abstractor 4.4.2 → 4.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07d9074db71c7f0389203998331177b329015321
-  data.tar.gz: 266b2bfeb642c6613ff23e12da66d904c90723f9
+  metadata.gz: 8e287ee46744b138166b5013a594f17488f48592
+  data.tar.gz: 00931cda0cb5d0d6fc03c263cf26da3fe130c120
 SHA512:
-  metadata.gz: fa9449c55a6b1600596d86fbaa55da291955a17e71a8f463cfa386687270e04654339d0e2e39441fbf7a418fb06d5e835124412c79092ae1ba6df6f092a2dd97
-  data.tar.gz: 1628fd3acdc7f26b12325cfb6666fed656937386faee9bb2b5de865f7d0744a2227e008f146fe2c454a7bfc450102f0ab74572f1a398e98023eb5a8be4507fa7
+  metadata.gz: 697b42f689aa4d88915d5431d62f96255bb16bab03166a0a2ae55bbee53f437be36cb8661c97e6f41c45797fb9d3ec52d4f8f762ab495571c43e8130fef948e0
+  data.tar.gz: 297cbf1b6752fec3e279bd22d48abc634f911278ca3738d2dc36e6ba2079fb512aa762a32b7197309d24a66628377cd0e0ea666036d4f2c908023d41fab3ad6e

data/lib/abstractor/methods/models/abstractor_subject.rb

@@ -253,104 +253,127 @@ module Abstractor
               abstractor_text = Abstractor::AbstractorAbstractionSource.abstractor_text(source)
               parser = Abstractor::Parser.new(abstractor_text)
 
+              sentences = []
+              # get all matching sentences
               abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
                 ranges = parser.range_all(Regexp.escape(predicate_variant), word_boundary: false)
                 ranges.each do |range|
                   sentence = parser.find_sentence(range)
-                  if sentence
-                    is_abstracted = abstract_canonical_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence, predicate_variant)
-                    abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence, predicate_variant) unless is_abstracted
-                  end
+                  sentences << sentence if sentence
                 end
               end
+              sentences.uniq.each do |sentence|
+                skip_sentinental = abstract_canonical_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence)
+                abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence) unless skip_sentinental
+              end
             end
             create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction, abstractor_abstraction_source)
             create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
           end
 
-          def abstract_canonical_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence, predicate_variant)
-            is_abstracted = false
-            if abstractor_abstraction_schema.abstractor_object_type && (abstractor_abstraction_schema.abstractor_object_type.number? || abstractor_abstraction_schema.abstractor_object_type.number_list?)
-              object_regex = Abstractor::Enum::NUMERIC_REGEX
+          def abstract_canonical_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence)
+            skip_sentinental = false
+            abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
+              if abstractor_abstraction_schema.abstractor_object_type && (abstractor_abstraction_schema.abstractor_object_type.number? || abstractor_abstraction_schema.abstractor_object_type.number_list?)
+                object_regex = Abstractor::Enum::NUMERIC_REGEX
 
-              match_values = ["#{Regexp.escape(predicate_variant)}:\s*#{object_regex}", "#{Regexp.escape(predicate_variant)}#{object_regex}"]
-              match_values.each do |match_value|
-                matches = parser.sentence_match_scan(sentence[:sentence], match_value, word_boundary: true).uniq
-                if abstractor_abstraction_schema.abstractor_object_type.number_list?
-                  # filter matched numbers by list of available values
-                  abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
-                    abstractor_object_value.object_variants.each do |object_variant|
-                      matches.each do |match|
-                        if object_variant == match[:object_value]
-                          suggest(abstractor_abstraction, abstractor_abstraction_source, match.to_s, match.to_s, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
+                match_values = ["#{Regexp.escape(predicate_variant)}:\s*#{object_regex}", "#{Regexp.escape(predicate_variant)}#{object_regex}"]
+                match_values.each do |match_value|
+                  matches = parser.sentence_match_scan(sentence[:sentence], match_value, word_boundary: true).uniq
+                  if abstractor_abstraction_schema.abstractor_object_type.number_list?
+                    # filter matched numbers by list of available values
+                    abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
+                      abstractor_object_value.object_variants.each do |object_variant|
+                        matches.each do |match|
+                          if object_variant == match[:object_value]
+                            skip_sentinental = suggest(abstractor_abstraction, abstractor_abstraction_source, match.to_s, match.to_s, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
+                          end
                         end
                       end
                     end
-                  end
-                else
-                  matches.each do |match|
-                    is_abstracted = suggest(abstractor_abstraction, abstractor_abstraction_source, match.to_s, match.to_s, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], match[:object_value], nil, nil, nil, nil)
+                  else
+                    matches.each do |match|
+                      skip_sentinental = suggest(abstractor_abstraction, abstractor_abstraction_source, match.to_s, match.to_s, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], match[:object_value], nil, nil, nil, nil)
+                    end
                   end
                 end
-              end
-            else
-              abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
-                abstractor_object_value.object_variants.each do |object_variant|
-                  match_values = ["#{Regexp.escape(predicate_variant)}:\s*#{Regexp.escape(object_variant)}", "#{Regexp.escape(predicate_variant)}#{Regexp.escape(object_variant)}"]
-                  match_values.each do |match_value|
-                    matches = parser.sentence_scan(sentence[:sentence], match_value, word_boundary: true).uniq
-                    matches.each do |match|
-                      is_abstracted = suggest(abstractor_abstraction, abstractor_abstraction_source, match, match, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
+              else
+                abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
+                  abstractor_object_value.object_variants.each do |object_variant|
+                    match_values = ["#{Regexp.escape(predicate_variant)}:\s*#{Regexp.escape(object_variant)}", "#{Regexp.escape(predicate_variant)}#{Regexp.escape(object_variant)}"]
+                    match_values.each do |match_value|
+                      matches = parser.sentence_scan(sentence[:sentence], match_value, word_boundary: true).uniq
+                      matches.each do |match|
+                        suggest(abstractor_abstraction, abstractor_abstraction_source, match, match, source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
+                      end
                     end
                   end
                 end
               end
             end
-            is_abstracted
+            skip_sentinental
           end
 
-          def abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence, predicate_variant)
-            is_abstracted = false
-            if abstractor_abstraction_schema.abstractor_object_type && (abstractor_abstraction_schema.abstractor_object_type.number? || abstractor_abstraction_schema.abstractor_object_type.number_list?)
-              object_regex = object_regex = Abstractor::Enum::NUMERIC_REGEX
-              match = parser.match_sentence(sentence[:sentence], object_regex)
-              if match
-                scoped_sentence = Abstractor::NegationDetection.parse_negation_scope(sentence[:sentence])
-                reject = (
-                           Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], predicate_variant) ||
-                           Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], predicate_variant) ||
-                           Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], match[:object_value]) ||
-                           Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], match[:object_value])
-                         )
-                if !reject
-                  if abstractor_abstraction_schema.abstractor_object_type.number_list?
-                    # filter matched numbers by list of available values
-                    abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
-                      abstractor_object_value.object_variants.each do |object_variant|
-                        if object_variant == match[:object_value]
-                          suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
-                        end
+          def abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source, source, parser, sentence)
+            abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
+              if match = parser.match_sentence(sentence[:sentence], predicate_variant)
+                if abstractor_abstraction_schema.abstractor_object_type && (abstractor_abstraction_schema.abstractor_object_type.number? || abstractor_abstraction_schema.abstractor_object_type.number_list?)
+                  object_regex = object_regex = Abstractor::Enum::NUMERIC_REGEX
+                  filtered_matches = parser.sentence_match_scan(sentence[:sentence], object_regex).reject{|m| m.begin(0) > match.begin(0) && m.end(0) < match.end(0)}
+                  if filtered_matches.any?
+                    closest_post_match  = filtered_matches.select{|m| m.begin(0) > match.end(0)}.first
+                    closest_pre_match   = filtered_matches.select{|m| m.end(0)   < match.begin(0)}.last
+
+                    closest_match = nil
+                    if closest_post_match && closest_pre_match
+                      if closest_post_match.begin(0) - match.end(0) > match.begin(0) - closest_pre_match.end(0) and sentence[:sentence][closest_pre_match.end(0)..match.begin(0)] !~ /[,;]/
+                        closest_match = closest_pre_match
+                      else
+                        closest_match = closest_post_match
                       end
+                    else
+                      closest_match =   closest_post_match
+                      closest_match ||= closest_pre_match
                     end
-                  else
-                    is_abstracted = suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], match[:object_value], nil, nil, nil, nil)
-                  end
-                end
-              end
-            else
-              abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
-                abstractor_object_value.object_variants.each do |object_variant|
-                  match = parser.match_sentence(sentence[:sentence], Regexp.escape(object_variant))
-                  if match
+
                     scoped_sentence = Abstractor::NegationDetection.parse_negation_scope(sentence[:sentence])
                     reject = (
                                Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], predicate_variant) ||
                                Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], predicate_variant) ||
-                               Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], object_variant) ||
-                               Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], object_variant)
+                               Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], closest_match[:object_value]) ||
+                               Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], closest_match[:object_value])
                              )
                     if !reject
-                      is_abstracted = suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], abstractor_object_value, nil, nil, nil, nil)
+                      if abstractor_abstraction_schema.abstractor_object_type.number_list?
+                        # filter matched numbers by list of available values
+                        abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
+                          abstractor_object_value.object_variants.each do |object_variant|
+                            if object_variant == closest_match[:object_value]
+                              suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name],  abstractor_object_value, nil, nil, nil, nil)
+                            end
+                          end
+                        end
+                      else
+                        suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], closest_match[:object_value], nil, nil, nil, nil)
+                      end
+                    end
+                  end
+                else
+                  abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
+                    abstractor_object_value.object_variants.each do |object_variant|
+                      match = parser.match_sentence(sentence[:sentence], Regexp.escape(object_variant))
+                      if match
+                        scoped_sentence = Abstractor::NegationDetection.parse_negation_scope(sentence[:sentence])
+                        reject = (
+                                   Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], predicate_variant) ||
+                                   Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], predicate_variant) ||
+                                   Abstractor::NegationDetection.negated_match_value?(scoped_sentence[:scoped_sentence], object_variant) ||
+                                   Abstractor::NegationDetection.manual_negated_match_value?(sentence[:sentence], object_variant)
+                                 )
+                        if !reject
+                          suggest(abstractor_abstraction, abstractor_abstraction_source, sentence[:sentence], sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], source[:section_name], abstractor_object_value, nil, nil, nil, nil)
+                        end
+                      end
                     end
                   end
                 end

data/lib/abstractor/version.rb

@@ -1,3 +1,3 @@
 module Abstractor
-  VERSION = '4.4.2'
+  VERSION = '4.4.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractor
 version: !ruby/object:Gem::Version
-  version: 4.4.2
+  version: 4.4.3
 platform: ruby
 authors:
 - Michael Gurley, Yulia Bushmanova
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails