abstractor 4.4.1 → 4.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1915d3f9543f45ccc3df0b4e6c74d6b58f566398
-  data.tar.gz: 5cb807386ae0cdfa2a60d28ef55b6d1bfddba633
+  metadata.gz: 07d9074db71c7f0389203998331177b329015321
+  data.tar.gz: 266b2bfeb642c6613ff23e12da66d904c90723f9
 SHA512:
-  metadata.gz: 5503ed02f9a8b7d9b9c39fa2ab19b937b9f363adf1bece36b84b5365ef0ad138dd0cabf182dc59b1d881dcc84c1134cb65cd0ad5138741b00c4419089a7361ee
-  data.tar.gz: ffa6167f82c4286ae712deb5f25b859eb74200d6e3ec266e26d8d0eab51d629db32348a0ccca3a72f814b0e0355c360e503d959a5f7dc8a4a196c3ddb2ed1d96
+  metadata.gz: fa9449c55a6b1600596d86fbaa55da291955a17e71a8f463cfa386687270e04654339d0e2e39441fbf7a418fb06d5e835124412c79092ae1ba6df6f092a2dd97
+  data.tar.gz: 1628fd3acdc7f26b12325cfb6666fed656937386faee9bb2b5de865f7d0744a2227e008f146fe2c454a7bfc450102f0ab74572f1a398e98023eb5a8be4507fa7

data/app/views/abstractor/abstractor_abstractions/edit.html.haml

@@ -7,28 +7,28 @@
       = abstraction_schema.display_name
     .abstraction_edit_abstraction_value
       - case abstraction_schema.abstractor_object_type.value
-      - when 'date'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_DATE
         = f.text_field :value, class: 'abstractor_datepicker'
-      - when 'text'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_TEXT
         = f.text_area :value
-      - when 'string'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_STRING
         = f.text_field :value
-      - when 'number'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_NUMBER
         = f.number_field :value
-      - when 'radio button list'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_RADIO_BUTTON_LIST
         - values = abstraction_schema.abstractor_object_values.order('abstractor_abstraction_schema_object_values.display_order, abstractor_object_values.value')
         -  values.each do |value|
           = f.radio_button :value, value.value
           = f.label :value, value.value, value: value.value
         = f.radio_button :value, '', {:style => 'display:none;' }
          
-      - when 'list'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_LIST, Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_NUMBER_LIST
         - values = abstraction_schema.abstractor_object_values.order('abstractor_abstraction_schema_object_values.display_order, abstractor_object_values.value')
         = f.select :value, values.map{|s| [s.value, s.value]}, {:include_blank => true}, :class => "combobox"
-      - when 'dynamic list'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_DYNAMIC_LIST
         - values = abstractor_abstraction.about.send(abstractor_abstraction.abstractor_subject.dynamic_list_method).sort_by { |l| l[:value] }
         = f.select :value, values.map{|s| [s[:value], s[:id]]}, {:include_blank => true}, :class => "combobox"
-      - when 'boolean'
+      - when Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_BOOLEAN
         - ['true', 'false'].each do |value|
           = f.radio_button :value, value
           = f.label :value, value

data/lib/abstractor/enum.rb

@@ -21,6 +21,30 @@ module Abstractor
     ABSTRACTOR_SUGGESTION_STATUS_ACCEPTED = 'Accepted'
     ABSTRACTOR_SUGGESTION_STATUS_REJECTED = 'Rejected'
     ABSTRACTOR_SUGGESTION_STATUSES = [ABSTRACTOR_SUGGESTION_STATUS_NEEDS_REVIEW, ABSTRACTOR_SUGGESTION_STATUS_ACCEPTED, ABSTRACTOR_SUGGESTION_STATUS_REJECTED]
+
     ABSTRACTOR_GROUP_SENTINENTAL_SUBTYPE = 'sentinental'
+
+    ABSTRACTOR_OBJECT_TYPE_LIST                 = 'list'
+    ABSTRACTOR_OBJECT_TYPE_NUMBER               = 'number'
+    ABSTRACTOR_OBJECT_TYPE_BOOLEAN              = 'boolean'
+    ABSTRACTOR_OBJECT_TYPE_STRING               = 'string'
+    ABSTRACTOR_OBJECT_TYPE_RADIO_BUTTON_LIST    = 'radio button list'
+    ABSTRACTOR_OBJECT_TYPE_DATE                 = 'date'
+    ABSTRACTOR_OBJECT_TYPE_DYNAMIC_LIST         = 'dynamic list'
+    ABSTRACTOR_OBJECT_TYPE_TEXT                 = 'text'
+    ABSTRACTOR_OBJECT_TYPE_NUMBER_LIST          = 'number list'
+    ABSTRACTOR_OBJECT_TYPES = [
+      ABSTRACTOR_OBJECT_TYPE_LIST,
+      ABSTRACTOR_OBJECT_TYPE_NUMBER,
+      ABSTRACTOR_OBJECT_TYPE_BOOLEAN,
+      ABSTRACTOR_OBJECT_TYPE_STRING,
+      ABSTRACTOR_OBJECT_TYPE_RADIO_BUTTON_LIST,
+      ABSTRACTOR_OBJECT_TYPE_DATE,
+      ABSTRACTOR_OBJECT_TYPE_DYNAMIC_LIST,
+      ABSTRACTOR_OBJECT_TYPE_TEXT,
+      ABSTRACTOR_OBJECT_TYPE_NUMBER_LIST
+    ]
+
+    NUMERIC_REGEX = '(?<object_value>\d+[\.,]*\d*[\.,]*\d*)'
   end
 end

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

@@ -8,7 +8,17 @@ module Abstractor
           # Associations
           base.send :has_many, :abstractor_abstraction_schemas
 
-          # base.send :attr_accessible, :deleted_at, :value
+          base.send(:include, InstanceMethods)
+        end
+
+        module InstanceMethods
+          def number?
+            self.value == Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_NUMBER
+          end
+
+          def number_list?
+            self.value == Abstractor::Enum::ABSTRACTOR_OBJECT_TYPE_NUMBER_LIST
+          end
         end
       end
     end

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

@@ -238,65 +238,120 @@ module Abstractor
             end
           end
 
+          # Generates suggestions for name/value pairs.
+          #
+          # Tht method will detect sentenses in the source text that match any of the predicate variants.
+          # For each detected sentence, method would first try to abstract canonical name/value pair.
+          # If canonical match was not found, method would try to abstract sentinental match.
+          #
+          # @param [ActiveRecord::Base] about The entity to abstract.  An instance of the class specified in the Abstractor::AbstractorSubject#subject_type attribute.
+          # @param [Abstractor::AbstractorAbstraction] abstractor_abstraction The instance of Abstractor::AbstractorAbstraction to make suggestions against.
+          # @param [Abstractor::AbstractorAbstractionSource] abstractor_abstraction_source The instance of the Abstractor::AbstractorAbstractionSource that provides the custom method to invoke on the abstractable entity to make custom suggestions.
+          # @return [void]
           def abstract_name_value(about, abstractor_abstraction, abstractor_abstraction_source)
-            abstract_canonical_name_value(about, abstractor_abstraction, abstractor_abstraction_source)
-            abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source)
-            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)
             abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
               abstractor_text = Abstractor::AbstractorAbstractionSource.abstractor_text(source)
               parser = Abstractor::Parser.new(abstractor_text)
+
               abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
-                abstractor_abstraction_schema.abstractor_object_values.each do |abstractor_object_value|
-                  abstractor_object_value.object_variants.each do |object_variant|
-                    match_value = "#{Regexp.escape(predicate_variant)}:\s*#{Regexp.escape(object_variant)}"
-                    matches = parser.scan(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
+                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
+                end
+              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
 
-                    match_value = "#{Regexp.escape(predicate_variant)}#{Regexp.escape(object_variant)}"
-                    matches = parser.scan(match_value, word_boundary: true).uniq
+          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
+
+              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)
+                        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)
+                  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|
-                      suggest(abstractor_abstraction, abstractor_abstraction_source, match, match, source[:source_id], source[:source_type].to_s, source[:source_method], source[:seciton_name], abstractor_object_value, nil, nil, nil, nil)
+                      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)
                     end
                   end
                 end
               end
             end
+            is_abstracted
           end
 
-          def abstract_sentential_name_value(about, abstractor_abstraction, abstractor_abstraction_source)
-            abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              abstractor_text = Abstractor::AbstractorAbstractionSource.abstractor_text(source)
-              parser = Abstractor::Parser.new(abstractor_text)
-              abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
-                ranges = parser.range_all(Regexp.escape(predicate_variant))
-                if ranges.any?
-                  ranges.each do |range|
-                    sentence = parser.find_sentence(range)
-                    if sentence
-                      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
+          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
                       end
                     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)
+                             )
+                    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)
+                    end
                   end
                 end
               end
@@ -377,7 +432,7 @@ module Abstractor
           def create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
             #Create an 'unknown' suggestion based on matching nothing only if we have not made a suggstion
             abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              if abstractor_abstraction.abstractor_suggestions(true).select { |abstractor_suggestion| abstractor_suggestion.unknown != true }.empty?
+              if abstractor_abstraction.abstractor_suggestions(true).select { |abstractor_suggestion| abstractor_suggestion.unknown != true || abstractor_suggestion.unknown == true}.empty?
                 suggest(abstractor_abstraction, abstractor_abstraction_source, nil, nil, source[:source_id], source[:source_type].to_s, source[:source_method],source[:section_name],  nil, true, nil, nil, nil)
               end
             end

data/lib/abstractor/parser.rb

@@ -28,8 +28,8 @@ module Abstractor
       end
     end
 
-    def scan(token, options = {})
-      options[:word_boundary] = true if options[:word_boundary].nil?
+     def scan(token, options = {})
+      options[:word_boundary] = true  if options[:word_boundary].nil?
       regular_expression = prepare_token(token, options)
       at = prepare_abstractor_text
       if (regular_expression.nil? || at.nil?)
@@ -39,13 +39,35 @@ module Abstractor
       end
     end
 
+    def sentence_scan(sentence, token, options = {})
+      options[:word_boundary] = true  if options[:word_boundary].nil?
+      regular_expression = prepare_token(token, options)
+      if (regular_expression.nil? || sentence.nil?)
+        []
+      else
+        sentence.scan(regular_expression)
+      end
+    end
+
+    def sentence_match_scan(sentence, token, options = {})
+      options[:word_boundary] = true  if options[:word_boundary].nil?
+      regular_expression = prepare_token(token, options)
+      if (regular_expression.nil? || sentence.nil?)
+        []
+      else
+        # http://stackoverflow.com/questions/6804557/how-do-i-get-the-match-data-for-all-occurrences-of-a-ruby-regular-expression-in
+        sentence.to_enum(:scan,regular_expression).map{ Regexp.last_match }
+      end
+    end
+
     def match(token)
       regular_expression = prepare_token(token)
       prepare_abstractor_text.match(regular_expression) unless regular_expression.nil?
     end
 
-    def range_all(token)
-      regular_expression = prepare_token(token)
+    def range_all(token, options = {})
+      options[:word_boundary] = true  if options[:word_boundary].nil?
+      regular_expression = prepare_token(token, options)
       prepare_abstractor_text.range_all(regular_expression) unless regular_expression.nil?
     end
 

data/lib/abstractor/setup.rb

@@ -2,14 +2,9 @@ module Abstractor
   module Setup
     def self.system
       puts 'Setting up Abstractor::AbstractorObjectType'
-      Abstractor::AbstractorObjectType.where(value: 'list').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'number').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'boolean').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'string').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'radio button list').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'date').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'dynamic list').first_or_create
-      Abstractor::AbstractorObjectType.where(value: 'text').first_or_create
+        Abstractor::Enum::ABSTRACTOR_OBJECT_TYPES.each do |abstractor_object_type|
+        Abstractor::AbstractorObjectType.where(value: abstractor_object_type).first_or_create
+      end
 
       puts 'Setting up Abstractor::AbstractorRuleType'
       Abstractor::AbstractorRuleType.where(name: 'name/value', description:'search for value associated with name').first_or_create

data/lib/abstractor/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractor
 version: !ruby/object:Gem::Version
-  version: 4.4.1
+  version: 4.4.2
 platform: ruby
 authors:
 - Michael Gurley, Yulia Bushmanova
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-11 00:00:00.000000000 Z
+date: 2015-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -845,7 +845,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A Rails engine gem for deriving discrete data points from narrative text