html_slicer 0.0.4

data/html_slicer.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "html_slicer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "html_slicer"
+  s.version     = HtmlSlicer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Valery Kvon"]
+  s.email       = ["addagger@gmail.com"]
+  s.homepage    = %q{http://github.com/addagger/HtmlSlicer}
+  s.summary     = %q{HTML text slicer}
+  s.description = %q{A "smart" way to slice HTMLsed text to pages, also it can optionally resize included "width/height" attributes of HTML tags like <iframe>, <object>, <img> etc.}
+  
+  s.add_development_dependency "actionpack", ['>= 3.0.0']
+
+  s.rubyforge_project = "html_slicer"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.licenses = ['MIT']
+  
+end

data/lib/html_slicer/config.rb

@@ -0,0 +1,85 @@
+require 'active_support/configurable'
+
+module HtmlSlicer
+  # Configures global settings for HtmlSlicer
+  #
+  # === Default global configuration options
+  #
+  #   window = 4
+  #   outer_window = 0
+  #   left = 0
+  #   right = 0
+  #   param_name = :slice
+  #
+  # === Override/complete global configuration
+  #
+  #   HtmlSlicer.configure do |config|
+  #     config.slice = {:complete => /\s+|\z/, :maximum => 2000}
+  #     config.resize = {:width => 300, :only => {:tag => 'iframe'}}
+  #     config.window = 5
+  #     config.param_name = :any_other_param_name
+  #   end
+  #
+  # === Passing an argument (:symbol) creates stylized configuration, which can be used like that:
+  #   
+  #   HtmlSlicer.configure(:paged) do |config|
+  #     config.as = :page
+  #     config.param_name = :page
+  #   end
+  #
+  #   class Post < ActiveRecord::Base
+  #     slice :content, :config => :paged
+  #   end
+  #
+  # * Missing required parameters pick up automatically from global configuration set before.
+  # 
+  def self.configure(style = nil, &block)
+    yield eval("@config#{"_#{style}" if style} ||= #{style ? "@config.duplicate" : "Configuration.new"}")
+  end
+  
+  # Config accessor for HtmlSlicer. Accepts argument as a +style+.
+  def self.config(style = nil)
+    eval("@config#{"_#{style}" if style}")
+  end
+  
+  # need a Class for 3.0
+  class Configuration #:nodoc:
+    
+    include ActiveSupport::Configurable
+    include HtmlSlicer::Utilities::Deepcopy
+    
+    config_accessor :as
+    config_accessor :slice
+    config_accessor :resize
+    config_accessor :processors
+    config_accessor :window
+    config_accessor :outer_window
+    config_accessor :left
+    config_accessor :right
+    config_accessor :param_name
+
+    def slice # Ugly coding. Override Hash::slice method
+      config[:slice]
+    end
+
+    def param_name
+      config.param_name.respond_to?(:call) ? config.param_name.call : config.param_name
+    end
+    
+    def duplicate
+      dup = Configuration.new
+			dup.config.replace(deepcopy(config))
+			dup
+    end
+    
+  end
+  
+  configure do |config| # Setup default global configuration
+    config.window = 4
+    config.outer_window = 0
+    config.left = 0
+    config.right = 0
+    config.param_name = :slice
+  end
+  
+end

data/lib/html_slicer/engine.rb

@@ -0,0 +1,4 @@
+module HtmlSlicer #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/html_slicer/helpers/action_view_extension.rb

@@ -0,0 +1,92 @@
+# This part of code is almost completely ported from +Kaminari+ gem by Akira Matsuda.
+# Look at http://github.com/amatsuda/kaminari/tree/master/lib/kaminari/helpers
+module HtmlSlicer
+
+  # The part of code, processing the +:param_name+ was rewritten by me.
+  # Now you can define +:param_name+ as a +symbol+ or +string+, or as an +array of any object that responses +.to_s+ method and returns +string+.
+  # Passing +array+ is the way to define nested :param_name.
+  #
+  # === Examples:
+  # 
+  #   :param_name => :page
+  #   # means you define params[:page] as a slice key.
+  #
+  #   :param_name => [:article, :page]
+  #   # means you define params[:article][:page] as a slice key.
+  #
+  
+  module ActionViewExtension
+    # A helper that renders the pagination links.
+    #
+    #   <%= slicer @article.paged %>
+    #
+    # ==== Options
+    # * <tt>:window</tt> - The "inner window" size (4 by default).
+    # * <tt>:outer_window</tt> - The "outer window" size (0 by default).
+    # * <tt>:left</tt> - The "left outer window" size (0 by default).
+    # * <tt>:right</tt> - The "right outer window" size (0 by default).
+    # * <tt>:params</tt> - url_for parameters for the links (:controller, :action, etc.)
+    # * <tt>:param_name</tt> - parameter name for slice number in the links. Accepts +symbol+, +string+, +array+.
+    # * <tt>:remote</tt> - Ajax? (false by default)
+    # * <tt>:ANY_OTHER_VALUES</tt> - Any other hash key & values would be directly passed into each tag as :locals value.
+    def slice(object, options = {}, &block)
+      slicer = HtmlSlicer::Helpers::Slicer.new self, object.options.reverse_merge(options).reverse_merge(:current_slice => object.current_slice, :slice_number => object.slice_number, :remote => false)
+      slicer.to_s
+    end
+
+    # A simple "Twitter like" pagination link that creates a link to the next slice.
+    #
+    # ==== Examples
+    # Basic usage:
+    #
+    #   <%= link_to_next_slice @article.paged, 'Next page' %>
+    #
+    # Ajax:
+    #
+    #   <%= link_to_next_slice @article.paged, 'Next page', :remote => true %>
+    #
+    # By default, it renders nothing if there are no more results on the next slice.
+    # You can customize this output by passing a block.
+    #
+    #   <%= link_to_next_slice @article.paged, 'Next page' do %>
+    #     <span>No More slices</span>
+    #   <% end %>
+    def link_to_next_slice(object, name, options = {}, &block)
+      params = options[:params] ? self.params.merge(options.delete :params) : self.params
+      param_name = options.delete(:param_name) || object.options.param_name
+      link_to_unless object.last_slice?, name, HtmlSlicer::SmartParams.new(params, param_name, (object.current_slice + 1)), options.reverse_merge(:rel => 'next') do
+        block.call if block
+      end
+    end
+
+    # Renders a helpful message with numbers of displayed vs. total entries.
+    # Ported from mislav/will_paginate
+    #
+    # ==== Examples
+    # Basic usage:
+    #
+    #   <%= slice_entries_info @article.paged %>
+    #   #-> Displaying paged 6 of 26
+    #
+    # By default, the message will use the stringified +method_name (+:as+ option)+ implemented as slicer method.
+    # Override this with the <tt>:entry_name</tt> parameter:
+    #
+    #   <%= slice_entries_info @article.paged, :entry_name => 'page' %>
+    #   #-> Displaying page 6 of 26
+    def slice_entries_info(object, options = {})
+      entry_name = options[:entry_name] || object.options.as
+      output = ""
+      if object.slice_number < 2
+        output = case object.slice_number
+        when 0 then "No #{entry_name} found"
+        when 1 then "Displaying <b>1</b> #{entry_name}"
+        else; "Displaying <b>all #{object.slice_number}</b> #{entry_name.to_s.pluralize}"
+        end
+      else
+        output = %{Displaying #{entry_name} <b>#{object.current_slice}</b> of <b>#{object.slice_number}</b>}
+      end
+      output.html_safe
+    end
+  end
+	
+end

data/lib/html_slicer/helpers/slicer.rb

@@ -0,0 +1,184 @@
+# This part of code is almost completely ported from +Kaminari+ gem by Akira Matsuda.
+# Look at http://github.com/amatsuda/kaminari/tree/master/lib/kaminari/helpers
+
+require 'active_support/inflector'
+require 'action_view'
+require 'action_view/log_subscriber'
+require 'action_view/context'
+require 'html_slicer/helpers/smart_params'
+require 'html_slicer/helpers/tags'
+
+module HtmlSlicer
+  
+  module Helpers
+    # The main container tag
+    
+    # Configure ActiveSupport inflections to pluralize 'slice' in a correct way = 'slices'. # By default would be 'slouse'.
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.plural 'slice', 'slices'
+      inflect.singular 'slice', 'slice'
+    end
+    
+    class Slicer < Tag
+      # so that this instance can actually "render"
+      include ::ActionView::Context
+
+      def initialize(template, options) #:nodoc:
+        @window_options = {}.tap do |h|
+          h[:window] = options.delete(:window) || options.delete(:inner_window)
+          outer_window = options.delete(:outer_window)
+          h[:left] = options.delete(:left)
+          h[:left] = outer_window if h[:left] == 0
+          h[:right] = options.delete(:right)
+          h[:right] = outer_window if h[:right] == 0
+        end
+        @template, @options = template, options
+        @theme = @options[:theme] ? "#{@options[:theme]}/" : ''
+        @options[:current_slice] = SliceProxy.new @window_options.merge(@options), @options[:current_slice], nil
+        # initialize the output_buffer for Context
+        @output_buffer = ActionView::OutputBuffer.new
+      end
+
+      # render given block as a view template
+      def render(&block)
+        instance_eval &block if @options[:slice_number] > 1
+        @output_buffer
+      end
+
+      # enumerate each slice providing sliceProxy object as the block parameter
+      # Because of performance reason, this doesn't actually enumerate all slices but slices that are seemingly relevant to the paginator.
+      # "Relevant" slices are:
+      # * slices inside the left outer window plus one for showing the gap tag
+      # * slices inside the inner window plus one on the left plus one on the right for showing the gap tags
+      # * slices inside the right outer window plus one for showing the gap tag
+      def each_relevant_slice
+        return to_enum(:each_relevant_slice) unless block_given?
+
+        relevant_slices(@window_options.merge(@options)).each do |i|
+          yield SliceProxy.new(@window_options.merge(@options), i, @last)
+        end
+      end
+      alias each_slice each_relevant_slice
+
+      def relevant_slices(options)
+        left_window_plus_one = 1.upto(options[:left] + 1).to_a
+        right_window_plus_one = (options[:slice_number] - options[:right]).upto(options[:slice_number]).to_a
+        inside_window_plus_each_sides = (options[:current_slice] - options[:window] - 1).upto(options[:current_slice] + options[:window] + 1).to_a
+
+        (left_window_plus_one + inside_window_plus_each_sides + right_window_plus_one).uniq.sort.reject {|x| (x < 1) || (x > options[:slice_number])}
+      end
+      private :relevant_slices
+
+      def slice_tag(slice)
+        @last = Slice.new @template, @options.merge(:slice => slice)
+      end
+
+      %w[first_slice prev_slice next_slice last_slice gap].each do |tag|
+        eval <<-DEF
+          def #{tag}_tag
+            @last = #{tag.classify}.new @template, @options
+          end
+        DEF
+      end
+
+      def to_s #:nodoc:
+        subscriber = ActionView::LogSubscriber.log_subscribers.detect {|ls| ls.is_a? ActionView::LogSubscriber}
+        return super @window_options.merge(@options).merge :slicer => self unless subscriber
+
+        # dirty hack to suppress logging render_partial
+        class << subscriber
+          alias_method :render_partial_with_logging, :render_partial
+          # do nothing
+          def render_partial(event); end
+        end
+
+        ret = super @window_options.merge(@options).merge :slicer => self
+
+        class << subscriber
+          alias_method :render_partial, :render_partial_with_logging
+          undef :render_partial_with_logging
+        end
+        ret
+      end
+
+      # Wraps a "slice number" and provides some utility methods
+      class SliceProxy
+        include Comparable
+
+        def initialize(options, slice, last) #:nodoc:
+          @options, @slice, @last = options, slice, last
+        end
+
+        # the slice number
+        def number
+          @slice
+        end
+
+        # current slice or not
+        def current?
+          @slice == @options[:current_slice]
+        end
+
+        # the first slice or not
+        def first?
+          @slice == 1
+        end
+
+        # the last slice or not
+        def last?
+          @slice == @options[:slice_number]
+        end
+
+        # the previous slice or not
+        def prev?
+          @slice == @options[:current_slice] - 1
+        end
+
+        # the next slice or not
+        def next?
+          @slice == @options[:current_slice] + 1
+        end
+
+        # within the left outer window or not
+        def left_outer?
+          @slice <= @options[:left]
+        end
+
+        # within the right outer window or not
+        def right_outer?
+          @options[:slice_number] - @slice < @options[:right]
+        end
+
+        # inside the inner window or not
+        def inside_window?
+          (@options[:current_slice] - @slice).abs <= @options[:window]
+        end
+
+        # The last rendered tag was "truncated" or not
+        def was_truncated?
+          @last.is_a? Gap
+        end
+
+        def to_i
+          number
+        end
+
+        def to_s
+          number.to_s
+        end
+
+        def +(other)
+          to_i + other.to_i
+        end
+
+        def -(other)
+          to_i - other.to_i
+        end
+
+        def <=>(other)
+          to_i <=> other.to_i
+        end
+      end
+    end
+  end
+end

data/lib/html_slicer/helpers/smart_params.rb

@@ -0,0 +1,35 @@
+module HtmlSlicer
+
+  class SmartParams < Hash
+    # Implements smart and flexible +params+ merging.
+    # Method accepts passed +params+ hash and merge it with a new +param_name+ and it's value.
+    # In the case when you passed +param_name+ option as an Array, method returns merged new
+    # instance of hashed params where all subhashes merged into the same way.
+    #
+    # === Example:
+    #
+    #   params = {:controller => "comments", :action => "show", :id => 34, :article_id => 3, :page => {:article => 2}}
+    #
+    #   :slice_params => [:page, :comment]
+    #
+    #   HtmlSlicer::SmartParams.new(params, slice_params, 34)
+    #   # => {:controller => "comments", :action => "show", :id => 34, :article_id => 3, :page => {:article => 2, :comment => 34}}
+    #    
+    def initialize(params = {}, param_name = nil, value = nil)
+      super()
+      param_subhash = case param_name
+      when Array then hashup(param_name.collect {|e| e.to_s} << value)
+      when String, Symbol then {param_name.to_s => value}
+      else {}
+      end
+      update(nested_merge(params, param_subhash))
+    end
+ 
+    private
+    
+    include HtmlSlicer::Utilities::HashupArray
+    include HtmlSlicer::Utilities::NestedMergeHash
+    
+  end
+  
+end

data/lib/html_slicer/helpers/tags.rb

@@ -0,0 +1,100 @@
+# This part of code is almost completely ported from +Kaminari+ gem by Akira Matsuda.
+# Look at http://github.com/amatsuda/kaminari/tree/master/lib/kaminari/helpers
+module HtmlSlicer
+  module Helpers
+    
+    # A tag stands for an HTML tag inside the paginator.
+    # Basically, a tag has its own partial template file, so every tag can be
+    # rendered into String using its partial template.
+    #
+    # The template file should be placed in your app/views/html_slicer/ directory
+    # with underscored class name (besides the "Tag" class. Tag is an abstract
+    # class, so _tag parital is not needed).
+    #   e.g.)  PrevLink  ->  app/views/html_slicer/_prev_link.html.erb
+    #
+    # When no matching template were found in your app, the engine's pre
+    # installed template will be used.
+    #   e.g.)  Paginator  ->  $GEM_HOME/html_slicer-x.x.x/app/views/html_slicer/_paginator.html.erb
+        
+    class Tag    
+      def initialize(template, options = {}) #:nodoc:
+        @template, @options = template, options.dup
+        @param_name = @options.delete(:param_name)
+        @theme = @options[:theme] ? "#{@options.delete(:theme)}/" : ''
+        @params = @options[:params] ? template.params.merge(@options.delete :params) : template.params        
+      end
+      
+      def to_s(locals = {}) #:nodoc:
+        @template.render :partial => "html_slicer/#{@theme}#{self.class.name.demodulize.underscore}", :locals => @options.merge(locals)
+      end
+
+      def slice_url_for(slice)
+        # +HtmlSlicer::SmartParams+: return deep merged params with a new slice number value.
+        @template.url_for HtmlSlicer::SmartParams.new(@params, @param_name, (slice <= 1 ? nil : slice))
+      end
+    end
+
+    # Tag that contains a link
+    module Link
+      # target slice number
+      def slice
+        raise 'Override slice with the actual slice value to be a slice.'
+      end
+      # the link's href
+      def url
+        slice_url_for slice
+      end
+      def to_s(locals = {}) #:nodoc:
+        super locals.merge(:url => url)
+      end
+    end
+
+    # A slice
+    class Slice < Tag
+      include Link
+      # target slice number
+      def slice
+        @options[:slice]
+      end
+      def to_s(locals = {}) #:nodoc:
+        super locals.merge(:slice => slice)
+      end
+    end
+
+    # Link with slice number that appears at the leftmost
+    class FirstSlice < Tag
+      include Link
+      def slice #:nodoc:
+        1
+      end
+    end
+
+    # Link with slice number that appears at the rightmost
+    class LastSlice < Tag
+      include Link
+      def slice #:nodoc:
+        @options[:slice_number]
+      end
+    end
+
+    # The "previous" slice of the current slice
+    class PrevSlice < Tag
+      include Link
+      def slice #:nodoc:
+        @options[:current_slice] - 1
+      end
+    end
+
+    # The "next" slice of the current slice
+    class NextSlice < Tag
+      include Link
+      def slice #:nodoc:
+        @options[:current_slice] + 1
+      end
+    end
+
+    # Non-link tag that stands for skipped slices...
+    class Gap < Tag
+    end
+  end
+end

data/lib/html_slicer/installer.rb

@@ -0,0 +1,118 @@
+module HtmlSlicer
+  
+  module Installer
+    
+    # The basic implementation method.
+    #
+    #   slice <method_name>, <configuration>, [:config => <:style>]*
+    #
+    # where: 
+    # * <method_name> - any method or local variable which returns source String (can be called with .send()).
+    # * <configuration> - Hash of configuration options and/or +:config+ parameter.
+    #
+    # === Example:
+    # 
+    #   class Article < ActiveRecord::Base
+    #     slice :content, :as => :paged, :slice => {:maximum => 2000}, :resize => {:width => 600}
+    #   end
+    #
+    # === Where:
+    # * <tt>:content</tt> is a method name or local variable, that return a target String object.
+    # * <tt>:as</tt> is a name of basic accessor for result.
+    # * <tt>:slice</tt> is a hash of +slicing options+.
+    # * <tt>:resize</tt> is a hash of +resizing options+.
+    # 
+    # You can define any key of configuration you want. Otherwise, default configuration
+    # will be picked up automatically.
+    # 
+    # === All configuration keys:
+    # * <tt>:as</tt> is a name of basic accessor for sliced +object+.
+    # * <tt>:slice</tt> is a hash of slicing options*.
+    # * <tt>:resize</tt> is a hash of resizing options*.
+    # * <tt>:processors</tt> - processors names*.
+    # * <tt>:window</tt> - parameter for ActionView: The "inner window" size (4 by default).
+    # * <tt>:outer_window</tt> - parameter for ActionView: The "outer window" size (0 by default).
+    # * <tt>:left</tt> - parameter for ActionView: The "left outer window" size (0 by default).
+    # * <tt>:right</tt> - parameter for ActionView: The "right outer window" size (0 by default).
+    # * <tt>:params</tt> - parameter for ActionView: url_for parameters for the links (:controller, :action, etc.)
+    # * <tt>:param_name</tt> - parameter for ActionView: parameter name for slice number in the links. Accepts +symbol+, +string+, +array+.
+    # * <tt>:remote</tt> - parameter for ActionView: Ajax? (false by default)
+    #
+    # === Block-style configuration example:
+    # 
+    #   slice *args do |config|
+    #     config.as = :paged
+    #     config.slice.merge! {:maximum => 1500}
+    #     config.resize = nil
+    #   end
+    #
+    #   # *args = method name or local variable, and/or +:config+ parameter.
+    #
+    #
+    # === Premature configuration (+:config+ parameter):
+    # Stylizied general configuration can be used for many implementations, such as:
+    #   
+    #  # For example, we set the global stylized config:
+    #
+    #   HtmlSlicer.configure(:paged_config) do |config|
+    #     config.as = :page
+    #     config.slice = {:maximum => 300}
+    #     config.window = 4
+    #     config.outer_window = 0
+    #     config.left = 0
+    #     config.right = 0
+    #     config.param_name = :slice
+    #   end
+    #   
+    #  # Now we can use it as next:
+    #
+    #   slice *args, :config => :paged_config
+    #     
+    #   You can also pass another configuration options directrly as arguments
+    #   and/or the block to clarify the config along with used global:
+    #
+    #   slice *args, :as => :chapter, :config => :paged_config do |config|
+    #     config.slice.merge! {:unit => {:tag => 'h1', :class => 'chapter'}, :maximum => 1}
+    #   end
+    #
+    # === Skipping slicing:
+    # 
+    #   To skip slicing (for example, if you want to use only resizing feature)
+    #   you can nilify +slice+ option at all:
+    #   
+    #   slice :content, :slice => nil, :resize => {:width => 300}
+    #
+    #   Notice: without +:slice+ neither +:resize+ options, using HtmlSlicer becomes meaningless. :)
+    #
+    # === See README.rdoc for details about +:slice+ and +:resize+ options etc.
+    #
+    def slice(*args, &block)
+      attr_name = args.first
+      raise(NameError, "Attribute name expected!") unless attr_name
+      
+      options = args.extract_options!
+      config = HtmlSlicer.config(options.delete(:config)).duplicate # Configuration instance for each single one implementation
+      if options.present? # Accepts options from args
+        options.each do |key, value|
+          config.send("#{key}=", value)
+        end
+      end
+      if block_given? # Accepts options from block
+        yield config
+      end
+      if config.processors
+        Array.wrap(config.processors).each do |name|
+          HtmlSlicer.load_processor!(name)
+        end
+      end
+      method_name = config.as||"#{attr_name}_slice"
+      class_exec do
+        define_method method_name do
+          var_name = "@_#{method_name}"
+          instance_variable_get(var_name)||instance_variable_set(var_name, HtmlSlicer::Interface.new(send(attr_name), config.config))
+        end
+      end
+    end
+  end
+  
+end