abstractor 1.0.20 → 1.0.22

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDg1YWM0MWMxN2ZlMTM1N2IxYTBjMTNhZTg3MGFlMDM5MjJhYWM0NQ==
+    MDdjMTlhOGQ5ZDUwZTFiYzllM2VlMjJiMTlmN2Q1ZmM4MTExYmZkZA==
   data.tar.gz: !binary |-
-    NmZmM2ZmNjI2YTg5MmE4OGNkN2ZkMmU5MDkzNjIwMGExNDEwMDRlMA==
+    MDFiZTgwYWM3MjhjMTk4ZTc4MWVmNmNjYjMzMDRjY2YyZjM2Mjk4MQ==
 SHA512:
   metadata.gz: !binary |-
-    NWQ1YWRjNzc5YWNlMGMxMGVjNmE4OTM5ZjhmMWE1ZDc4NWVjOGFlZmRlYzQ2
-    MTkxNzM2ZjUwZDQwMTJiN2EzZjFjMDc2NWFmMGZhODJlNWU0MmYyMDRlMjE3
-    ZTEwOTZlNjRmMDQ3ODM0ZjhjZWYyZjcyODMyZWFkMjNlZmYxNjk=
+    YmE5Yzk3YzIzZjM1MTY1M2I4NjZmYTNlNzMwZTBmYjE2NGNhOTViYTBiZTgx
+    M2RkOTRhZmMwZjY2ZGZiODVhNGFlNjMyYWIwNWY3OWM1YWRkY2ZjZmI3OTY4
+    OGM1N2UzNjNjMmEyNDhmZDRlMDBhNDNkMjExNjk3MWE3ZDMwM2Q=
   data.tar.gz: !binary |-
-    MDU2ZTJkNWVkN2Y2ODg0MjVhYjE4ZWVmNGI0ZjMwMzM3MWRmNTBjYWRmNmNm
-    NGZjYjBjOWIwMWVmMWEzNTkyY2EwNDdjNzdmMzI2ZDU0OGUzNzc1MzYzOTUz
-    ZjAyMzcwYThlZmM1ZDc3OWY0NGI4OTZjN2QzYTA1NjNmNGJmNTM=
+    NWVhNWJiZGYxN2M5YWU3YzU5YmUyZDEwZWZlMWRhZDExMmVkOTdkMzQ0NTNl
+    ZmI0ZmU4NjZmZjY3NTUwYWM4ZDMyY2FlNWVhZDI2MTBjMmI3OGM0ZmRiN2Nh
+    ZWJmOGM4YmE5NWUwNzM0YjcwZDEyZDQ2YjAwMWQ3YWM4OTk5MmY=

data/Rakefile

@@ -4,7 +4,6 @@ begin
   require 'cucumber/rake/task'
   require 'rspec/core/rake_task'
   require 'rubygems/package_task'
-  require 'nubic/gem_tasks'
 end
 
 gemspec = eval(File.read('abstractor.gemspec'), binding, 'abstractor.gemspec')
@@ -27,7 +26,4 @@ namespace :cucumber do
   end
 end
 
-task :cucumber => 'cucumber:features'
-Nubic::GemTasks::DeployGemTask.new("pkg/#{gemspec.file_name}")
-task "deploy:gem" => :repackage
-Bundler::GemHelper.install_tasks
+task :cucumber => 'cucumber:features'

data/app/assets/javascripts/abstractor/abstractor.js

@@ -74,7 +74,7 @@ Abstractor.AbstractionUI = function(){
 };
 
 Abstractor.AbstractionSuggestionUI = function(){
-  $(document).on('change', '#abstractor_suggestion_abstractor_suggestion_status_id_1, #abstractor_suggestion_abstractor_suggestion_status_id_2, #abstractor_suggestion_abstractor_suggestion_status_id_3', function() {
+  $(document).on('change', '.abstractor_suggestion_status_selection', function() {
     $(this).closest('form').submit();
   });
 

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

@@ -49,8 +49,9 @@
             .column-3
               - values = Abstractor::AbstractorSuggestionStatus.all.sort_by(&:name).map{|s| [s.name, s.id] }
               -  values.each do |value|
-                = f.radio_button :abstractor_suggestion_status_id, value.last
-                = f.label :abstractor_suggestion_status_id, value.first, value: value.last
+                - id = "abstractor_suggestion_abstractor_suggestion_status_id_#{value.last}_#{abstractor_suggestion.id}"
+                = f.radio_button :abstractor_suggestion_status_id, value.last, id: id, class: 'abstractor_suggestion_status_selection'
+                = f.label :abstractor_suggestion_status_id, value.first, value: value.last, for: id
                 %br
               = f.radio_button :abstractor_suggestion_status_id, '', {:style => 'display:none;' }
             %hr
@@ -65,5 +66,4 @@
               - abstractable_from_column = about.send(from_method)
               - unless abstractable_from_column.nil?
                 = abstractable_from_column.clone
-
     .clear

data/db/migrate/20140618140759_add_custom_method_to_abstractor_abstraction_sources.rb

@@ -0,0 +1,5 @@
+class AddCustomMethodToAbstractorAbstractionSources < ActiveRecord::Migration
+  def change
+    add_column :abstractor_abstraction_sources, :custom_method, :string
+  end
+end

data/db/migrate/20140618140828_add_custom_method_to_abstractor_suggestion_sources.rb

@@ -0,0 +1,5 @@
+class AddCustomMethodToAbstractorSuggestionSources < ActiveRecord::Migration
+  def change
+    add_column :abstractor_suggestion_sources, :custom_method, :string
+  end
+end

data/lib/abstractor/abstractable.rb

@@ -1,8 +1,6 @@
 module Abstractor
   module Abstractable
     def self.included(base)
-      base.send(:include, InstanceMethods)
-      base.extend(ClassMethods)
       base.class_eval do
         has_many :abstractor_abstractions, class_name: Abstractor::AbstractorAbstraction, as: :about
 
@@ -10,6 +8,8 @@ module Abstractor
 
         accepts_nested_attributes_for :abstractor_abstractions, allow_destroy: false
       end
+      base.send(:include, InstanceMethods)
+      base.extend(ClassMethods)
     end
 
     module InstanceMethods
@@ -56,7 +56,7 @@ module Abstractor
           if !only_unreviewed || (only_unreviewed && abstractor_abstraction.unreviewed?)
             abstractor_abstraction.abstractor_suggestions.each do |abstractor_suggestion|
               abstractor_suggestion.abstractor_suggestion_sources.destroy_all
-              abstractor_suggestion.abstractor_suggestion_object_value.destroy
+              abstractor_suggestion.abstractor_suggestion_object_value.destroy if abstractor_suggestion.abstractor_suggestion_object_value
               abstractor_suggestion.destroy
             end
             abstractor_abstraction.destroy
@@ -89,7 +89,6 @@ module Abstractor
       # @param [Hash] options the options to filter the objects returned
       # @option options [Boolean] :grouped Filters the list of Abstactor::AbstractorSubject objects to grouped and non-grouped.  Defaults to nil which returns all objects.
       # @return ActiveRecord::Relation list of Abstactor::AbstractorSubject objects
-
       def abstractor_subjects(options = {})
         options = { grouped: nil }.merge(options)
         subjects = Abstractor::AbstractorSubject.where(subject_type: self.to_s)

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

@@ -25,8 +25,8 @@ module Abstractor
           # Hooks
           base.send :after_save, :review_matching_suggestions#, :if => lambda {|abstractor_abstraction| abstractor_abstraction.value_changed?}
 
-          base.send :extend, ClassMethods
           base.send(:include, InstanceMethods)
+          base.extend(ClassMethods)
         end
 
         module InstanceMethods

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

@@ -10,7 +10,7 @@ module Abstractor
           base.send :has_many, :abstractor_suggestion_sources
           base.send :has_many, :abstractor_abstractions, :through => :abstractor_suggestion_sources
 
-          base.send :attr_accessible, :abstractor_subject, :abstractor_subject_id, :deleted_at, :from_method
+          base.send :attr_accessible, :abstractor_subject, :abstractor_subject_id, :deleted_at, :from_method, :custom_method
         end
 
         def normalize_from_method_to_sources(about)

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

@@ -20,77 +20,118 @@ module Abstractor
 
 
           base.send :attr_accessible, :abstractor_abstraction_schema, :abstractor_abstraction_schema_id, :abstractor_rule_type, :abstractor_rule_type_id, :subject_type
+          base.send(:include, InstanceMethods)
         end
 
-        # Instance Methods
-        def abstract(about)
-          abstractor_abstraction = about.find_or_create_abstractor_abstraction(abstractor_abstraction_schema, self)
-          case abstractor_rule_type.name
-          when 'name/value'
-            abstract_name_value(about, abstractor_abstraction)
-          when 'value'
-            abstract_value(about, abstractor_abstraction)
-          when 'unknown'
-            abstract_unknown(about, abstractor_abstraction)
+        module InstanceMethods
+          ##
+          # Creates or finds and instance of an Abstactor::AbstractorAbstraction.
+          # The method will create instances of Abstractor::AbstractorSuggestion and
+          # Abstractor::AbstractorSuggestionSource for the abstractable entity
+          # passed via the about parameter.
+          #
+          # The Abstractor::AbstractorSubject#abstractor_rule_type attribute determines the abstraction strategy:
+          #
+          # * 'name/value': attempts to search for non-negated sentences mentioning of an Abstractor::AbstractorAbstractionSchema#predicate and an Abstractor::AbstractorObjectValue
+          # * 'value': attempts to search for non-negated sentences mentioning an Abstractor::AbstractorObjectValue
+          # * 'unknown': will automatically create an 'unknown' Abstractor::AbstractorSuggestion
+          # * 'custom': will create instances of Abstractor::AbstractorSuggestion based on custom logic delegated to the method on the about parameter configured in AbstractorAbstractionSource#custom_method
+          #
+          # @param [ActiveRecord::Base] about the entity abstract.  An instnace of the class specified in the Abstractor::AbstractorSubject#subject_type attribute.
+          # @return [void]
+          def abstract(about)
+            abstractor_abstraction = about.find_or_create_abstractor_abstraction(abstractor_abstraction_schema, self)
+            case abstractor_rule_type.name
+            when 'name/value'
+              abstract_name_value(about, abstractor_abstraction)
+            when 'value'
+              abstract_value(about, abstractor_abstraction)
+            when 'unknown'
+              abstract_unknown(about, abstractor_abstraction)
+            when 'custom'
+              abstract_custom(about, abstractor_abstraction)
+            end
           end
-        end
 
-        def abstract_unknown(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+          # Cycle through instances of Abstractor::AbstractorSuggestionSources
+          # --each time calling the method on the about paramter configured by
+          # the AbstractorAbstractionSource#custom_method attribute.
+          # Setting up an Abstractor::AbstractorSubject with a
+          # 'custom' rule type obligates the developer to implement an instance
+          # method on the abstractable entitty to make suggestions as
+          # appropriate.  The 'custom' rule type is intened to faciliate a
+          # way to generate suggestions in a completely customizable way.
+          #
+          # @param [ActiveRecord::Base] about the entity to abstraction
+          # @param [Abstractor::AbstractorAbstraction] abstractor_abstraction the instance of an abstractor abstraction
+          # @return [void]
+          def abstract_custom(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              suggested_values = about.send(abstractor_abstraction_source.custom_method)
+              suggested_values.each do |suggested_value|
+                suggest(abstractor_abstraction, abstractor_abstraction_source, nil, nil, about.id, about.class.to_s, abstractor_abstraction_source.from_method, suggested_value, nil, nil, abstractor_abstraction_source.custom_method)
+              end
+              create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+            end
           end
-        end
 
-        def abstract_value(about, abstractor_abstraction)
-          abstract_sentential_value(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+          def abstract_unknown(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+            end
           end
-        end
 
-        def abstract_sentential_value(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
-              abstractor_object_value_ids = abstractor_abstraction_schema.abstractor_object_values.map(&:id)
+          def abstract_value(about, abstractor_abstraction)
+            abstract_sentential_value(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+            end
+          end
 
-              adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
-              case adapter
-              when 'sqlserver'
-                abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' + abstractor_object_value_variants.value + '%'))", abstractor_object_value_ids, source[:source_id]).all
-              when 'sqlite3'
-                abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' || abstractor_object_value_variants.value || '%'))", abstractor_object_value_ids, source[:source_id]).all
-              when 'postgresql'
-                abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} ILIKE ('%' || abstractor_object_value_variants.value || '%'))", abstractor_object_value_ids, source[:source_id]).all
-              end
+          def abstract_sentential_value(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
+                abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
+                abstractor_object_value_ids = abstractor_abstraction_schema.abstractor_object_values.map(&:id)
 
-              abstractor_object_values = abstractor_object_value_variants.map(&:abstractor_object_value).uniq
+                adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
+                case adapter
+                when 'sqlserver'
+                  abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' + abstractor_object_value_variants.value + '%'))", abstractor_object_value_ids, source[:source_id]).all
+                when 'sqlite3'
+                  abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' || abstractor_object_value_variants.value || '%'))", abstractor_object_value_ids, source[:source_id]).all
+                when 'postgresql'
+                  abstractor_object_value_variants = Abstractor::AbstractorObjectValueVariant.where("abstractor_object_value_id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} ILIKE ('%' || abstractor_object_value_variants.value || '%'))", abstractor_object_value_ids, source[:source_id]).all
+                end
 
-              adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
-              case adapter
-              when 'sqlserver'
-                abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' + abstractor_object_values.value + '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
-              when 'sqlite3'
-                abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' || abstractor_object_values.value || '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
-              when 'postgresql'
-                abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} ILIKE ('%' || abstractor_object_values.value || '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
-              end
+                abstractor_object_values = abstractor_object_value_variants.map(&:abstractor_object_value).uniq
 
-              parser = Abstractor::Parser.new(abstractor_text)
-              abstractor_object_values.each do |abstractor_object_value|
-                object_variants(abstractor_object_value, abstractor_object_value_variants).each do |object_variant|
-                  ranges = parser.range_all(Regexp.escape(object_variant.downcase))
-                  if ranges.any?
-                    ranges.each do |range|
-                      sentence = parser.find_sentence(range)
-                      if sentence
-                        scoped_sentence = Abstractor::NegationDetection.parse_negation_scope(sentence[:sentence])
-                        reject = (
-                                  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, object_variant.downcase, sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], abstractor_object_value, nil, nil)
+                adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
+                case adapter
+                when 'sqlserver'
+                  abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' + abstractor_object_values.value + '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
+                when 'sqlite3'
+                  abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} LIKE ('%' || abstractor_object_values.value || '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
+                when 'postgresql'
+                  abstractor_object_values.concat(Abstractor::AbstractorObjectValue.where("abstractor_object_values.id in (?) AND EXISTS (SELECT 1 FROM #{source[:source_type].table_name} WHERE #{source[:source_type].table_name}.id = ? AND #{source[:source_type].table_name}.#{source[:source_method]} ILIKE ('%' || abstractor_object_values.value || '%'))", abstractor_object_value_ids, source[:source_id]).all).uniq
+                end
+
+                parser = Abstractor::Parser.new(abstractor_text)
+                abstractor_object_values.each do |abstractor_object_value|
+                  object_variants(abstractor_object_value, abstractor_object_value_variants).each do |object_variant|
+                    ranges = parser.range_all(Regexp.escape(object_variant.downcase))
+                    if ranges.any?
+                      ranges.each do |range|
+                        sentence = parser.find_sentence(range)
+                        if sentence
+                          scoped_sentence = Abstractor::NegationDetection.parse_negation_scope(sentence[:sentence])
+                          reject = (
+                                    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, object_variant.downcase, sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], abstractor_object_value, nil, nil, nil)
+                          end
                         end
                       end
                     end
@@ -99,67 +140,67 @@ module Abstractor
               end
             end
           end
-        end
 
-        def abstract_name_value(about, abstractor_abstraction)
-          abstract_canonical_name_value(about, abstractor_abstraction)
-          abstract_sentential_name_value(about, abstractor_abstraction)
-          create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+          def abstract_name_value(about, abstractor_abstraction)
+            abstract_canonical_name_value(about, abstractor_abstraction)
+            abstract_sentential_name_value(about, abstractor_abstraction)
+            create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+            end
           end
-        end
 
-        def abstract_canonical_name_value(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
-              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], abstractor_object_value, nil, nil)
-                    end
+          def abstract_canonical_name_value(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
+                abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
+                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], abstractor_object_value, nil, nil, nil)
+                      end
 
-                    match_value = "#{Regexp.escape(predicate_variant)}#{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], abstractor_object_value, nil, nil)
+                      match_value = "#{Regexp.escape(predicate_variant)}#{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], abstractor_object_value, nil, nil, nil)
+                      end
                     end
                   end
                 end
               end
             end
           end
-        end
 
-        def abstract_sentential_name_value(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
-              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], abstractor_object_value, nil, nil)
+          def abstract_sentential_name_value(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
+                abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
+                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], abstractor_object_value, nil, nil, nil)
+                              end
                             end
                           end
                         end
@@ -170,59 +211,69 @@ module Abstractor
               end
             end
           end
-        end
 
-        def suggest(abstractor_abstraction, abstractor_abstraction_source, match_value, sentence_match_value, source_id, source_type, source_method, abstractor_object_value, unknown, not_applicable)
-          match_value.strip! unless match_value.nil?
-          sentence_match_value.strip! unless sentence_match_value.nil?
-          abstractor_suggestion = abstractor_abstraction.detect_abstractor_suggestion(abstractor_object_value.value) unless abstractor_object_value.nil?
-          if !abstractor_suggestion
-            abstractor_suggestion_status_needs_review = Abstractor::AbstractorSuggestionStatus.where(name: 'Needs review').first
-            abstractor_suggestion = Abstractor::AbstractorSuggestion.create(
-                                                                abstractor_abstraction: abstractor_abstraction,
-                                                                abstractor_suggestion_status: abstractor_suggestion_status_needs_review,
-                                                                suggested_value: abstractor_object_value.try(:value),
-                                                                unknown: unknown,
-                                                                not_applicable: not_applicable
-                                                                )
-            abstractor_suggestion.abstractor_suggestion_object_value = Abstractor::AbstractorSuggestionObjectValue.new(abstractor_object_value: abstractor_object_value)
+          def suggest(abstractor_abstraction, abstractor_abstraction_source, match_value, sentence_match_value, source_id, source_type, source_method, suggested_value, unknown, not_applicable, custom_method)
+            match_value.strip! unless match_value.nil?
+            sentence_match_value.strip! unless sentence_match_value.nil?
+            if abstractor_object_value?(suggested_value)
+              abstractor_object_value = suggested_value
+              suggested_value = suggested_value.value
+            end
+            abstractor_suggestion = abstractor_abstraction.detect_abstractor_suggestion(suggested_value) unless suggested_value.nil?
+            if !abstractor_suggestion
+              abstractor_suggestion_status_needs_review = Abstractor::AbstractorSuggestionStatus.where(name: 'Needs review').first
+              abstractor_suggestion = Abstractor::AbstractorSuggestion.create(
+                                                                  abstractor_abstraction: abstractor_abstraction,
+                                                                  abstractor_suggestion_status: abstractor_suggestion_status_needs_review,
+                                                                  suggested_value: suggested_value,
+                                                                  unknown: unknown,
+                                                                  not_applicable: not_applicable
+                                                                  )
+
+              abstractor_suggestion.abstractor_suggestion_object_value = Abstractor::AbstractorSuggestionObjectValue.new(abstractor_object_value: abstractor_object_value) if abstractor_object_value
+            end
+
+            abstractor_suggestion_source = abstractor_suggestion.detect_abstractor_suggestion_source(abstractor_abstraction_source, sentence_match_value, source_id, source_type)
+            if !abstractor_suggestion_source
+              Abstractor::AbstractorSuggestionSource.create(
+                                                abstractor_abstraction_source: abstractor_abstraction_source,
+                                                abstractor_suggestion: abstractor_suggestion,
+                                                match_value: match_value,
+                                                sentence_match_value: sentence_match_value,
+                                                source_id: source_id,
+                                                source_type: source_type,
+                                                source_method: source_method,
+                                                custom_method: custom_method
+                                               )
+            end
+            abstractor_suggestion
           end
 
-          abstractor_suggestion_source = abstractor_suggestion.detect_abstractor_suggestion_source(abstractor_abstraction_source, sentence_match_value, source_id, source_type)
-          if !abstractor_suggestion_source
-            Abstractor::AbstractorSuggestionSource.create(
-                                              abstractor_abstraction_source: abstractor_abstraction_source,
-                                              abstractor_suggestion: abstractor_suggestion,
-                                              match_value: match_value,
-                                              sentence_match_value: sentence_match_value,
-                                              source_id: source_id,
-                                              source_type: source_type,
-                                              source_method: source_method
-                                             )
+          def abstractor_object_value?(suggested_value)
+            suggested_value.instance_of?(Abstractor::AbstractorObjectValue)
           end
-          abstractor_suggestion
-        end
 
-        def create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction)
-          abstractor_abstraction_sources.each do |abstractor_abstraction_source|
-            abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
-              abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
-              parser = Abstractor::Parser.new(abstractor_text)
-              #Create an 'unknown' suggestion based on match name only if we have not made a suggstion
-              if abstractor_abstraction.abstractor_suggestions(true).empty?
-                abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
-                  ranges = parser.range_all(Regexp.escape(predicate_variant))
-                  if ranges
-                    ranges.each do |range|
-                      sentence = parser.find_sentence(range)
-                      if sentence
-                        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)
-                                )
-                        if !reject
-                          suggest(abstractor_abstraction, abstractor_abstraction_source, predicate_variant.downcase, sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], nil, true, nil)
+          def create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction)
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              abstractor_abstraction_source.normalize_from_method_to_sources(about).each do |source|
+                abstractor_text = source[:source_type].find(source[:source_id]).send(source[:source_method])
+                parser = Abstractor::Parser.new(abstractor_text)
+                #Create an 'unknown' suggestion based on match name only if we have not made a suggstion
+                if abstractor_abstraction.abstractor_suggestions(true).empty?
+                  abstractor_abstraction_schema.predicate_variants.each do |predicate_variant|
+                    ranges = parser.range_all(Regexp.escape(predicate_variant))
+                    if ranges
+                      ranges.each do |range|
+                        sentence = parser.find_sentence(range)
+                        if sentence
+                          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)
+                                  )
+                          if !reject
+                            suggest(abstractor_abstraction, abstractor_abstraction_source, predicate_variant.downcase, sentence[:sentence], source[:source_id], source[:source_type].to_s, source[:source_method], nil, true, nil, nil)
+                          end
                         end
                       end
                     end
@@ -231,27 +282,27 @@ module Abstractor
               end
             end
           end
-        end
 
-        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).empty?
-              suggest(abstractor_abstraction, abstractor_abstraction_source, nil, nil, source[:source_id], source[:source_type].to_s, source[:source_method], nil, true, nil)
+          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).empty?
+                suggest(abstractor_abstraction, abstractor_abstraction_source, nil, nil, source[:source_id], source[:source_type].to_s, source[:source_method], nil, true, nil, nil)
+              end
             end
           end
-        end
 
-        def groupable?
-          !abstractor_subject_group_member.nil?
-        end
+          def groupable?
+            !abstractor_subject_group_member.nil?
+          end
 
-        private
+          private
 
-          def object_variants(abstractor_object_value, abstractor_object_value_variants)
-            aovv = abstractor_object_value_variants.select { |abstractor_object_value_variant| abstractor_object_value_variant.abstractor_object_value_id == abstractor_object_value.id }
-            [abstractor_object_value.value].concat(aovv.map(&:value))
-          end
+            def object_variants(abstractor_object_value, abstractor_object_value_variants)
+              aovv = abstractor_object_value_variants.select { |abstractor_object_value_variant| abstractor_object_value_variant.abstractor_object_value_id == abstractor_object_value.id }
+              [abstractor_object_value.value].concat(aovv.map(&:value))
+            end
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Abstractor
           base.send :belongs_to, :abstractor_abstraction_source
           base.send :belongs_to, :abstractor_suggestion
 
-          base.send :attr_accessible, :abstractor_abstraction_source, :abstractor_abstraction_source_id, :abstractor_suggestion, :abstractor_suggestion_id, :source_id, :source_type, :source_method, :match_value, :deleted_at, :sentence_match_value
+          base.send :attr_accessible, :abstractor_abstraction_source, :abstractor_abstraction_source_id, :abstractor_suggestion, :abstractor_suggestion_id, :source_id, :source_type, :source_method, :match_value, :deleted_at, :sentence_match_value, :custom_method
         end
       end
     end

data/lib/abstractor/version.rb

@@ -1,3 +1,3 @@
 module Abstractor
-  VERSION = '1.0.20'
+  VERSION = '1.0.22'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractor
 version: !ruby/object:Gem::Version
-  version: 1.0.20
+  version: 1.0.22
 platform: ruby
 authors:
 - Michael Gurley, Yulia Bushmanova
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -344,26 +344,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.2.1
-- !ruby/object:Gem::Dependency
-  name: nubic-gem-tasks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -501,6 +481,8 @@ files:
 - db/migrate/20131227213427_create_abstractor_suggestions.rb
 - db/migrate/20131228041944_create_abstractor_suggestion_object_values.rb
 - db/migrate/20131228041945_create_abstractor_suggestion_sources.rb
+- db/migrate/20140618140759_add_custom_method_to_abstractor_abstraction_sources.rb
+- db/migrate/20140618140828_add_custom_method_to_abstractor_suggestion_sources.rb
 - db/seeds.rb
 - lib/abstractor.rb
 - lib/abstractor/abstractable.rb