pertinent_parser 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82c1ea5ccb406cf088548e021a771378c318e3d1
+  data.tar.gz: 9b89619ed72dda0008192856ea343f624b0573b5
+SHA512:
+  metadata.gz: e3d3d6f55364d41ab21ebce1e48a9d2e2b84aaf737afb7b8390a599bbd206dff1ea72874772f9e5dadb340efd794b0b3c62877540915529ff142a406e839ae37
+  data.tar.gz: 8238784a074f077775b6d8df61c792a77b5ff0f2e8f8b23c8418f3d4eecd5f7ad15edd4059374744240b8dac1445ac85090a5503e79a603fa1f0da5f9cd54073

data/lib/pertinent_parser.rb

@@ -0,0 +1,78 @@
+require "hpricot"
+require "pertinent_parser/transform"
+require "pertinent_parser/rule"
+require "pertinent_parser/text"
+
+class Hpricot::Elem
+  def stag
+    "<#{name}#{attributes_as_html}" +
+      ((empty? and not etag) ? " /" : "") +
+      ">"
+  end
+end
+
+module PertinentParser
+  class << self
+    # Better write our own traversal function so that we can screw with the HTML representation the way we like.
+    def html(html)
+      doc = Hpricot(html)
+      d = 0
+      t = text(doc.inner_text)
+      doc.traverse_all_element do |elem|
+        if elem.text?
+          #puts elem.inner_text
+          d += elem.inner_text.size
+        else
+          #puts elem.stag
+          t + wrap_(d...d+elem.inner_text.size, elem.stag)
+          #puts "#{d}..#{d+elem.inner_text.size}"
+        end
+      end
+      t
+    end
+
+    def text(s)
+      r = Rule.new((0..s.size-1), Transform.new(:identity, ["id"]))
+      t = Text.new(s)
+      t.rule = r
+      t
+    end
+
+    def offset_to_r(o)
+      (o[0]..o[1]-1)
+    end
+
+    def range_from_specification context, target, number
+      count, position = 0, 0
+      stored = []
+      re = Regexp.new(Regexp.escape(target))
+      while (match = context.match(re , position)) do
+        temp = match.offset 0
+        position += 1; count += 1 if temp != stored
+        return offset_to_r(temp) if count == number
+        stored = temp
+      end
+    end
+
+    def new_wrap(context, target, number, tag)
+      range = range_from_specification(context, target, number)
+      wrap_(range, tag)
+    end
+
+    def rule(range, transform)
+      Rule.new(range, transform)
+    end
+
+
+    def wrap_(range, tag)
+      transform = Transform.new(:wrap, [tag, "</"+tag.match(/<(\S*)(\s|>)/)[1]+">" ])
+      r = Rule.new(range, transform)
+    end
+
+    def new_replace(context, target, number, replacement)
+      range = range_from_specification(context, target, number)
+      transform = Transform.new(:replacement, replacement)
+      r = Rule.new(range, transform)
+    end
+  end
+end

data/lib/pertinent_parser/rule.rb

@@ -0,0 +1,79 @@
+class Rule
+  attr_accessor :name, :children, :parent
+  attr_accessor :transform
+  attr_accessor :range
+  def initialize(range, transform=nil, children=[], parent=nil)
+    @range = range.to_a
+    @children = children
+    @parent = parent
+    @transform = transform
+  end
+  def <=>(r)
+    range.first <=> r.range.first
+  end
+  def apply_recur(s, offset=0)
+    pre = offset
+    @children.each do |child|
+      offset += child.apply_recur(s, offset)
+    end
+    # This was an optimization gone wrong. Sorry. Applies the transformation to the portion of the text.
+    return (s[@range.first+pre..@range.last+offset] = @transform.apply(s[@range.first+pre..@range.last+offset])).size - range.size
+  end
+  def apply(str)
+    s = str.dup
+    apply_recur(s)
+    return s
+  end
+  def +(text)
+    add(text.rule)
+    return text
+  end
+  def add(new_rule)
+    intersection = range & new_rule.range
+    if intersection == new_rule.range
+      contain = []
+      input = new_rule
+      @children.each do |child|
+        result = child.add(input)
+        case result
+        when Rule        
+          input = result
+        when :inside     
+          return :inside
+        when :contain    
+          contain << child
+        when :outside
+        end
+      end
+      @children -= contain
+      contain.each do |child|
+        input.add child
+      end
+      @children << input
+      @children.sort!
+      return :inside
+    elsif intersection.empty?
+      return :outside
+    elsif intersection == range
+      if @parent.nil?
+        children = new_rule.children
+        new_rule.children = [self]
+        children.each do |child|
+          new_rule.add child
+        end
+        return new_rule
+      end
+      return :contain
+    else
+      difference = new_rule.range - intersection
+      transforms = new_rule.transform.split(difference.size)
+      if intersection.first < difference.first
+        inter_tran, diff_tran = transforms
+      else
+        diff_tran, inter_tran = transforms
+      end
+      self.add(Rule.new(intersection, inter_tran))
+      return Rule.new(difference, diff_tran)
+    end
+  end
+end

data/lib/pertinent_parser/text.rb

@@ -0,0 +1,27 @@
+class Text < String
+  attr_accessor :rule
+
+  # Return the HTML after all rules are applied
+  def apply
+    @rule.apply(self)
+  end
+  
+  undef +
+    def +(new_rule)
+      @rule.add(new_rule)
+  end
+
+  # Wrap text, falling inside of existing boundaries
+  def wrap_in(tag, target, number=1)
+    self.+(PertinentParser.new_wrap(self, target, number, tag))
+  end
+
+  def replace(replacement, target, number=1)
+    self.+(PertinentParser.new_replace(self, target, number, replacement))
+  end
+
+  # Wrap text, falling outside of existing boundaries
+  def wrap_out(tag, target, number=1)
+    PertinentParser.new_wrap(self, target, number, tag).+(self)
+  end
+end 

data/lib/pertinent_parser/transform.rb

@@ -0,0 +1,25 @@
+class Transform
+  attr_accessor :type, :property
+
+  def initialize type, property
+    @type, @property = type, property
+  end
+
+  def split(n)
+    if @type == :replacement
+      return [Transform.new(:replacement, @property[0..n-1]), Transform.new(:replacement, @property[n..-1])]
+    elsif @type == :wrap
+      return [self, self.dup]
+    end
+  end
+
+  def apply(s)
+    if @type == :identity
+      return s
+    elsif @type == :replacement
+      return @property
+    elsif @type == :wrap
+      return @property[0] + s + @property[1]
+    end
+  end
+end   

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: pertinent_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Matthew Bunday
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hpricot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+description: PertinentParser helps you compose HTML tags across existing tag boundaries.
+email: mkbunday@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pertinent_parser.rb
+- lib/pertinent_parser/rule.rb
+- lib/pertinent_parser/text.rb
+- lib/pertinent_parser/transform.rb
+homepage: https://github.com/zencephalon/Pertinent_Parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: PertinentParser helps you compose HTML tags across existing tag boundaries.
+test_files: []