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

hairaito 0.0.2 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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