html_slicer 0.0.4

data/lib/html_slicer/interface.rb

@@ -0,0 +1,105 @@
+module HtmlSlicer
+  
+  class Interface # General accessor instance
+    attr_reader :document, :options, :current_slice
+
+    delegate :root, :to => :document
+    
+    def initialize(content, options = {})
+      raise(TypeError, "String object expected, '#{content.class}' passed") unless content.is_a?(String)
+      @options = options
+      @current_slice = 1
+      @document = HTML::Document.new(HtmlSlicer::Process.iterate(content, options[:processors]))
+      if @options[:slice]
+        @slicing = Slicing.new(document, @options[:slice])
+      end
+      if @options[:resize]
+        @resizing = Resizing.new(document, @options[:resize])
+      end
+    end
+
+    # Resturn number of slices.
+    def slice_number
+      sliced? ? @slicing.slice_number : 1
+    end
+
+    # General slicing method. Passing the argument changes the slice.
+    def slice!(slice = nil)
+      raise(Exception, "Slicing unavailable!") unless sliced?
+      if slice.present?
+        if slice.to_i.in?(1..slice_number)
+          @current_slice = slice.to_i
+        else
+          raise(ArgumentError, "Slice number must be Fixnum in (1..#{slice_number}). #{slice.inspect} passed.")
+        end
+      end
+      self
+    end
+    
+    # Textual representation according to a current slice.
+    def to_s
+      if sliced? && map = @slicing.map[current_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 sliced?
+      @slicing.present?
+    end
+    
+    def resized?
+      @resizing.present?
+    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 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
+
+  end
+  
+end

data/lib/html_slicer/models/active_record_extension.rb

@@ -0,0 +1,22 @@
+require 'html_slicer/installer'
+
+module HtmlSlicer
+  
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      class_eval do
+        include HtmlSlicer::Installer
+      end
+    end
+
+    module InstanceMethods
+
+    end
+            
+  end
+  
+end

data/lib/html_slicer/options.rb

@@ -0,0 +1,60 @@
+module HtmlSlicer
+  
+  # Make options adjective and convinient for processing needs.
+  
+  class Options #:nodoc:
+    # Superclass
+    attr_reader :only, :except
+    def initialize(options)
+      options ||= {}
+      @only = options[:only]
+      @except = options[:except]
+    end
+  end
+  
+  class SliceOptions < Options #:nodoc:
+    attr_reader :unit, :maximum, :complete, :text_break, :limit
+    def initialize(options)
+      super(options)
+      @unit = case options[:unit]
+      when Hash, Regexp then options[:unit]
+      when String then /#{options[:unit]}/
+      when nil then /&#?\w+;|\S/
+      else raise "Invalid :unit definition '#{options[:unit].inspect}'"
+      end
+      @maximum = case options[:maximum]
+      when Fixnum then
+        if options[:maximum] > 0
+          options[:maximum]
+        else
+          raise "Invalid :maximum definition. Has to be more than zero, '#{options[:unit].inspect}' passed"
+        end
+      when nil then case unit
+                    when String, Regexp then 300
+                    when Hash then 10
+                    else 2000
+                    end
+      else raise "Invalid :maximum definition '#{options[:maximum].inspect}'"
+      end
+      @complete = case options[:complete]
+      when Regexp then options[:complete]
+      when nil then nil
+      else raise "Invalid :complete option definition '#{options[:complete].inspect}'"
+      end
+      @limit = case options[:limit]
+      when Fixnum, nil then options[:limit]
+      else raise "Invalid :limit option definition '#{options[:limit].inspect}'"
+      end
+      @text_break = options[:text_break]
+    end
+  end
+  
+  class ResizeOptions < Options
+    attr_reader :width
+    def initialize(options)
+      super(options)
+      @width = options[:width]
+    end
+  end
+  
+end

data/lib/html_slicer/processor.rb

@@ -0,0 +1,46 @@
+module HtmlSlicer
+  class Processor
+  
+    attr_accessor :content
+  
+    def initialize(stuff = nil)
+      @content = case stuff
+      when String then stuff
+      else
+        if stuff.respond_to?(:to_s)
+          stuff.to_s
+        else
+          raise(TypeError, "String or responsible :to_s object expected, #{stuff.class} passed.")
+        end
+      end
+    end
+  
+    def make
+    end
+  
+    def export
+      make
+    end
+  
+  end
+  
+  def self.load_processor!(name)
+    if defined?(Rails.root) && Rails.root
+      require File.expand_path(Rails.root.join("lib", "html_slicer_processors", "#{name.to_s.underscore}.rb"))
+    end
+  end
+  
+  module Process
+    def self.iterate(content, processors = nil)
+      if processors.present?
+        Array.wrap(processors).each do |processor_name|
+          processor = processor_name.to_s.classify.constantize
+          raise(TypeError, "HtmlSlicer::Processor expected, #{processor.name} passed.") unless processor.superclass == HtmlSlicer::Processor
+          content = processor.new(content).export
+        end
+      end
+      content
+    end
+  end
+  
+end

data/lib/html_slicer/railtie.rb

@@ -0,0 +1,15 @@
+require 'rails'
+
+module HtmlSlicer
+  class Railtie < ::Rails::Railtie
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        require 'html_slicer/models/active_record_extension'
+        ActiveRecord::Base.send(:include, HtmlSlicer::ActiveRecordExtension)
+      end
+      ActiveSupport.on_load :action_view do
+        ActionView::Base.send(:include, HtmlSlicer::ActionViewExtension)
+      end
+    end
+  end
+end

data/lib/html_slicer/resizing.rb

@@ -0,0 +1,46 @@
+module HtmlSlicer
+  
+  class Resizing # Resizing engine
+    attr_reader :options
+    
+    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)
+    end
+
+    private
+
+    include HtmlSlicer::Utilities::ParseNode
+    include HtmlSlicer::Utilities::NodeMatchExtension
+
+    def resize_document!(root)
+      parse(root) do |node|
+        resize!(node) if node.is_a?(HTML::Tag) && resizeable?(node)
+      end
+    end
+
+    def resizeable?(node)
+      able_to?(node, @options)
+    end
+
+    def resize!(node)
+      parent_width = node.parent.is_a?(HTML::Tag) ? absolute_resolution(node.parent.attributes["width"]) : nil
+      target_width = parent_width.present? ? parent_width.to_i : @options.width
+      if target_width.present? && node_width = absolute_resolution(node.attributes["width"])
+        node_height = absolute_resolution(node.attributes["height"])
+        if node_width > target_width
+          ratio = node_width.to_f/target_width
+          node.attributes["width"] = target_width.to_s
+          node.attributes["height"] = (node_height/ratio).round.to_s if node_height
+        end
+      end
+    end
+
+    def absolute_resolution(value)
+      (value.present? && value.last != "%") ? value.to_i : nil
+    end
+
+  end
+  
+end

data/lib/html_slicer/slicing.rb

@@ -0,0 +1,101 @@
+module HtmlSlicer
+
+  class Slicing # Slicing engine
+    attr_reader :options, :map
+
+    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)
+    end
+
+    # Resturn number of slices.
+    def slice_number
+      @map.size
+    end
+
+    private
+
+    include HtmlSlicer::Utilities::ParseNode
+    include HtmlSlicer::Utilities::NodeMatchExtension
+
+    def slice_document_by_text!(root)
+      units_count = 0
+      parse(root) do |node|
+        if node.is_a?(HTML::Text)
+          if sliceable?(node)
+            sanitize_content!(node)
+            content = node.to_s
+            index = 0
+            begin
+              while (match = content.match(@options.unit, index)) && index < content.size
+                units_count += 1
+                last_index ||= 0
+                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)
+                  last_index = index
+                  limited? ? raise(Exception) : @map << Hash.new
+                else
+                  index = match.end(0)
+                end
+                if units_count > 0
+                  @map.last[node.object_id] = Range.new(last_index, -1)
+                end
+              end
+            rescue Exception
+              break
+            end
+          else
+            @map.last[node.object_id] = Range.new(0, -1)
+          end
+        else
+          @map.last[node.object_id] = true
+        end
+      end
+    end
+
+    def slice_document_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)
+        else
+          @map.last[node.object_id] = 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
+          end
+        end
+      end
+    end
+
+    def limited?
+      @options.limit && slice_number >= @options.limit
+    end
+
+    def sanitize_content!(node)
+      content = HTML::FullSanitizer.new.sanitize(node.to_s)
+      node.instance_variable_set(:@content, content)
+    end
+
+    def complete!(content, index)
+      if regexp = @options.complete
+        content.match(regexp, index).try(:begin, 0)||index
+      else
+        index
+      end
+    end
+
+    def sliceable?(node)
+      able_to?(node, @options)
+    end
+
+  end
+  
+end

data/lib/html_slicer/utilities.rb

@@ -0,0 +1,132 @@
+module HtmlSlicer
+  
+  module Utilities
+
+    module ParseNode
+      def parse(node, &block)
+        node.children.each do |node|
+          yield node if block_given?
+          parse(node, &block) if node.is_a?(HTML::Tag)
+        end
+      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)
+        array_copy = Proc.new do |a|
+          duplicate = Array.new
+          a.each do |value|
+            duplicate << case value
+            when Hash then hash_copy.call(value)
+            when Array then array_copy.call(value)
+            else value
+            end
+          end
+          duplicate
+        end
+        hash_copy = Proc.new do |h|
+          duplicate = Hash.new
+          h.each do |key, value|
+            duplicate[key] = case value
+            when Hash then hash_copy.call(value)
+            when Array then array_copy.call(value)
+            else value
+            end
+          end
+          duplicate
+        end
+        case object
+        when Hash then hash_copy.call(object)
+        when Array then array_copy.call(object)
+        else object
+        end
+      end
+    end
+
+    module HashupArray
+      # Return a nested Hash object from Array's elements sequence, where elements used as names of +hash+ keys.
+      # The last element of array would be the last nested value.
+      #
+      # === Example:
+      #   
+      #   [:vehicle, :car, :ford, :mustang, "2 please"].hashup
+      #
+      #   #=> {:vehicle=>{:car=>{:ford=>{:mustang=>"2 please"}}}}
+      def hashup(array)
+        raise(TypeError, "Array expected!") unless array.is_a?(Array)
+        raise(Exception, "At least 2 elements needed!") if array.size < 2
+        value = array.delete_at(-1)
+        hash = {}
+        index = 0
+        last_hash = hash
+        while index < array.size
+          last_hash = last_hash[array.at(index)] = (index + 1 == array.size) ? value : {}
+          index += 1
+        end
+        hash
+      end      
+    end
+    
+    module NestedMergeHash
+  
+      include Deepcopy
+
+      # Return the merged Hash with another +hash+, where the possible child hashes are also merged.
+      #
+      # === Example:
+      # 
+      #   h1 = {:breakfast => {:eggs => 2, :bread => 1}, :lunch => {:steak => 1, :salad => 1}}
+      #   h2 = {:breakfast => {:coffee => :espresso, :juice => 1}, :lunch => {:tea => 2}, :dinner => :none}
+      #   h1.nested_merge(h2)
+      #   #=> {:breakfast=>{:eggs=>2, :bread=>1, :coffee=>:espresso, :juice=>1}, :lunch=>{:steak=>1, :salad=>1, :tea=>2}, :dinner=>:none}
+      #
+      def nested_merge(hash, other_hash = {})
+        raise(TypeError, "Hash expected!") unless hash.is_a?(Hash)
+        a = Proc.new do |original, change|
+          change.each do |key, value|
+            if !original.has_key?(key) || !original[key].is_a?(Hash)
+              original[key] = value
+            elsif original[key].is_a?(Hash) && value.is_a?(Hash)
+              a.call(original[key], value)
+            end
+          end
+          original
+        end
+        a.call(deepcopy(hash), other_hash)
+      end
+
+      # .nested_merge replaces the source hash.
+      def nested_merge!(hash, other_hash = {})
+        hash.replace(nested_merge(hash, other_hash = {}))
+      end
+    end
+    
+    module NodeMatchExtension
+    
+      # Checking if node is included in +:only+ parameter and/or excluded of +:except+ parameeter.
+      def able_to?(node, options)
+        if options.only.present?
+          general_match(node, options.only)
+        elsif options.except.present?
+          !general_match(node, options.except)
+        else
+          true
+        end
+      end
+    
+      # Checking if node is a member of other node's tree. Accepts +hashes+ as conditions.
+      # Returns +true+ if node or it's parent matches at least one condition, or +false+ otherwise.
+      def general_match(node, hashes = [])
+        conditions = Array.wrap(hashes)
+        while node
+          break true if conditions.each {|condition| break true if node.match(condition)} == true
+          node = node.parent
+        end||false
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/html_slicer/version.rb

@@ -0,0 +1,3 @@
+module HtmlSlicer
+  VERSION = "0.0.4"
+end

data/lib/html_slicer.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require "html_slicer/version"
+
+module HtmlSlicer
+  
+  def self.load!
+    require 'html_slicer/utilities'
+    require 'html_slicer/config'
+    require 'html_slicer/options'
+    require 'html_slicer/processor'
+    require 'html_slicer/slicing'
+    require 'html_slicer/resizing'
+    require 'html_slicer/interface'
+    require 'html_slicer/engine'
+    require 'html_slicer/helpers/action_view_extension'
+    require 'html_slicer/helpers/slicer'
+    require 'html_slicer/railtie'
+  end
+  
+end
+  
+HtmlSlicer.load!

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: html_slicer
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Valery Kvon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: &70154298274740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70154298274740
+description: 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.
+email:
+- addagger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- app/views/html_slicer/_first_slice.html.erb
+- app/views/html_slicer/_first_slice.html.haml
+- app/views/html_slicer/_first_slice.html.slim
+- app/views/html_slicer/_gap.html.erb
+- app/views/html_slicer/_gap.html.haml
+- app/views/html_slicer/_gap.html.slim
+- app/views/html_slicer/_last_slice.html.erb
+- app/views/html_slicer/_last_slice.html.haml
+- app/views/html_slicer/_last_slice.html.slim
+- app/views/html_slicer/_next_slice.html.erb
+- app/views/html_slicer/_next_slice.html.haml
+- app/views/html_slicer/_next_slice.html.slim
+- app/views/html_slicer/_prev_slice.html.erb
+- app/views/html_slicer/_prev_slice.html.haml
+- app/views/html_slicer/_prev_slice.html.slim
+- app/views/html_slicer/_slice.html.erb
+- app/views/html_slicer/_slice.html.haml
+- app/views/html_slicer/_slice.html.slim
+- app/views/html_slicer/_slicer.html.erb
+- app/views/html_slicer/_slicer.html.haml
+- app/views/html_slicer/_slicer.html.slim
+- config/locales/html_slicer.yml
+- html_slicer.gemspec
+- lib/html_slicer.rb
+- lib/html_slicer/config.rb
+- lib/html_slicer/engine.rb
+- lib/html_slicer/helpers/action_view_extension.rb
+- lib/html_slicer/helpers/slicer.rb
+- lib/html_slicer/helpers/smart_params.rb
+- lib/html_slicer/helpers/tags.rb
+- lib/html_slicer/installer.rb
+- lib/html_slicer/interface.rb
+- lib/html_slicer/models/active_record_extension.rb
+- lib/html_slicer/options.rb
+- lib/html_slicer/processor.rb
+- lib/html_slicer/railtie.rb
+- lib/html_slicer/resizing.rb
+- lib/html_slicer/slicing.rb
+- lib/html_slicer/utilities.rb
+- lib/html_slicer/version.rb
+homepage: http://github.com/addagger/HtmlSlicer
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: html_slicer
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: HTML text slicer
+test_files: []