abstractor 1.0.23 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjVhYzRjMmQyYTc3MGFiNWQ4OWRkODQ1NmI2OTUyN2JkZTJjMmJlYg==
+    ZmI1ZTY3ZWJlZTU1MjhhNWU1MDYxZWNkNWQxMWE5YTUzOTlmYjM3NA==
   data.tar.gz: !binary |-
-    OGQ2ODg1YTA4OTEwNTMzMGRiMmM0MzQzNjBlNWVlMDBjZGUxN2NmYQ==
+    M2YyMGQwOWFmMTRiYzdkZTRlY2IzOWFhNzAwYzIzYmU1MjUzMzdhMw==
 SHA512:
   metadata.gz: !binary |-
-    YzlhMjAxNTdhZGY4ODZmMjhkZGQzZTgyOTM3ZGJhNjIwZjUyYjYxZjA3OTVl
-    M2ExNTRjNjhhZWRiZDA4Zjk2YWZiOTY3MDFhMWUyNzMyMTY5NmZkNGNlNWQz
-    ZDZmNjY4YzhiZGFhZTNhNTJjNjEwNmU0OWM3YTEzOGJhMDg3NjE=
+    YTAxZDAyMzE0OTQ2YzYxYWE0OWY4ZmUyYzhmYzlkOWJjN2M1ZWE4YzcxZmE4
+    MDdiZTNjZDA1ZDljYTc3ZjJkZDZjNDY2ZDAwZTMxMGFiMzdjN2Y0NGRlYzk0
+    YTkwOTdmMjY5N2M3NjQ3ZDkxODYxZDRhOTI0ODE0ODRlYzQxMzY=
   data.tar.gz: !binary |-
-    YjQzY2RjMjI3ZTAxZDlkNDdkMDk5MmI5ZjAwY2U1OGQ4YzM0MWZlZDIyODYy
-    ODRkZjZhZWE1MWQ1NDlkM2YxYzBhNmZiM2YyM2Y1YTE3ZTRhYTBjNGE1NDZm
-    YWZjMjhiN2E4Mjg4ZTRiMGMyNzNmYWExNTljNjcxMDBmMzA1ZTI=
+    YWM2YmE0MDI2ZmEzZjljMmU0OWVlMmE1MmQ5YTgzNzg3ZDk0Mzc0OTFlMWNk
+    YTA1M2JlMWZiY2QyZDU1ZGEwYjYxZWJiMzQ1NTg4ZmRhMTY2YWY0Mjc2Yzk4
+    YTU3YzdhNWUzMTk5NzgyMTY4ZmMzMDJlNzI3ZmRlZjM4MTE4Mzg=

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

@@ -71,6 +71,13 @@ Abstractor.AbstractionUI = function(){
     zIndex: 40000,
     dialogClass: "ui-dialog_abstractor"
   });
+
+  $(document).on('change', 'select.indirect_source_list', function () {
+    var source_type = $(this).attr('rel'),
+        value = $(this).find('option:selected').prop('value');
+    $(this).siblings('.indirect_source_text').hide();
+    $(this).siblings('.' + source_type + '_' + value).show();
+  });
 };
 
 Abstractor.AbstractionSuggestionUI = function(){

data/app/assets/stylesheets/abstractor/abstractor_abstractions.css

@@ -310,4 +310,24 @@ span.tooltip_img {
 }
 .abstractor_abstraction_actions a {
   margin: .25em;
+}
+
+.abstractor_abstraction_edit .indirect_source_list {
+  margin-bottom: 1em;
+}
+
+.indirect_sources label {
+  font-weight: bold !important;
+}
+
+.indirect_source_list {
+  width: 20em;
+}
+
+.indirect_source_text {
+   border: 1px solid #969696;
+}
+
+.indirect_source {
+  margin-bottom: 1em;
 }

data/app/models/abstractor/abstractor_abstraction.rb

@@ -1,6 +1,7 @@
 module Abstractor
   class AbstractorAbstraction < ActiveRecord::Base
     include Abstractor::Methods::Models::AbstractorAbstraction
-    # @!parse extend Moo::ClassMethods
+    # @!parse include Abstractor::Methods::Models::AbstractorAbstraction::InstanceMethods
+    # @!parse extend Abstractor::Methods::Models::AbstractorAbstraction::ClassMethods
   end
 end

data/app/models/abstractor/abstractor_abstraction_group_member.rb

@@ -1,6 +1,5 @@
 module Abstractor
   class AbstractorAbstractionGroupMember < ActiveRecord::Base
     include Abstractor::Methods::Models::AbstractorAbstractionGroupMember
-    # @!parse extend Moo::ClassMethods
   end
 end

data/app/models/abstractor/abstractor_abstraction_source_type.rb

@@ -0,0 +1,5 @@
+module Abstractor
+  class AbstractorAbstractionSourceType < ActiveRecord::Base
+    include Abstractor::Methods::Models::AbstractorAbstractionSourceType
+  end
+end

data/app/models/abstractor/abstractor_indirect_source.rb

@@ -0,0 +1,5 @@
+module Abstractor
+  class AbstractorIndirectSource < ActiveRecord::Base
+    include Abstractor::Methods::Models::AbstractorIndirectSource
+  end
+end

data/app/models/abstractor/abstractor_subject.rb

@@ -1,6 +1,6 @@
 module Abstractor
   class AbstractorSubject < ActiveRecord::Base
     include Abstractor::Methods::Models::AbstractorSubject
-    # @!parse extend Moo::ClassMethods
+    # @!parse include Abstractor::Methods::Models::AbstractorSubject::InstanceMethods
   end
 end

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

@@ -57,7 +57,7 @@
             %hr
     - else
       .column-9
-        - abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+        - abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.select { |s| s.abstractor_abstraction_source_type.name == 'nlp suggestion' }.each do |abstractor_abstraction_source|
           - from_method = abstractor_abstraction_source.from_method
           - if about.respond_to?(from_method)
             %span{ :class => 'abstractor_abstraction_source_tooltip_img label', :rel => "#abstraction_text_#{abstractor_abstraction_source.id}", :title => "#{about.class.to_s} #{from_method}"}

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

@@ -43,10 +43,9 @@
       = f.label :unknown, 'unknown'
     .column-3
       - abstractor_abstraction = f.object
-      - abstraction_sources = abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.reject{|s| s.from_method == 'unknown'}
+      - abstraction_sources = abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.select { |s| s.abstractor_abstraction_source_type.name == 'nlp suggestion' }
       - abstraction_sources.each do |abstraction_source|
         - from_method = abstraction_source.from_method
-        -#%b= from_method.titleize
         %span{ :class => 'abstractor_abstraction_source_tooltip_img label', :rel => "#abstraction_text_#{abstraction_source.id}", :title => "#{abstractor_abstraction.about.class.to_s} #{from_method}"}
           = image_tag('abstractor/page.png', :id => "abstraction_text_link_#{abstraction_source.id}")
           %br
@@ -56,3 +55,19 @@
       = f.submit 'Save', :class => 'button positive'
       = link_to 'Cancel', abstractor_abstraction, :class => 'button negative', :remote => true
     .clear
+    .indirect_sources
+      - abstraction_sources = abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.select { |s| s.abstractor_abstraction_source_type.name == 'indirect' }
+      = f.fields_for :abstractor_indirect_sources, f.object.abstractor_indirect_sources do |abstractor_indirect_source_form|
+        .indirect_source
+          - abstraction_source = abstraction_sources.select { |abstraction_source| abstraction_source.id == abstractor_indirect_source_form.object.abstractor_abstraction_source_id }.first
+          - source_setup = abstractor_abstraction.about.send(abstraction_source.from_method)
+          - sources = source_setup[:sources].all
+          %label
+            Indirect Source:
+            = source_setup[:source_type].tableize.humanize
+          %br
+          = abstractor_indirect_source_form.select :source_id, sources.map{ |s| [s.send(source_setup[:source_name_method]), s.id] }, { :include_blank => 'None' }, :size => "#{sources.size + 1}", class: 'indirect_source_list', rel: "#{source_setup[:source_type]}"
+          - sources.each do |source|
+            - hidden = abstractor_indirect_source_form.object.source_id == source.id ? '' : 'hidden'
+            %div{ class: "indirect_source_text #{hidden} #{source_setup[:source_type]}_#{source.id}"}
+              = source.send(source_setup[:source_method])

data/db/migrate/20140718014952_refactor_abstractor_rule_types.rb

@@ -0,0 +1,29 @@
+class RefactorAbstractorRuleTypes < ActiveRecord::Migration
+  def up
+    create_table :abstractor_abstraction_source_types do |t|
+      t.string :name
+      t.datetime :deleted_at
+      t.timestamps
+    end
+
+    add_column :abstractor_abstraction_sources, :abstractor_abstraction_source_type_id, :integer
+    add_column :abstractor_abstraction_sources, :abstractor_rule_type_id, :integer
+    remove_column :abstractor_subjects, :abstractor_rule_type_id
+
+    create_table  :abstractor_indirect_sources do |t|
+      t.integer   :abstractor_abstraction_id
+      t.integer   :abstractor_abstraction_source_id
+      t.string    :source_type
+      t.integer   :source_id
+      t.string    :source_method
+      t.datetime  :deleted_at
+      t.timestamps
+    end
+  end
+
+  def down
+    drop_table :abstractor_abstraction_source_types
+    remove_column :abstractor_abstraction_sources, :abstractor_abstraction_source_type_id
+    add_column :abstractor_subjects, :abstractor_rule_type_id, :integer
+  end
+end

data/lib/abstractor/abstractable.rb

@@ -1,5 +1,7 @@
 module Abstractor
   module Abstractable
+    # @!parse include Abstractor::Abstractable::InstanceMethods
+    # @!parse extend Abstractor::Abstractable::ClassMethods
     def self.included(base)
       base.class_eval do
         has_many :abstractor_abstractions, class_name: Abstractor::AbstractorAbstraction, as: :about
@@ -66,16 +68,20 @@ module Abstractor
     end
 
     module ClassMethods
-      def by_abstractor_suggestion_status(abstractor_suggestion_status)
-        abstractor_suggestion_status_needs_review = Abstractor::AbstractorSuggestionStatus.where(:name => 'Needs review').first
-        abstractor_suggestion_status_accepted= Abstractor::AbstractorSuggestionStatus.where(:name => 'Accepted').first
-        abstractor_suggestion_status_rejected = Abstractor::AbstractorSuggestionStatus.where(:name => 'Rejected').first
-
-        case abstractor_suggestion_status
+      ##
+      # Returns all abstractable entities filtered by the parameter abstractor_abstraction_status:
+      #
+      # * 'needs_review': Filter abstractable entites having at least one abstraction without a determined value (value, unknown or not_applicable).
+      # * 'reviewed': Filter abstractable entites having no abstractions without a determined value (value, unknown or not_applicable).
+      #
+      # @param [String] abstractor_abstraction_status Filter abstactable entities that an abstraction that 'needs_review' or are all abstractions are 'reviewed'.
+      # @return [ActiveRecord::Relation] List of abstractable entities.
+      def by_abstractor_abstraction_status(abstractor_abstraction_status)
+        case abstractor_abstraction_status
         when 'needs_review'
-          where(["EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}' JOIN abstractor_suggestions aas ON aa.id = aas.abstractor_abstraction_id AND aas.abstractor_suggestion_status_id = ? WHERE #{self.table_name}.id = aa.about_id)", abstractor_suggestion_status_needs_review])
+          where(["EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}' WHERE #{self.table_name}.id = aa.about_id AND aa.value IS NULL AND (aa.unknown IS NULL OR aa.unknown = ?) AND (aa.not_applicable IS NULL OR aa.not_applicable = ?))", false, false])
         when 'reviewed'
-          where(["EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}' JOIN abstractor_suggestions aas ON aa.id = aas.abstractor_abstraction_id WHERE #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}' JOIN abstractor_suggestions aas ON aa.id = aas.abstractor_abstraction_id  AND aas.abstractor_suggestion_status_id = ? WHERE #{self.table_name}.id = aa.about_id)", abstractor_suggestion_status_needs_review])
+          where(["EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}' WHERE #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_subjects asb JOIN abstractor_abstractions aa ON asb.id = aa.abstractor_subject_id AND asb.subject_type = '#{self.to_s}'WHERE #{self.table_name}.id = aa.about_id AND aa.value IS NOT NULL AND aa.unknown != ? AND aa.not_applicable != ?)", true, true])
         else
           where(nil)
         end

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

@@ -11,19 +11,21 @@ module Abstractor
 
           base.send :has_many, :abstractor_suggestions
           base.send :has_many, :abstractor_abstraction_sources, :through => :abstractor_abstractor_suggestions
+          base.send :has_many, :abstractor_indirect_sources
 
           base.send :has_one, :abstractor_abstraction_group_member
           base.send :has_one, :abstractor_abstraction_group, :through => :abstractor_abstraction_group_member
           base.send :has_one, :abstractor_abstraction_schema, :through => :abstractor_subject
 
           base.send :accepts_nested_attributes_for, :abstractor_suggestions
+          base.send :accepts_nested_attributes_for, :abstractor_indirect_sources
 
           base.send :belongs_to, :about, polymorphic: true
 
-          base.send :attr_accessible, :about, :abstractor_subject, :abstractor_subject_id, :value, :about_type, :about_id, :unknown, :not_applicable, :deleted_at
+          base.send :attr_accessible, :about, :abstractor_subject, :abstractor_subject_id, :value, :about_type, :about_id, :unknown, :not_applicable, :deleted_at, :abstractor_indirect_sources_attributes
 
           # Hooks
-          base.send :after_save, :review_matching_suggestions#, :if => lambda {|abstractor_abstraction| abstractor_abstraction.value_changed?}
+          base.send :after_save, :review_matching_suggestions
 
           base.send(:include, InstanceMethods)
           base.extend(ClassMethods)
@@ -68,6 +70,19 @@ module Abstractor
             abstractor_suggestion_status_needs_review = Abstractor::AbstractorSuggestionStatus.where(name: 'Needs review').first
             abstractor_suggestions.any? { |abstractor_suggestion| abstractor_suggestion.abstractor_suggestion_status == abstractor_suggestion_status_needs_review }
           end
+
+          ##
+          # Detects if the abstraction already has an Abstractor::AbstractorIndirectSource based on the Abstractor::AbstractorAbstractionSource passed via the abstractor_abstraction_source parameter.
+          # Retuns it if present.  Otherwise nil.
+          #
+          # @param [Abstractor::AbstractorAbstractionSource] abstractor_abstraction_source An instance of Abstractor::AbstractorAbstractionSource to check for the presence of an Abstractor::AbstractorIndirectSource.
+          # @return [Abstractor::AbstractorIndirectSource, nil]
+          def detect_abstractor_indirect_source(abstractor_abstraction_source)
+            abstractor_indirect_source = nil
+            abstractor_indirect_source = abstractor_indirect_sources(true).detect do |ais|
+              ais.abstractor_abstraction_source == abstractor_abstraction_source
+            end
+          end
         end
 
         module ClassMethods

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

@@ -7,10 +7,13 @@ module Abstractor
 
           # Associations
           base.send :belongs_to, :abstractor_subject
+          base.send :belongs_to, :abstractor_rule_type
+          base.send :belongs_to, :abstractor_abstraction_source_type
           base.send :has_many, :abstractor_suggestion_sources
           base.send :has_many, :abstractor_abstractions, :through => :abstractor_suggestion_sources
+          base.send :has_many, :abstractor_indirect_sources
 
-          base.send :attr_accessible, :abstractor_subject, :abstractor_subject_id, :deleted_at, :from_method, :custom_method
+          base.send :attr_accessible, :abstractor_subject, :abstractor_subject_id, :deleted_at, :from_method, :custom_method, :abstractor_rule_type, :abstractor_rule_type_id, :abstractor_abstraction_source_type, :abstractor_abstraction_source_type_id
         end
 
         def normalize_from_method_to_sources(about)

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

@@ -0,0 +1,16 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstractionSourceType
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many, :abstractor_abstraction_sources
+
+          base.send :attr_accessible, :deleted_at, :name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorIndirectSource
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_abstraction_source
+          base.send :belongs_to, :abstractor_abstraction
+
+          base.send :attr_accessible, :abstractor_abstraction_id, :abstractor_abstraction, :abstractor_abstraction_source_id, :abstractor_abstraction_source, :source_type, :source_id, :source_method, :reviewed
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Abstractor
           base.send :include, SoftDelete
 
           # Associations
-          base.send :has_many, :abstractor_subjects
+          base.send :has_many, :abstractor_abstraction_sources
 
           base.send :attr_accessible, :deleted_at, :description, :name, :abstractor_subjects
         end

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

@@ -6,7 +6,6 @@ module Abstractor
           base.send :include, SoftDelete
 
           # Associations
-          base.send :belongs_to, :abstractor_rule_type
           base.send :belongs_to, :abstractor_abstraction_schema
 
           base.send :has_one, :abstractor_subject_group_member
@@ -19,119 +18,168 @@ module Abstractor
           base.send :has_many, :subject_relations,  :class_name => "Abstractor::AbstractorSubjectRelation", :foreign_key => "subject_id"
 
 
-          base.send :attr_accessible, :abstractor_abstraction_schema, :abstractor_abstraction_schema_id, :abstractor_rule_type, :abstractor_rule_type_id, :subject_type, :dynamic_list_method
+          base.send :attr_accessible, :abstractor_abstraction_schema, :abstractor_abstraction_schema_id, :subject_type, :dynamic_list_method
           base.send(:include, InstanceMethods)
         end
 
         module InstanceMethods
           ##
-          # Creates or finds and instance of an Abstactor::AbstractorAbstraction.
+          # Creates or finds an instance of an Abstractor::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:
+          # The method cycles through each Abstractor::AbstractorAbstractionSource setup
+          # for the instance of the Abstractor::AbstractorSubject.
+          # The Abstractor::AbstractorSubject#abstractor_abstraction_source_type
+          # attribute determines the abstraction strategy:
+          #
+          # * 'nlp suggestion': creates instances of Abstractor::AbstractorSuggestion based on natural language processing (nlp) logic searching the text provided by the Abstractor::AbstractorSubject#from_methd attribute.
+          # * 'custom suggestion': creates instances of Abstractor::AbstractorSuggestion based on custom logic delegated to the method configured in AbstractorAbstractionSource#custom_method.
+          # * 'indirect': creates an instance of Abstractor::AbstractorIndirectSource wih null source_type, source_id, source_method attributes -- all waiting to be set upon selection of an indirect source.
+          #
+          # @param [ActiveRecord::Base] about The entity to abstract.  An instance 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)
+
+            abstractor_abstraction_sources.each do |abstractor_abstraction_source|
+              case abstractor_abstraction_source.abstractor_abstraction_source_type.name
+              when 'nlp suggestion'
+                abstract_nlp_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+              when 'custom suggestion'
+                abstract_custom_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+              when 'indirect'
+                abstract_indirect_source(about, abstractor_abstraction, abstractor_abstraction_source)
+              end
+            end
+          end
+
+          ##
+          # Creates an instance of Abstractor::AbstractorIndirectSource -- if one does not already exist --
+          # for the abstractor_abstraction and abstraction_source parameters.
+          # An 'indirect' Abstractor::AbstractorAbstractionSources give developers
+          # the ability to define a pool of documents that are indrectly related to an
+          # abstraction.  The developer is responsible for implementing a
+          # method on the abstractable enttiy specified in Abstractor::AbstractorAbstractionSource#from_method.
+          # The method should return a hash with the following keys populated:
+          #
+          # * [Array<ActiveRecord::Base>] :sources An array of active record objects that constitute the list of indirect sources.
+          # * [Symbol] :source_id A method specifying the primary key of each member in sources.
+          # * [Symbol] :source_method A method specifying the source text of each member in sources.
+          #
+          # @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 insert an indirect source.
+          # @param [Abstractor::AbstractorAbstractionSource] abstractor_abstraction_source The instance of the Abstractor::AbstractorAbstractionSource that provides the indirec source.
+          # @return [void]
+          def abstract_indirect_source(about, abstractor_abstraction, abstractor_abstraction_source)
+            if !abstractor_abstraction.detect_abstractor_indirect_source(abstractor_abstraction_source)
+              source = about.send(abstractor_abstraction_source.from_method)
+              abstractor_abstraction.abstractor_indirect_sources.build(abstractor_abstraction_source: abstractor_abstraction_source, source_type: source[:source_type], source_method: source[:source_method])
+              abstractor_abstraction.save!
+            end
+          end
+
+          ##
+          # Creates instances of Abstractor::AbstractorSuggestion and Abstractor::AbstractorSuggestionSource
+          # based on natural languange processing (nlp).
+          #
+          # The Abstractor::AbstractorSubject#abstractor_rule_type attribute determines the nlp strategy to employ:
           #
           # * '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.
+          # @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 rule type and from method to make nlp suggestions.
           # @return [void]
-          def abstract(about)
-            abstractor_abstraction = about.find_or_create_abstractor_abstraction(abstractor_abstraction_schema, self)
-            case abstractor_rule_type.name
+
+          def abstract_nlp_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
+            case abstractor_abstraction_source.abstractor_rule_type.name
             when 'name/value'
-              abstract_name_value(about, abstractor_abstraction)
+              abstract_name_value(about, abstractor_abstraction, abstractor_abstraction_source)
             when 'value'
-              abstract_value(about, abstractor_abstraction)
+              abstract_value(about, abstractor_abstraction, abstractor_abstraction_source)
             when 'unknown'
-              abstract_unknown(about, abstractor_abstraction)
-            when 'custom'
-              abstract_custom(about, abstractor_abstraction)
+              abstract_unknown(about, abstractor_abstraction, abstractor_abstraction_source)
             end
           end
 
-          # 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
+          # Creates instances of Abstractor::AbstractorSuggestion and Abstractor::AbstractorSuggestionSource
+          # based on calling the method  configured by the AbstractorAbstractionSource#custom_method attribute.
+          # The method is called on the abstractable entity passed via the about parameter.
+          #
+          # Setting up an Abstractor::AbstractorSubject with an AbstractorAbstractionSource
+          # with an AbstractorAbstractionSource#abstractor_abstraction_source_type attribute
+          # set to 'custom suggestion' 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.
+          # appropriate.  The 'custom suggestion' source type is
+          # intended to faciliate the generation of suggestions in a customizable way.
           #
-          # @param [ActiveRecord::Base] about the entity to abstraction
-          # @param [Abstractor::AbstractorAbstraction] abstractor_abstraction the instance of an abstractor abstraction
+          # @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_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)
+          def abstract_custom_suggestion(about, abstractor_abstraction, 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
 
-          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
+          def abstract_unknown(about, abstractor_abstraction, abstractor_abstraction_source)
+            create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
           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)
-            end
+          def abstract_value(about, abstractor_abstraction, abstractor_abstraction_source)
+            abstract_sentential_value(about, abstractor_abstraction, abstractor_abstraction_source)
+            create_unknown_abstractor_suggestion(about, abstractor_abstraction, abstractor_abstraction_source)
           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)
-
-                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_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, nil)
-                          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
+
+              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
@@ -141,34 +189,30 @@ module Abstractor
             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)
-            end
+          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_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
+          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 = 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, 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, nil)
                     end
                   end
                 end
@@ -176,31 +220,29 @@ module Abstractor
             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, nil)
-                              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 = 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
@@ -253,27 +295,25 @@ module Abstractor
             suggested_value.instance_of?(Abstractor::AbstractorObjectValue)
           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, nil)
-                          end
+          def create_unknown_abstractor_suggestion_name_only(about, abstractor_abstraction, 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

data/lib/abstractor/setup.rb

@@ -1,7 +1,7 @@
 module Abstractor
   module Setup
     def self.system
-      puts 'Setting up AbstractorObjectType'
+      puts 'Setting up Abstractor::AbstractorObjectType'
       Abstractor::AbstractorObjectType.find_or_create_by_value('list')
       Abstractor::AbstractorObjectType.find_or_create_by_value('number')
       Abstractor::AbstractorObjectType.find_or_create_by_value('boolean')
@@ -10,21 +10,24 @@ module Abstractor
       Abstractor::AbstractorObjectType.find_or_create_by_value('date')
       Abstractor::AbstractorObjectType.find_or_create_by_value('dynamic list')
 
-      puts 'Setting up AbstractorRuleType'
+      puts 'Setting up Abstractor::AbstractorRuleType'
       Abstractor::AbstractorRuleType.find_or_create_by_name_and_description(name: 'name/value', description:'search for value associated with name')
-      Abstractor::AbstractorRuleType.find_or_create_by_name_and_description(name:'name', description: 'search for name match')
       Abstractor::AbstractorRuleType.find_or_create_by_name_and_description(name:'value', description: 'search for value match')
       Abstractor::AbstractorRuleType.find_or_create_by_name_and_description(name: 'unknown', description: 'do not try to abstract, always assign "unknown"')
-      Abstractor::AbstractorRuleType.find_or_create_by_name_and_description(name:'custom', description: 'use whatever from_method returns as a value')
 
-      puts 'Setting up AbstractorSuggestionStatus'
+      puts 'Setting up Abstractor::AbstractorSuggestionStatus'
       Abstractor::AbstractorSuggestionStatus.find_or_create_by_name('Needs review')
       Abstractor::AbstractorSuggestionStatus.find_or_create_by_name('Accepted')
       Abstractor::AbstractorSuggestionStatus.find_or_create_by_name('Rejected')
 
-      puts 'Setting up AbstractorRelationType'
+      puts 'Setting up Abstractor::AbstractorRelationType'
       Abstractor::AbstractorRelationType.find_or_create_by_name('member_of')
       Abstractor::AbstractorRelationType.find_or_create_by_name('preceded_by')
+
+      puts 'Setting up Abstractor::AbstractorAbstractionSourceType'
+      Abstractor::AbstractorAbstractionSourceType.find_or_create_by_name('nlp suggestion')
+      Abstractor::AbstractorAbstractionSourceType.find_or_create_by_name('custom suggestion')
+      Abstractor::AbstractorAbstractionSourceType.find_or_create_by_name('indirect')
     end
   end
 end

data/lib/abstractor/version.rb

@@ -1,3 +1,3 @@
 module Abstractor
-  VERSION = '1.0.23'
+  VERSION = '2.0.0'
 end

data/lib/generators/abstractor/install/install_generator.rb

@@ -63,13 +63,13 @@ module Abstractor
         insert_into_file("#{Rails.root}/config/environments/development.rb", :after => /::Application.configure do\n/) do
 '  StanfordCoreNLP.use :english
   StanfordCoreNLP.model_files = {}
-  StanfordCoreNLP.jar_path = "#{Rails.root}/lib/stanford-corenlp-full-2014-01-04/"
-  StanfordCoreNLP.model_path = "#{Rails.root}/lib/stanford-corenlp-full-2014-01-04/"
+  StanfordCoreNLP.jar_path = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16/"
+  StanfordCoreNLP.model_path = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16/"
   StanfordCoreNLP.default_jars = [
     "joda-time.jar",
     "xom.jar",
-    "stanford-corenlp-3.3.1.jar",
-    "stanford-corenlp-3.3.1-models.jar",
+    "stanford-corenlp-3.4.jar",
+    "stanford-corenlp-3.4-models.jar",
     "jollyday.jar",
     "bridge.jar"
   ]

data/lib/tasks/abstractor_tasks.rake

@@ -8,20 +8,20 @@ namespace :abstractor do
       Abstractor::Setup.system
     end
 
-    desc "Setup Stanford CoreNLP library in lib/stanford-corenlp-full-2014-01-04/ directory"
+    desc "Setup Stanford CoreNLP library in lib/stanford-corenlp-full-2014-06-16/ directory"
     task :stanford_core_nlp => :environment do
       puts 'Please be patient...This could take a while.'
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-01-04.zip"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16.zip"
       open(file, 'wb') do |fo|
-        fo.print open('http://nlp.stanford.edu/software/stanford-corenlp-full-2014-01-04.zip').read
+        fo.print open('http://nlp.stanford.edu/software/stanford-corenlp-full-2014-06-16.zip').read
       end
 
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-01-04.zip"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16.zip"
       destination = "#{Rails.root}/lib/"
       puts 'Unzipping...'
       unzip_file(file, destination)
 
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-01-04/bridge.jar"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16/bridge.jar"
       open(file, 'wb') do |fo|
         fo.print open('https://github.com/louismullie/stanford-core-nlp/blob/master/bin/bridge.jar?raw=true').read
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractor
 version: !ruby/object:Gem::Version
-  version: 1.0.23
+  version: 2.0.0
 platform: ruby
 authors:
 - Michael Gurley, Yulia Bushmanova
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-17 00:00:00.000000000 Z
+date: 2014-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -438,6 +438,8 @@ files:
 - app/models/abstractor/abstractor_abstraction_schema_predicate_variant.rb
 - app/models/abstractor/abstractor_abstraction_schema_relation.rb
 - app/models/abstractor/abstractor_abstraction_source.rb
+- app/models/abstractor/abstractor_abstraction_source_type.rb
+- app/models/abstractor/abstractor_indirect_source.rb
 - app/models/abstractor/abstractor_object_type.rb
 - app/models/abstractor/abstractor_object_value.rb
 - app/models/abstractor/abstractor_object_value_variant.rb
@@ -484,6 +486,7 @@ files:
 - db/migrate/20140618140759_add_custom_method_to_abstractor_abstraction_sources.rb
 - db/migrate/20140618140828_add_custom_method_to_abstractor_suggestion_sources.rb
 - db/migrate/20140716184049_add_dynamic_list_method_to_abstractor_subjects.rb
+- db/migrate/20140718014952_refactor_abstractor_rule_types.rb
 - db/seeds.rb
 - lib/abstractor.rb
 - lib/abstractor/abstractable.rb
@@ -501,6 +504,8 @@ files:
 - lib/abstractor/methods/models/abstractor_abstraction_schema_predicate_variant.rb
 - lib/abstractor/methods/models/abstractor_abstraction_schema_relation.rb
 - lib/abstractor/methods/models/abstractor_abstraction_source.rb
+- lib/abstractor/methods/models/abstractor_abstraction_source_type.rb
+- lib/abstractor/methods/models/abstractor_indirect_source.rb
 - lib/abstractor/methods/models/abstractor_object_type.rb
 - lib/abstractor/methods/models/abstractor_object_value.rb
 - lib/abstractor/methods/models/abstractor_object_value_variant.rb