abstractor 1.0.8

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

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

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

@@ -0,0 +1,24 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorObjectValue
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many, :abstractor_object_value_variants
+          base.send :has_many, :abstractor_abstraction_schema_object_values
+          base.send :has_many, :abstractor_abstraction_schemas, :through => :abstractor_abstraction_schema_object_values
+
+          #Validations
+          base.send :attr_accessible, :value, :abstractor_object_value_variants, :abstractor_abstraction_schema_object_values, :abstractor_abstraction_schemas
+        end
+
+        # Instance Methods
+        def object_variants
+          [value].concat(abstractor_object_value_variants.map(&:value))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorObjectValueVariant
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_object_value
+
+          base.send :attr_accessible, :abstractor_object_value, :abstractor_object_value_id, :deleted_at, :value
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,258 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSubject
+        def self.included(base)
+          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
+          base.send :has_one, :abstractor_subject_group, :through => :abstractor_subject_group_member
+
+          base.send :has_many, :abstractor_abstractions
+          base.send :has_many, :abstractor_abstraction_sources
+
+          base.send :has_many, :object_relations,   :class_name => "Abstractor::AbstractorSubjectRelation", :foreign_key => "object_id"
+          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
+        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)
+          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)
+          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)
+          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)
+
+              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
+
+              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_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)
+                        end
+                      end
+                    end
+                  end
+                end
+              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)
+          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
+
+                    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)
+                    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)
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              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)
+          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
+                                             )
+          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)
+                        end
+                      end
+                    end
+                  end
+                end
+              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)
+            end
+          end
+        end
+
+        def groupable?
+          !abstractor_subject_group_member.nil?
+        end
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSubjectGroup
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many, :abstractor_subject_group_members
+          base.send :has_many, :abstractor_subjects, :through => :abstractor_subject_group_members
+          base.send :has_many, :abstractor_abstraction_groups
+          base.send :has_many, :abstractor_abstractions, :through => :abstractor_abstraction_groups
+
+          base.send :attr_accessible, :deleted_at, :name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSubjectGroupMember
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_subject_group
+          base.send :belongs_to, :abstractor_subject
+
+          base.send :attr_accessible, :abstractor_subject_group, :abstractor_subject_group_id, :abstractor_subject_id, :display_order, :deleted_at, :abstractor_subject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSubjectRelation
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_relation_type
+          base.send :belongs_to, :object,   :class_name => "Abstractor::AbstractorSubject", :foreign_key => "object_id"
+          base.send :belongs_to, :subject,  :class_name => "Abstractor::AbstractorSubject", :foreign_key => "subject_id"
+
+          base.send :attr_accessible, :abstractor_relation_type, :abstractor_relation_type_id, :object, :object_id, :subject, :subject_id, :deleted_at
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSuggestion
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_abstraction
+          base.send :belongs_to, :abstractor_suggestion_status
+
+          base.send :has_one, :abstractor_suggestion_object_value
+          base.send :has_one, :abstractor_object_value, :through => :abstractor_suggestion_object_value
+
+          base.send :has_many, :abstractor_suggestion_sources
+
+          base.send :attr_accessible, :abstractor_abstraction, :abstractor_abstraction_id, :abstractor_suggestion_sources, :abstractor_suggestion_source_id, :abstractor_suggestion_status, :abstractor_suggestion_status_id, :suggested_value, :deleted_at, :unknown, :not_applicable
+
+          # Hooks
+          base.send :after_save, :update_abstraction_value, :if => lambda {|abstractor_suggestion| abstractor_suggestion.abstractor_suggestion_status_id_changed?}
+          base.send :after_save, :update_siblings_status, :if => lambda {|abstractor_suggestion| abstractor_suggestion.abstractor_suggestion_status_id_changed?}
+        end
+
+        # Instance Methods
+        def update_abstraction_value
+          if abstractor_suggestion_status.accepted?
+            abstractor_abstraction.value                     = suggested_value
+            abstractor_abstraction.unknown                   = unknown
+            abstractor_abstraction.not_applicable            = not_applicable
+            abstractor_abstraction.save!
+          elsif abstractor_suggestion_status.needs_review?
+            abstractor_abstraction.value          = nil
+            abstractor_abstraction.unknown        = nil
+            abstractor_abstraction.not_applicable = nil
+            abstractor_abstraction.save!
+          elsif abstractor_suggestion_status.rejected?
+            abstractor_abstraction.value          = nil if abstractor_abstraction.value == suggested_value
+            abstractor_abstraction.unknown        = nil if unknown && abstractor_abstraction.unknown == unknown
+            abstractor_abstraction.not_applicable = nil if not_applicable && abstractor_abstraction.not_applicable == not_applicable
+            abstractor_abstraction.save!
+          end
+        end
+
+        def update_siblings_status
+          rejected_status = Abstractor::AbstractorSuggestionStatus.where(:name => 'Rejected').first
+          needs_review_status = Abstractor::AbstractorSuggestionStatus.where(:name => 'Needs review').first
+
+          if abstractor_suggestion_status.accepted?
+            #reject sibling suggestions
+            self.sibling_suggestions.each do |abstractor_suggestion|
+              abstractor_suggestion.abstractor_suggestion_status = rejected_status
+              abstractor_suggestion.save!
+            end
+          elsif abstractor_suggestion_status.needs_review?
+            #reset status on sibling suggestions
+            self.sibling_suggestions.each do |abstractor_suggestion|
+              abstractor_suggestion.abstractor_suggestion_status = needs_review_status
+              abstractor_suggestion.save!
+            end
+          end
+        end
+
+        def display_value
+          if unknown
+            'unknown'
+          elsif not_applicable
+            'not applicable'
+          else
+            suggested_value
+          end
+        end
+
+        def sibling_suggestions
+          abstractor_abstraction.abstractor_suggestions.where('id != ?', id)
+        end
+
+        def detect_abstractor_suggestion_source(abstractor_abstraction_source, sentence_match_value, source_id, source_type)
+          abstractor_suggestion_source = abstractor_suggestion_sources.detect do |abstractor_suggestion_source|
+            abstractor_suggestion_source.abstractor_abstraction_source == abstractor_abstraction_source &&
+            abstractor_suggestion_source.sentence_match_value == sentence_match_value &&
+            abstractor_suggestion_source.source_id == source_id &&
+            abstractor_suggestion_source.source_type == source_type
+          end
+        end
+      end
+    end
+  end
+end