html_slicer 0.0.7 → 0.1.0

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 0.1.0
+
+* The big changes. :)
+* Code has been optimized and rewritten by ~70%.
+* Caching option provided.
+
 == 0.0.7
 
 * Code refactoring.

data/README.rdoc

@@ -65,6 +65,7 @@ where:
 * <tt>:as</tt> is a name of basic accessor for result.
 * <tt>:slice</tt> is a hash of <tt>slicing options</tt> as a part of configuration.
 * <tt>:resize</tt> is a hash of <tt>resizing options</tt> as a part of configuration.
+* <tt>:cache_to</tt> is an accessor name used to store the cache. +True+ value make it by default.
 
 You can define any configuration key you want. Otherwise, default configuration options (if available) will be picked up automatically.
   
@@ -198,7 +199,7 @@ you can override/complete any configuration.
 By applying +:config+ key you can use one of stylized configurations:
   
   class Post < ActiveRecord::Base
-    slice :content, :config => :paged, :slice = {:complete => /\s+/, :maximum => 3000}
+    slice :content, :config => :paged, :slice => {:complete => /\s+/, :maximum => 3000}
   end
 
 Through passing the block you get a more flexible approach to configure slicer:
@@ -304,6 +305,52 @@ Examples:
   :param_name => [:article, :page]
   # means you define params[:article][:page] as a slice key.
 
+== Caching
+
+Caching implies that resizing/slicing procedures is both time-consuming processes will be started only at once, and once again will be launched only if the target content has been changed or resizing/slicing options has been modified.
+
+For caching, pass the option: <tt>:cache_to => true</tt> or <tt>:cache_to => :any_other_accessor</tt> within your config definition.
+
+=== ActiveRecord model
+
+Example:
+
+  class Article < ActiveRecord::Base
+    slice :content, :as => :paged, :slice => {:maximum => 1000, :complete => /\s+|\z/}, :cache_to => :content_page_cache
+  end
+
+Accessor method <tt>.content_page_cache=</tt> used for caching here.
+The first time when resizing and slicing procedures is called, generated maps will be cached and assigned to <tt>.content_page_cache</tt> accessor. Before the article saves itself, assigned dump stuff is recorded like any other attribute of article (callback <tt>before_save</tt> is set up). 
+
+Of course, attribute is recorded only as a column of the database :), So, before, add the column to a model:
+
+<tt>% rails generate migration AddContentPageCacheToArticle content_page_cache:text</tt>
+
+<tt>% rake db:migrate </tt>
+
+Slicing/resizing procedures repeat again only if target content has been changed or options has been modified. 
+
+=== ActiveModel
+
+Example:
+
+  class TextModel
+    attr_accessor :text, :paged_cache
+  
+    extend HtmlSlicer::Installer
+  
+    slice :text, :as => :paged, :slice => {:complete => /\s+/, :maximum => 300}, :cache_to => true
+  
+    def initialize(text)
+      @text = text
+    end
+  
+  end
+
++True+ value of <tt>:cache_to</tt> option set default cache accessor name consisted of basic accessor name + <tt>_page</tt>.
+
+In fact, caching ActiveModel not so significant in most cases, but still works. The next time you call slicing method, the cached resizing/slicing map(s) will be used.
+
 == More
 
 === Slicing a general String or ActiveModel (or any other) object

data/lib/html_slicer/cached_stuff.rb

@@ -0,0 +1,70 @@
+require 'digest/sha1'
+
+module HtmlSlicer
+  # Object to be serialized and dumped as cache storage.
+  # Include +resizing+ and +slicing+ objects, and original text's hexdigest hash value to provide authenticity.
+  # During the runtime object is used as an +maps+ accessor too.
+  
+  class CachedStuff
+    attr_reader :hexdigest, :resizing, :slicing
+    attr_accessor :changed, :time
+    
+    def initialize(text = nil)
+      @changed = false
+      self.hexdigest_for = text if text
+    end
+    
+    def hexdigest_for=(text)
+      hex = Digest::SHA1.hexdigest(text)
+      unless hex == @hexdigest
+        @changed = true
+        @hexdigest = hex
+      end
+      hex
+    end
+    
+    def slicing=(object)
+      case object
+      when HtmlSlicer::Mappers::Slicing, nil then
+        @changed = true unless object.try(:options).try(:hexdigest) == @slicing.try(:options).try(:hexdigest)
+        @slicing = object
+      else
+        raise(TypeError, "HtmlSlicer::Mappers::Slicing or nil expected, '#{object.class}' passed")
+      end
+    end
+    
+    def resizing=(object)
+      case object
+      when HtmlSlicer::Mappers::Resizing, nil then
+        @changed = true unless object.try(:options).try(:hexdigest) == @slicing.try(:options).try(:hexdigest)
+        @resizing = object
+      else
+        raise(TypeError, "HtmlSlicer::Mappers::Resizing or nil expected, '#{object.class}' passed")
+      end
+    end
+    
+    def valid_text?(text)
+      Digest::SHA1.hexdigest(text) == @hexdigest
+    end
+    
+    def valid_resizing_options?(options)
+      options.try(:hexdigest) == @resizing.try(:options).try(:hexdigest)
+    end
+
+    def valid_slicing_options?(options)
+      options.try(:hexdigest) == @slicing.try(:options).try(:hexdigest)
+    end
+
+    def changed?
+      @changed
+    end
+    
+    # Serialize self, using Marshal and Base64 encoding
+    def to_dump
+      @time = Time.now
+      Base64.encode64(Marshal.dump(self))
+    end
+    
+  end
+  
+end

data/lib/html_slicer/config.rb

@@ -39,7 +39,7 @@ module HtmlSlicer
   
   # Config accessor for HtmlSlicer. Accepts argument as a +style+.
   def self.config(style = nil)
-    eval("@config#{"_#{style}" if style}")
+    eval("@config#{"_#{style}" if style}") || raise("Config style '#{style}' is invalid.")
   end
   
   # need a Class for 3.0
@@ -57,6 +57,7 @@ module HtmlSlicer
     config_accessor :left
     config_accessor :right
     config_accessor :param_name
+    config_accessor :cache_to
 
     def slice # Ugly coding. Override Hash::slice method
       config[:slice]

data/lib/html_slicer/installer.rb

@@ -105,12 +105,18 @@ module HtmlSlicer
         end
       end
       method_name = config.as||"#{attr_name}_slice"
-      class_exec do
+      config.cache_to = "#{method_name}_cache" if config.cache_to == true
+      class_eval do
         define_method method_name do
           var_name = "@_#{method_name}"
           instance_variable_get(var_name)||instance_variable_set(var_name, HtmlSlicer::Interface.new(self, attr_name, config.config))
         end
       end
+      if config.cache_to && self.superclass == ActiveRecord::Base
+        before_save do
+          send(method_name).load!
+        end
+      end
     end
     
   end

data/lib/html_slicer/interface.rb

@@ -1,3 +1,9 @@
+require 'html_slicer/options'
+require 'html_slicer/processor'
+require 'html_slicer/cached_stuff'
+require 'html_slicer/mappers/slicing'
+require 'html_slicer/mappers/resizing'
+
 module HtmlSlicer
   
   # Interface code.
@@ -10,17 +16,75 @@ module HtmlSlicer
   #
   
   class Interface # General accessor instance
-    attr_reader :options, :current_slice, :document
-        
-    delegate :sliced?, :resized?, :slice_number, :to => :document
-    
+    include HtmlSlicer::Mappers
+   
+    attr_reader :options, :document, :current_slice, :cached_stuff
+
+    delegate :slicing, :resizing, :to => :cached_stuff
+
     def initialize(env, method_name, options = {})
+      @env, @method_name = env, method_name
       @options = options
-      @document = Document.new(env, method_name, options)
+      @resizing_options = ResizingOptions.new(options[:resize]) if options[:resize]
+      @slicing_options = SlicingOptions.new(options[:slice]) if options[:slice]
       @current_slice = 1
+      load!
+    end
+    
+    # Getting source content
+    def source
+      case options[:processors].present?
+      when true then HtmlSlicer::Process.iterate(@env.send(@method_name), options[:processors])
+      else
+        @env.send(@method_name)
+      end
     end
 
-    # General slicing method. Passing the argument changes the slice.
+    # Process initializer
+    def load!
+      text = source
+      @cached_stuff ||= 
+      begin
+        if options[:cache_to] # Getting recorded hash dump
+          Marshal.load(Base64.decode64(@env.send(options[:cache_to])))
+        else
+          raise Exception
+        end
+      rescue Exception, TypeError, NoMethodError # New cache object otherwise
+        CachedStuff.new
+      end
+      if @document.blank? || !@cached_stuff.valid_text?(text) # Initialize new @document if not exist or content has been changed
+        @document = HTML::Document.new(text)
+        @cached_stuff.hexdigest_for = text
+      end
+      if @cached_stuff.changed? || !@cached_stuff.valid_resizing_options?(@resizing_options) # Initialize new resizing process if the content or options has been changed
+        if @resizing_options
+          @cached_stuff.resizing = Resizing.new(@document, @resizing_options)
+        else
+          @cached_stuff.resizing = nil
+        end
+      end
+      if @cached_stuff.changed? || !@cached_stuff.valid_slicing_options?(@slicing_options) # Initialize new slicing process if the content or options has been changed
+        if @slicing_options
+          @cached_stuff.slicing = Slicing.new(@document, @slicing_options)
+        else
+          @cached_stuff.slicing = nil
+        end
+      end
+      if @cached_stuff.changed? # Serialize and dump the cache if any changes provided
+        @cached_stuff.changed = false
+        if options[:cache_to]
+          @env.send("#{options[:cache_to]}=", @cached_stuff.to_dump)
+        end
+      end
+    end
+
+    # Return number of slices.
+    def slice_number
+      sliced? ? slicing.slice_number : 1
+    end
+
+    # General slicing method. Passing the argument changes the +current_slice+.
     def slice!(slice = nil)
       raise(Exception, "Slicing unavailable!") unless sliced?
       if slice.present?
@@ -32,10 +96,10 @@ module HtmlSlicer
       end
       self
     end
-    
-    # Textual representation according to a current slice.
+
     def to_s
-      document.to_s(current_slice)
+      load!
+      view(document.root, @current_slice)
     end
     
     def inspect
@@ -45,10 +109,66 @@ module HtmlSlicer
     def method_missing(*args, &block)
       to_s.send(*args, &block)
     end
+
+    # True if any HTML tag has been resized
+    def resized?
+      resizing ? resizing.map.any? : false
+    end
     
+    # True if any part of document has been sliced
+    def sliced?
+      slicing ? slicing.map.any? : false
+    end
+
     # Return the current slice is a last or not?
     def last_slice?
       current_slice == slice_number
+    end    
+
+    private
+
+    # Return a textual representation of the node including all children.
+    def view(node, slice)
+      slice = slice.to_i
+      case node
+      when HTML::Tag then
+        children_view = node.children.collect {|child| view(child, slice)}.compact.join
+        if resized?
+          resizing.resize_node(node)
+        end
+        if sliced?
+          if slicing.map.get(node, slice) || children_view.present?
+            if node.closing == :close
+              "</#{node.name}>"
+            else
+              s = "<#{node.name}"
+              node.attributes.each do |k,v|
+                s << " #{k}"
+                s << "=\"#{v}\"" if String === v
+              end
+              s << " /" if node.closing == :self
+              s << ">"
+              s += children_view
+              s << "</#{node.name}>" if node.closing != :self && !node.children.empty?
+              s
+            end
+          end
+        else
+          node.to_s
+        end
+      when HTML::Text then
+        if sliced?
+          if range = slicing.map.get(node, slice)
+            "#{node.content[Range.new(*range)]}#{slicing.options.text_break unless range.last == -1}"
+          end
+        else
+          node.to_s
+        end
+      when HTML::CDATA then
+        node.to_s
+      when HTML::Node then
+        node.children.collect {|child| view(child, slice)}.compact.join
+      end
     end
 
   end

data/lib/html_slicer/{makers → mappers}/resizing.rb

@@ -1,17 +1,38 @@
 module HtmlSlicer
-  module Makers
+  module Mappers
     
-    class Resizing # Resizing engine
-      attr_reader :options
-    
-      def initialize(document, options = {})
+    class Resizing # Resizing engine, generate and store slicing Map (hash)
+      attr_reader :options, :map
+
+      class Map < Hash #:nodoc:
+        include HtmlSlicer::Utilities::NodeIdent
+        
+        def commit(node, width, height)
+          self[node_identify(node)] = [width, height]
+        end
+        def width(node)
+          self[node_identify(node)].try(:first)
+        end
+        def height(node)
+          self[node_identify(node)].try(:last)
+        end
+      end    
+
+      def initialize(document, options)
         raise(TypeError, "HTML::Document expected, '#{document.class}' passed") unless document.is_a?(HTML::Document)
-        @options = ResizeOptions.new(options)
-        resize_document!(document.root)
+        raise(TypeError, "HtmlSlicer::Options expected, '#{options.class}' passed") unless options.is_a?(HtmlSlicer::Options)
+        @options = options
+        @map = Map.new
+        process!(document.root)
       end
-    
-      def did?
-        @did||false
+
+      def resize_node(node)
+        if w = @map.width(node)
+          width(node) { w.to_s }
+        end
+        if h = @map.height(node)
+          height(node) { h.to_s }
+        end
       end
 
       private
@@ -19,9 +40,18 @@ module HtmlSlicer
       include HtmlSlicer::Utilities::ParseNode
       include HtmlSlicer::Utilities::NodeMatchExtension
 
-      def resize_document!(root)
+      def process!(root)
         parse(root) do |node|
-          resize!(node) if node.is_a?(HTML::Tag) && resizeable?(node)
+          if node.is_a?(HTML::Tag) && resizeable?(node)
+            target_width = node.parent.is_a?(HTML::Tag) ? @map.width(node.parent)||@options.width : @options.width
+            if target_width.present? && node_width = width(node)
+              node_height = height(node)
+              if node_width > target_width
+                ratio = node_width.to_f/target_width
+                @map.commit(node, target_width, node_height ? (node_height/ratio).round : nil)
+              end
+            end
+          end
         end
       end
 
@@ -31,7 +61,7 @@ module HtmlSlicer
 
       def width(node)
         values = []
-        if block_given?
+        if block_given? && node.attributes.has_key?("width")
           node.attributes["width"] = yield
         else
           values << absolute_resolution(node.attributes["width"])
@@ -53,7 +83,7 @@ module HtmlSlicer
 
       def height(node)
         values = []
-        if block_given?
+        if block_given? && node.attributes.has_key?("height")
           node.attributes["height"] = yield
         else
           values << absolute_resolution(node.attributes["height"])
@@ -73,19 +103,6 @@ module HtmlSlicer
         values.compact.min
       end
 
-      def resize!(node)
-        target_width = node.parent.is_a?(HTML::Tag) ? width(node.parent)||@options.width : nil
-        if target_width.present? && node_width = width(node)
-          node_height = height(node)
-          if node_width > target_width
-            ratio = node_width.to_f/target_width
-            width(node) { target_width.to_s }
-            height(node) { (node_height/ratio).round.to_s } if node_height
-            @did = true
-          end
-        end
-      end
-
       def absolute_resolution(value)
         (value.present? && value.last != "%") ? value.to_i : nil
       end

data/lib/html_slicer/{makers → mappers}/slicing.rb

@@ -1,19 +1,28 @@
 module HtmlSlicer
-  module Makers
+  module Mappers
     
-    class Slicing # Slicing engine
-      attr_reader :options, :map
+    class Slicing # Slicing engine, generate and store resizing Map (hash)
+      attr_reader :options, :map, :slice_number
+      
+      class Map < Hash #:nodoc:
+        include HtmlSlicer::Utilities::NodeIdent
 
-      def initialize(document, options = {})
-        raise(TypeError, "HTML::Document expected, '#{document.class}' passed") unless document.is_a?(HTML::Document)
-        @options = SliceOptions.new(options)
-        @map = [Hash.new]
-        @options.unit.is_a?(Hash) ? slice_document_by_node!(document.root) : slice_document_by_text!(document.root)
+        def commit(node, number, value)
+          self[node_identify(node)] ||= {}
+          self[node_identify(node)].merge!(number => value)
+        end
+        def get(node, number)
+          self[node_identify(node)] ? self[node_identify(node)][number] : nil
+        end
       end
 
-      # Resturn number of slices.
-      def slice_number
-        @map.size
+      def initialize(document, options)
+        raise(TypeError, "HTML::Document expected, '#{document.class}' passed") unless document.is_a?(HTML::Document)
+        raise(TypeError, "HtmlSlicer::Options expected, '#{options.class}' passed") unless options.is_a?(HtmlSlicer::Options)
+        @options = options
+        @map = Map.new
+        @slice_number = 1
+        @options.unit.is_a?(Hash) ? process_by_node!(document.root) : process_by_text!(document.root)
       end
 
       private
@@ -21,7 +30,7 @@ module HtmlSlicer
       include HtmlSlicer::Utilities::ParseNode
       include HtmlSlicer::Utilities::NodeMatchExtension
 
-      def slice_document_by_text!(root)
+      def process_by_text!(root)
         units_count = 0
         parse(root) do |node|
           if node.is_a?(HTML::Text)
@@ -36,48 +45,48 @@ module HtmlSlicer
                   if units_count == @options.maximum
                     units_count = 0
                     index = complete!(content, match.end(0))
-                    @map.last[node.object_id] = Range.new(last_index, index-1)
+                    @map.commit(node, @slice_number, [last_index, index-1])
                     last_index = index
-                    limited? ? raise(Exception) : @map << Hash.new
+                    limited? ? raise(Exception) : @slice_number += 1
                   else
                     index = match.end(0)
                   end
                   if units_count > 0
-                    @map.last[node.object_id] = Range.new(last_index, -1)
+                    @map.commit(node, @slice_number, [last_index, -1])
                   end
                 end
               rescue Exception
                 break
               end
             else
-              @map.last[node.object_id] = Range.new(0, -1)
+              @map.commit(node, @slice_number, [0, -1])
             end
           else
-            @map.last[node.object_id] = true
+            @map.commit(node, @slice_number, true)
           end
         end
       end
 
-      def slice_document_by_node!(root)
+      def process_by_node!(root)
         units_count = 0
         parse(root) do |node|
           if node.is_a?(HTML::Text)
-            @map.last[node.object_id] = Range.new(0, -1)
+            @map.commit(node, @slice_number, [0, -1])
           else
-            @map.last[node.object_id] = true
+            @map.commit(node, @slice_number, true)
           end
           if node.match(@options.unit) && sliceable?(node)
             units_count += 1
             if units_count == @options.maximum
               units_count = 0
-              limited? ? break : @map << Hash.new
+              limited? ? break : @slice_number += 1
             end
           end
         end
       end
 
       def limited?
-        @options.limit && slice_number >= @options.limit
+        @options.limit && @slice_number >= @options.limit
       end
 
       def sanitize_content!(node)

data/lib/html_slicer/options.rb

@@ -1,3 +1,5 @@
+require 'digest/sha1'
+
 module HtmlSlicer
   
   # Make options adjective and convinient for processing needs.
@@ -5,15 +7,26 @@ module HtmlSlicer
   class Options #:nodoc:
     # Superclass
     attr_reader :only, :except
+
     def initialize(options)
       options ||= {}
       @only = options[:only]
       @except = options[:except]
     end
+
+    def hexdigest
+      Digest::SHA1.hexdigest(string_value)
+    end
+    
+    def string_value
+      instance_variables.collect {|name| name.to_s + ":" + instance_variable_get(name).to_s}.join
+    end
+    
   end
   
-  class SliceOptions < Options #:nodoc:
+  class SlicingOptions < Options #:nodoc:
     attr_reader :unit, :maximum, :complete, :text_break, :limit
+    
     def initialize(options)
       super(options)
       @unit = case options[:unit]
@@ -47,14 +60,17 @@ module HtmlSlicer
       end
       @text_break = options[:text_break]
     end
+
   end
   
-  class ResizeOptions < Options
+  class ResizingOptions < Options
     attr_reader :width
+    
     def initialize(options)
       super(options)
-      @width = options[:width]
+      @width = options[:width].to_i
     end
+
   end
   
 end

data/lib/html_slicer/utilities.rb

@@ -5,11 +5,19 @@ module HtmlSlicer
       def parse(node, &block)
         node.children.each do |node|
           yield node if block_given?
-          parse(node, &block) if node.is_a?(HTML::Tag)
+          if node.is_a?(HTML::Tag)
+            parse(node, &block)
+          end
         end
       end
     end
 
+    module NodeIdent
+      def node_identify(node)
+        [node.line, node.position]
+      end
+    end
+
     module Deepcopy
       # Return the 'deep' brand new copy of Hash or Array. All nested hashes/arrays rebuilded at the same way.
       def deepcopy(object)

data/lib/html_slicer/version.rb

@@ -1,3 +1,3 @@
 module HtmlSlicer
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/lib/html_slicer.rb

@@ -7,9 +7,6 @@ module HtmlSlicer
   def self.load!
     require 'html_slicer/utilities'
     require 'html_slicer/config'
-    require 'html_slicer/options'
-    require 'html_slicer/processor'
-    require 'html_slicer/document'
     require 'html_slicer/interface'
     require 'html_slicer/engine'
     require 'html_slicer/helpers/action_view_extension'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: html_slicer
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-22 00:00:00.000000000 Z
+date: 2012-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -82,8 +82,8 @@ files:
 - config/locales/html_slicer.yml
 - html_slicer.gemspec
 - lib/html_slicer.rb
+- lib/html_slicer/cached_stuff.rb
 - lib/html_slicer/config.rb
-- lib/html_slicer/document.rb
 - lib/html_slicer/engine.rb
 - lib/html_slicer/helpers/action_view_extension.rb
 - lib/html_slicer/helpers/slicer.rb
@@ -91,8 +91,8 @@ files:
 - lib/html_slicer/helpers/tags.rb
 - lib/html_slicer/installer.rb
 - lib/html_slicer/interface.rb
-- lib/html_slicer/makers/resizing.rb
-- lib/html_slicer/makers/slicing.rb
+- lib/html_slicer/mappers/resizing.rb
+- lib/html_slicer/mappers/slicing.rb
 - lib/html_slicer/models/active_record_extension.rb
 - lib/html_slicer/options.rb
 - lib/html_slicer/processor.rb

data/lib/html_slicer/document.rb

@@ -1,107 +0,0 @@
-require 'html_slicer/makers/slicing'
-require 'html_slicer/makers/resizing'
-
-module HtmlSlicer
-  
-  class Document # Framework
-    include HtmlSlicer::Makers
-    
-    attr_reader :options, :document, :slicing, :resizing
-    
-    delegate :root, :to => :document
-    
-    def initialize(env, method_name, options = {})
-      @options = options
-      @source = Proc.new do
-        if options[:processors].present?
-          HtmlSlicer::Process.iterate(env.send(method_name), options[:processors])
-        else
-          env.send(method_name)
-        end
-      end
-      prepare!
-    end
-    
-    # Resturn number of slices.
-    def slice_number
-      sliced? ? @slicing.slice_number : 1
-    end
-
-    def to_s(slice = 1)
-      prepare! if changed?
-      if sliced? && map = slicing.map[slice-1]      
-        view(root, map, slicing.options.text_break)
-      else
-        root
-      end
-    end
-    
-    def inspect
-      to_s
-    end
-    
-    def method_missing(*args, &block)
-      to_s.send(*args, &block)
-    end
-
-    def resized?
-      resizing.try(:did?)||false
-    end
-    
-    def sliced?
-      slicing.present?
-    end
-    
-    def changed?
-      @source_hash != @source.call.hash
-    end
-    
-    private
-
-    # Return a textual representation of the node including all children assigned to a +map+.
-    def view(node, map = {}, text_break = nil)
-      case node
-      when HTML::Tag then
-        children_view = node.children.collect {|child| view(child, map, text_break)}.compact.join
-        if map[node.object_id] || children_view.present?
-          if node.closing == :close
-            "</#{node.name}>"
-          else
-            s = "<#{node.name}"
-            node.attributes.each do |k,v|
-              s << " #{k}"
-              s << "=\"#{v}\"" if String === v
-            end
-            s << " /" if node.closing == :self
-            s << ">"
-            s += children_view
-            s << "</#{node.name}>" if node.closing != :self && !node.children.empty?
-            s
-          end
-        end
-      when HTML::Text then
-        if range = map[node.object_id]
-          "#{node.content[range]}#{text_break unless range.last == -1}"
-        end
-      when HTML::CDATA then
-        node.to_s
-      when HTML::Node then
-        node.children.collect {|child| view(child, map, text_break)}.compact.join
-      end
-    end
-        
-    # Mapping the original source.
-    def prepare!
-      @source_hash = @source.call.hash
-      @document = HTML::Document.new(@source.call)
-      if options[:resize]
-        @resizing = Resizing.new(document, options[:resize])
-      end
-      if options[:slice]
-        @slicing = Slicing.new(document, options[:slice])
-      end
-    end
-    
-  end
-  
-end