RubyGems - hairaito - Versions diffs - 0.0.2 → 0.0.3 - Mend

hairaito 0.0.2 → 0.0.3

Files changed (6) hide show

checksums.yaml +4 -4
data/README.md +64 -0
data/lib/hairaito/nokogiri/xml/document.rb +61 -49
data/lib/hairaito/nokogiri/xml/node.rb +161 -15
data/lib/hairaito/version.rb +1 -1
metadata +2 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e3cd6878a89daabfb2fdf0d3a9ca661fc238566
-  data.tar.gz: 237ee8e16ee95f4e20ac67bd301500a3eb7deb81
+  metadata.gz: 739c486eff2c0dd13f4d31cc67937efd6bc3fabf
+  data.tar.gz: ab89ded036459096b7b8993c7102b23caad3fe3a
 SHA512:
-  metadata.gz: 762a12095a72d152e6b07d80c48ec8294f4077c4e769222d0e770bb3eaa2b7a4c0c4f5176502ddd57a5c6727c6aaaa073d70384623ed808afdcccd3ccc500e6a
-  data.tar.gz: 69e4d996242c807cd4fbd42e445809b6af8d64fbc3bf6d84bb519b787a7bd1a27887137177bd4f2e4295b3e06ace6967cfc7dd9c2edf7456093506f7231c241f
+  metadata.gz: 854720af08d6228b2235795188ce59e78e5228f74907c770be7b9469b167d91a887fa0fd46a20c8f0f7d287fa347e6bff4f71347b7d449f79b990b2388be9f2e
+  data.tar.gz: 8b0c6bd2cc94c6b2bc9cd851fb3fe719f048f0122816ddae58a6949757874b1ef78cba42a2a461c8cbee02ad35320517ce245c601862cd3368ce56feb4953863

data/README.md CHANGED Viewed

@@ -1,5 +1,7 @@
 # Hairaito
+Extends Nokogiri with text snippets highlighting. It looks like jquery-highlight plugin, but for ruby and nokogiri.
 ## Installation
 Add this line to your application's Gemfile:
@@ -16,6 +18,68 @@ Or install it yourself as:
 ## Usage
+Hairaito adds to Nokogiri::XML::Document _highlight_ method.
+Example:
+```
+doc = Nokogiri::XML('<body>abc def ghi</body>')
+doc.highlight(['def'])
+doc.to_html # => '<body>abc <span class="snippet-part snippet-start" data-snippet-id="0">def</span> ghi</body>'
+```
+There are several options for highlighting customization:
+```
+{
+  highlight_base: {
+      selector: 'body',                             # Highlighting will be launched at this selector
+      content_wrapper: '',                          # Highlighting base content can be wrapped by this tag
+      content_wrapper_class: 'highlighting-base',   # Class for wrapper above
+  },
+  snippet: {
+      part_wrapper: 'span',                         # Found snippet parts will be wrapped with this tag
+      part_wrapper_class: 'snippet-part',           # Class for wrapper above
+      starting_part_class: 'snippet-start',         # Class for wrapper above, is added only for first part per found snippet
+  },
+  numeration: {
+      attr: 'data-snippet-id',                      # Snippet parts of single snippet will have same numeration value in this attribute
+      prefix: '',                                   # Prefix, that will be added to each numeration value
+      suffix: '',                                   # Suffix, that will be added to each numeration value
+      start_with: 0,                                # Starting point for numeration increment
+  },
+  boundaries: {
+    whole_words_only: true,                         # If true, only whole words will be found
+    inline_tags: %w(a b i s u basefont big em font img label small span strike strong sub sup tt), # Tags, that aren't considered as word boundary
+    word_parts: '[а-яА-ЯёЁa-zA-Z\d]',               # Characters, that are considered as word part
+  },
+}
+```
+Example:
+```
+doc = Nokogiri::XML('<body>abc def ghi abcdefghi</body>')
+options = {
+    highlight_base: {
+      content_wrapper: 'div',
+    },
+    snippet: {
+      starting_part_class: 'start',
+      part_wrapper_class: 'part',
+    },
+    numeration: {
+      attr: 'data-id',
+      prefix: 'snippet_'
+    },
+    boundaries: {
+      whole_words_only: false,
+    }
+}
+doc.highlight(['abc'], options)
+doc.to_html # => '<body><div class="highlighting-base"><span class="part start" data-id="snippet_0">abc</span> def ghi <span class="part start" data-id="snippet_1">abc</span>defghi</div></body>'
+```
 ## Contributing
 1. Fork it ( https://github.com/dmazilov/hairaito/fork )

data/lib/hairaito/nokogiri/xml/document.rb CHANGED Viewed

@@ -3,80 +3,92 @@ module Hairaito
     module XML
       module Document
+        # Highlights text snippets in document
+        #
+        # @param snippets [Array<String>] text variants to be highlighted
+        # @param options [Hash] custom highlighting options
+        # @return [Nokogiri::XML::Document] self document for chaining
         def highlight(snippets, options = {})
-          highlighting_default_options(options)
-          snippets.each do |snippet|
-            highlighting_base.traverse_by_text(snippet).each do |snippet_container|
-              to_wrap = []
-              start_index = snippet_container.text().index(snippet)
-              start_node, start_inner_index = snippet_container.text_node_by_position(start_index)
+          highlighting_defaults(options)
+          snippet_parts_to_wrap = []
+          prepare_snippets(snippets).each do |snippet|
+            highlighting_base.traverse_by_text(snippet, @hl_opts[:boundaries]) do |snippet_container, snippet_offset|
+              start_node, start_inner_index = snippet_container.text_node_by_position(snippet_offset.first)
               start_range = start_node.text_range_by_index(start_inner_index, snippet.length)
-              to_wrap << [start_node, start_range]
+              snippet_parts_to_wrap << {part: start_node, range: start_range, starting: true}
               # If start node contains only part of snippet
               if snippet.length > start_range.size
-                end_node, end_inner_index = snippet_container.text_node_by_position(start_index + snippet.length - 1)
+                end_node, end_inner_index = snippet_container.text_node_by_position(snippet_offset.last - 1)
                 end_range = end_node.text_range_by_index(end_inner_index)
-                to_wrap += snippet_container.text_nodes_between(start_node, end_node).map do |node|
-                  [node, 0..(node.text.length - 1)]
+                snippet_parts_to_wrap += snippet_container.text_nodes_between(start_node, end_node).map do |node|
+                  {part: node, range: 0..(node.text.length - 1)}
                 end
-                to_wrap << [end_node, end_range]
-              end
-              to_wrap.each do |node_data|
-                node_data.first.highlight_by_range(node_data.last)
+                snippet_parts_to_wrap << {part: end_node, range: end_range}
               end
-              snippet_container['class'] = "#{snippet_container['class']} #{@hl_opts[:snippet_container_class]}"
             end
           end
-          numerate_highlighted_snippets if @hl_opts[:numerate]
-          to_html
-        end
-        def highlight_snippet_part(text)
-          if @hl_opts[:snippet_part_wrapper].blank?
-            raise ArgumentError.new('Snippet part wrapper tag is not specified!')
+          snippet_parts_to_wrap.group_by{|part_data| part_data[:part]}.each do |part, parts_collection|
+            part.highlight_by_ranges(parts_collection.map{|p| p.except(:part)}, @hl_opts)
           end
-          wrapper = create_element("#{@hl_opts[:snippet_part_wrapper]}", class: "#{@hl_opts[:snippet_part_wrapper_class]}")
-          wrapper.content = text
-          wrapper
+          numerate_snippet_parts if @hl_opts[:numeration][:attr].present?
+          self
         end
         private
-        def highlighting_default_options(options)
+        def highlighting_defaults(options)
+          @hl_base = nil
           @hl_opts = {
-              base_selector: 'body',
-              base_content_wrapper: '',
-              base_content_wrapper_class: 'highlighting-base',
-              snippet_container_class: 'highlighted-snippet',
-              snippet_part_wrapper: 'span',
-              snippet_part_wrapper_class: 'highlighted-snippet-part',
-              numerate: true,
-              numeration_attr: 'data-snippet-id',
-              numeration_prefix: '',
-              numeration_suffix: '',
-          }.merge(options)
+              highlight_base: {
+                  selector: 'body',
+                  content_wrapper: '',
+                  content_wrapper_class: 'highlighting-base',
+              },
+              snippet: {
+                  part_wrapper: 'span',
+                  part_wrapper_class: 'snippet-part',
+                  starting_part_class: 'snippet-start',
+              },
+              numeration: {
+                  attr: 'data-snippet-id',
+                  prefix: '',
+                  suffix: '',
+                  start_with: 0,
+              },
+              boundaries: {},
+          }.deep_merge(options).with_indifferent_access
         end
         def highlighting_base
-          base = at(@hl_opts[:base_selector])
+          return @hl_base if @hl_base.present?
+          base = at(@hl_opts[:highlight_base][:selector])
           raise ArgumentError.new('Document does not contain highlighting base element!') if base.blank?
-          if @hl_opts[:base_content_wrapper].present?
-            wrapper = create_element("#{@hl_opts[:base_content_wrapper]}", class: "#{@hl_opts[:base_content_wrapper_class]}")
+          if @hl_opts[:highlight_base][:content_wrapper].present?
+            wrapper = create_element("#{@hl_opts[:highlight_base][:content_wrapper]}",
+                                     class: "#{@hl_opts[:highlight_base][:content_wrapper_class]}")
             base.children.each{|child| child.parent = wrapper}
             wrapper.parent = base
-            return wrapper
+            @hl_base = wrapper
+          else
+            @hl_base = base
           end
-          base
+          @hl_base
+        end
+        # Longer snippets must go first due to situations with snippets overlapping
+        # Example: ['abc', 'abcdef'],
+        # without sorting this produces highlighting artifacts like shorter snippet duplication in result nodes
+        def prepare_snippets(snippets)
+          snippets.uniq.sort_by{|snippet| snippet.length}.reverse
         end
-        def numerate_highlighted_snippets
-          css(".#{@hl_opts[:snippet_container_class]}").each_with_index do |snippet_container, index|
-            snippet_container[@hl_opts[:numeration_attr]] =
-                "#{@hl_opts[:numeration_prefix]}#{index}#{@hl_opts[:numeration_prefix]}"
+        def numerate_snippet_parts
+          selector = @hl_opts[:snippet][:part_wrapper_class].gsub(/\s+/, ' ').split(' ').map{|cl| ".#{cl}"}.join('')
+          index = @hl_opts[:numeration][:start_with] - 1
+          css(selector).each do |part|
+            index += 1 if part[:class].split(' ').include?(@hl_opts[:snippet][:starting_part_class])
+            part[@hl_opts[:numeration][:attr]] = "#{@hl_opts[:numeration][:prefix]}#{index}#{@hl_opts[:numeration][:suffix]}"
           end
         end

data/lib/hairaito/nokogiri/xml/node.rb CHANGED Viewed

@@ -3,6 +3,7 @@ module Hairaito
     module XML
       module Node
+        # @return [Nokogiri::XML::NodeSet] all text nodes, that has self as ancestor
         def text_nodes
           result_nodes = []
           traverse do |node|
@@ -12,6 +13,17 @@ module Hairaito
           ::Nokogiri::XML::NodeSet.new(document, result_nodes)
         end
+        # @return [Nokogiri::XML::Node] first text node within self node
+        def first_text_node
+          traverse do |node|
+            return node if node.text?
+          end
+          nil
+        end
+        # @param start_node [Nokogiri::XML::Node] left boundary
+        # @param end_node [Nokogiri::XML::Node] right boundary
+        # @return [Nokogiri::XML::NodeSet] all text nodes are located between specified boundaries
         def text_nodes_between(start_node, end_node)
           nodes = text_nodes
           indexes = [nodes.index(start_node), nodes.index(end_node)]
@@ -22,18 +34,83 @@ module Hairaito
           ::Nokogiri::XML::NodeSet.new(document, result_nodes)
         end
-        def traverse_by_text(text, exclude_ancestors = true)
-          excluded = []
-          result_nodes = []
-          traverse do |node|
-            next if node.is_a?(::Nokogiri::XML::Text)
-            next if node.in?(excluded)
-            if node.text.include?(text)
-              result_nodes << node
-              excluded += node.ancestors if exclude_ancestors
+        # @param base [Nokogiri::XML::Node] root element for search
+        # @return [Nokogiri::XML::Node, nil] previous text node within base node or nil if it doesn't exist
+        def previous_text(base = document)
+          first_text_node = text_nodes.first
+          base_text_nodes = base.text_nodes
+          if (index = base_text_nodes.index(first_text_node)).blank?
+            raise ArgumentError.new('Base must contain self node!')
+          end
+          return if index == 0
+          base_text_nodes[index - 1]
+        end
+        # @param base [Nokogiri::XML::Node] root element for search
+        # @return [Nokogiri::XML::Node, nil] next text node within base node or nil if it doesn't exist
+        def next_text(base = document)
+          first_text_node = text_nodes.last
+          base_text_nodes = base.text_nodes
+          if (index = base_text_nodes.index(first_text_node)).blank?
+            raise ArgumentError.new('Base must contain self node!')
+          end
+          return if index == base_text_nodes.count - 1
+          base_text_nodes[index + 1]
+        end
+        # Yields for each match of specified string in child nodes recursively
+        #
+        # @yieldparam node [Nokogiri::XML::Node] child node contains specified string
+        # @yieldparam offset [Array] child text inner offset
+        # @param string [String] text for matching
+        # @param options [Hash] @see #traverse_by_text_default_options
+        # @return [Nokogiri::XML::Node] self node for chaining
+        def traverse_by_text(string, options = {}, &block)
+          traverse_by_text_defaults(options)
+          traverse do |current_node|
+            next if current_node.text?
+            offset_types = @tbt_opts[:whole_words_only] ? [:inner_word, :boundary_word] : [:simple]
+            inner_offsets, boundary_offsets = current_node.matched_offsets(string, offset_types, @tbt_opts)
+            # Check words bordered with current inline tag if current node has boundary words
+            # abc<span>def<span> or <span>def</span>ghi or abc<span>def</span>ghi
+            if current_node.name.in?(@tbt_opts[:inline_tags]) && self != current_node
+              if boundary_offsets.try(:first).try(:first) == 0
+                previous_node = current_node.previous_text(self)
+                boundary_offsets.shift if previous_node.try(:matched_offsets, :any, :ending_word, @tbt_opts).present?
+              end
+              if boundary_offsets.try(:last).try(:first) == 0
+                next_node = current_node.next_text(self)
+                boundary_offsets.pop if next_node.try(:matched_offsets, :any, :beginning_word, @tbt_opts).present?
+              end
+            end
+            offsets = (inner_offsets + (boundary_offsets || [])).sort_by{|offset| offset.first}
+            if offsets.any?
+              offsets.each {|offset| yield(current_node, offset)} if block_given?
+              if current_node != self
+                # Excludes processed offsets from all ancestors
+                ([current_node] + current_node.ancestors).each do |node|
+                  pos = node.position_by_text_node(current_node.first_text_node)
+                  # Shifts all offsets according to node inner position and excludes from future processing
+                  node.exclude_offsets(offsets.map{|offset| [offset.first + pos, offset.last + pos]})
+                  # Reaches highlighting base
+                  break if node == self
+                end
+              end
             end
           end
-          result_nodes
+          self
+        end
+        def position_by_text_node(text_node)
+          nodes = text_nodes
+          if (index = nodes.index(text_node)) < 0
+            raise ArgumentError.new('Self node must contain text_node!')
+          end
+          return 0 if index == 0
+          nodes[0..index - 1].map{|node| node.text}.join('').length
         end
         def text_node_by_position(in_text_position)
@@ -48,11 +125,23 @@ module Hairaito
           raise ArgumentError.new('Inner index is out of range!')
         end
-        def highlight_by_range(range)
-          prefix = range.first > 0 ? text[0..(range.first - 1)]: ''
-          suffix = range.last < text.length - 1 ? text[(range.last + 1)..(text.length - 1)]: ''
-          for_wrapping = text[range]
-          new_contents = "#{prefix}#{document.highlight_snippet_part(for_wrapping)}#{suffix}"
+        def highlight_by_ranges(ranges, options)
+          if options[:snippet][:part_wrapper].blank?
+            raise ArgumentError.new('Snippet part wrapper tag is not specified!')
+          end
+          parts = []
+          ranges = ranges.sort_by{|r| r[:range].first}
+          ranges.each_with_index do |range_data, index|
+            range = range_data[:range]
+            parts << (range.first > 0 ? text[0..(range.first - 1)]: '') if index == 0
+            snippet_class = range_data[:starting] ? "#{options[:snippet][:starting_part_class]}" : ''
+            wrapper = document.create_element("#{options[:snippet][:part_wrapper]}", class: "#{options[:snippet][:part_wrapper_class]} #{snippet_class}")
+            wrapper.content = text[range]
+            parts << wrapper.to_s
+            parts << text[(range.last + 1)..(ranges[index + 1][:range].first - 1)] if index < ranges.count - 1
+            parts << (range.last < text.length - 1 ? text[(range.last + 1)..(text.length - 1)]: '') if index == ranges.count - 1
+          end
+          new_contents = parts.join('')
           replace(new_contents)
         end
@@ -60,6 +149,63 @@ module Hairaito
           demand_length.present? ? index..[text.length - 1, index + demand_length - 1].min : 0..index
         end
+        # @return [Array] self node offsets were already processed
+        def excluded_offsets
+          @excluded_offsets ||= []
+        end
+        # @param offsets [Array] self node offsets to be excluded in the future processing
+        def exclude_offsets(offsets)
+          @excluded_offsets ||= []
+          @excluded_offsets += offsets
+        end
+        def matched_offsets(string, types, options)
+          types = [types] unless types.is_a?(Array)
+          offsets = []
+          types.each do |type|
+            offsets << text.to_enum(:scan, build_regexp(string, type, options)).map do
+              offset = Regexp.last_match.offset(:text)
+              # Only one highlighting per position
+              offset unless overlapped_offsets?(excluded_offsets, offset)
+            end.compact || []
+          end
+          return *offsets
+        end
+        private
+        def traverse_by_text_defaults(options)
+          @tbt_opts = {
+              whole_words_only: true,
+              inline_tags: %w(a b i s u basefont big em font img label small span strike strong sub sup tt),
+              word_parts: '[а-яА-ЯёЁa-zA-Z\d]',
+          }.deep_merge(options).with_indifferent_access
+        end
+        def build_regexp(string, type = :simple, options)
+          string = '.+' if string == :any
+          case type.to_sym
+            when :simple
+              return /(?<text>#{string})/
+            when :inner_word
+              return /(?<!#{options[:word_parts]}|\A)(?<text>#{string})(?!#{options[:word_parts]}|\Z)/
+            when :beginning_word
+              return /\A(?<text>#{string})(?!#{options[:word_parts]})/
+            when :ending_word
+              return /(?<!#{options[:word_parts]})(?<text>#{string})\Z/
+            when :boundary_word
+              return /(\A(?<text>#{string})(?!#{options[:word_parts]}))|((?<!#{options[:word_parts]})(?<text>#{string})\Z)|(\A(?<text>#{string})\Z)/
+          end
+        end
+        def overlapped_offsets?(offsets_collection, offset_for_check)
+          offsets_collection.each do |offset|
+            return true if (offset_for_check.first...offset_for_check.last).overlaps?(offset.first...offset.last)
+          end
+          false
+        end
       end
     end
   end

data/lib/hairaito/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Hairaito
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hairaito
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Denis Mazilov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler