abstractor 4.3.3 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a061d566e99d4c51eb64e933e20c1a87d8055fa
-  data.tar.gz: 3c110a04810414ee724e1ecfffdc05f907723da4
+  metadata.gz: b812a802ae7263947c7d57b0e8ebd3bfc5d9861d
+  data.tar.gz: 7f950eef0cc2ebfb940219b9f3fdb6f83853cb51
 SHA512:
-  metadata.gz: 5f5ebb7723d60f1389bce4c4f9a23aea5ac6f7982079014f0c5869fef4657f46a6e90b62730806159737b4459b95caa9ed3d4f1d27ade32fd023f80c218331d6
-  data.tar.gz: fe161176c8a8570a50a6d24e2a43326cef54f3a602844ca9934bcb74b3044225d778df84a1cc523a3b017e5e22d11ea465fa669b23c3b5b2dadb4156062a01d6
+  metadata.gz: 5c5b88efd3f276b9bb8b77f5a800c0b44474f9ce2b67d66795e8a8390e40643ee155ed47d41f1777892f6bfef62a75262f70808108e095326e48e876e9de68b0
+  data.tar.gz: e2e6bec4bace81fd45b51de2f085ddd6d780ade29976f9cd4b9c4c1530b70af9780e5ee9b8d9d0678852ddd2621981c06e046e045728ba8aab98b980abc72fa1

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

@@ -16,14 +16,14 @@
       - when 'number'
         = f.number_field :value
       - when 'radio button list'
-        - values = abstraction_schema.abstractor_object_values.sort_by(&:value)
+        - values = abstraction_schema.abstractor_object_values.order('abstractor_abstraction_schema_object_values.display_order, abstractor_object_values.value')
         -  values.each do |value|
           = f.radio_button :value, value.value
           = f.label :value, value.value, value: value.value
         = f.radio_button :value, '', {:style => 'display:none;' }
          
       - when 'list'
-        - values = abstraction_schema.abstractor_object_values.sort_by(&:value)
+        - values = abstraction_schema.abstractor_object_values.order('abstractor_abstraction_schema_object_values.display_order, abstractor_object_values.value')
         = f.select :value, values.map{|s| [s.value, s.value]}, {:include_blank => true}, :class => "combobox"
       - when 'dynamic list'
         - values = abstractor_abstraction.about.send(abstractor_abstraction.abstractor_subject.dynamic_list_method).sort_by { |l| l[:value] }

data/db/migrate/20150422135935_add_display_order_to_abstractor_abstraction_schema_object_values.rb

@@ -0,0 +1,5 @@
+class AddDisplayOrderToAbstractorAbstractionSchemaObjectValues < ActiveRecord::Migration
+  def change
+    add_column :abstractor_abstraction_schema_object_values, :display_order, :integer
+  end
+end

data/db/migrate/20150423045055_add_subtype_to_abstractor_subject_groups.rb

@@ -0,0 +1,5 @@
+class AddSubtypeToAbstractorSubjectGroups < ActiveRecord::Migration
+  def change
+    add_column :abstractor_subject_groups, :subtype, :string
+  end
+end

data/db/migrate/20150505022228_add_subtype_to_abstractor_abstraction_groups.rb

@@ -0,0 +1,5 @@
+class AddSubtypeToAbstractorAbstractionGroups < ActiveRecord::Migration
+  def change
+    add_column :abstractor_abstraction_groups, :subtype, :string
+  end
+end

data/lib/abstractor/abstractable.rb

@@ -88,9 +88,12 @@ module Abstractor
       # @return [void]
       def abstract(options = {})
         options = { namespace_type: nil, namespace_id: nil, abstractor_abstraction_schema_ids: [] }.merge(options)
+        sentinental_groups = []
         self.class.abstractor_subjects(options).each do |abstractor_subject|
           abstractor_subject.abstract(self)
+          sentinental_groups << abstractor_subject.abstractor_subject_group if abstractor_subject.abstractor_subject_group && abstractor_subject.abstractor_subject_group.has_subtype?(Abstractor::Enum::ABSTRACTOR_GROUP_SENTINENTAL_SUBTYPE)
         end
+        sentinental_groups.uniq.map{|sentinental_group| regroup_sentinental_suggestions(sentinental_group, options)}
       end
 
       def detect_abstractor_abstraction(abstractor_subject)
@@ -98,11 +101,13 @@ module Abstractor
       end
 
       def find_or_create_abstractor_abstraction(abstractor_abstraction_schema, abstractor_subject)
+        options = { namespace_type: abstractor_subject.namespace_type, namespace_id: abstractor_subject.namespace_id }
         if abstractor_abstraction = detect_abstractor_abstraction(abstractor_subject)
         else
           abstractor_abstraction = Abstractor::AbstractorAbstraction.create!(abstractor_subject: abstractor_subject, about: self)
+
           if abstractor_subject.groupable?
-            abstractor_abstraction_group = find_or_initialize_abstractor_abstraction_group(abstractor_subject.abstractor_subject_group)
+            abstractor_abstraction_group = find_or_initialize_abstractor_abstraction_group(abstractor_subject.abstractor_subject_group, options)
             abstractor_abstraction_group.abstractor_abstractions << abstractor_abstraction
             abstractor_abstraction_group.save!
           end
@@ -110,12 +115,15 @@ module Abstractor
         abstractor_abstraction
       end
 
-      def detect_abstractor_abstraction_group(abstractor_subject_group)
-        abstractor_abstraction_groups(true).detect { |abstractor_abstraction_group| abstractor_abstraction_group.abstractor_subject_group_id ==  abstractor_subject_group.id }
+      def detect_abstractor_abstraction_group(abstractor_subject_group, options)
+        abstractor_abstraction_groups(true).
+          select { |abstractor_abstraction_group| abstractor_abstraction_group.abstractor_subject_group_id ==  abstractor_subject_group.id }.
+          select { |abstractor_abstraction_group| abstractor_abstraction_group.abstractor_abstractions.joins(:abstractor_subject).where(abstractor_subjects: { namespace_type: options[:namespace_type], namespace_id: options[:namespace_id]}).any?}.
+          first
       end
 
-      def find_or_initialize_abstractor_abstraction_group(abstractor_subject_group)
-        if abstractor_abstraction_group = detect_abstractor_abstraction_group(abstractor_subject_group)
+      def find_or_initialize_abstractor_abstraction_group(abstractor_subject_group, options)
+        if abstractor_abstraction_group = detect_abstractor_abstraction_group(abstractor_subject_group, options)
         else
           abstractor_abstraction_group = Abstractor::AbstractorAbstractionGroup.new(abstractor_subject_group: abstractor_subject_group, about: self, system_generated: true)
         end
@@ -191,6 +199,143 @@ module Abstractor
           end
         end
       end
+
+      ##
+      # Regroups suggestions for subjects grouped marked with 'sentinental' subtype. Does not affect abstraction groups with curated values.
+      # Creates an abstraction group for each combination of suggestions that came from the same sentence.
+      # Creates groups only if there are enough abstractions.
+      #
+      # @param [ActiveRecord::Relation] sentinental_group sentinental group to process
+      # @return [void]
+      def regroup_sentinental_suggestions(sentinental_group, options)
+        sentinental_group_abstractor_subjects           = sentinental_group.abstractor_subjects.not_deleted
+        if options[:namespace_type] || options[:namespace_id]
+          sentinental_group_abstractor_subjects           = sentinental_group_abstractor_subjects.where(namespace_type: options[:namespace_type], namespace_id: options[:namespace_id])
+        end
+
+        sentinental_group_abstractor_abstraction_groups = Abstractor::AbstractorAbstractionGroup.not_deleted.joins(:abstractor_subject_group, :abstractor_abstractions).where(abstractor_subject_group_id: sentinental_group.id, abstractor_abstractions: {about_id: self.id, abstractor_subject_id: sentinental_group_abstractor_subjects.map(&:id)}).distinct
+
+        sentinental_group_abstractor_suggestion_sources = Abstractor::AbstractorSuggestionSource.joins(abstractor_suggestion: { abstractor_abstraction: :abstractor_abstraction_group})
+          .where(abstractor_abstraction_groups: { id: sentinental_group_abstractor_abstraction_groups.map(&:id)}, abstractor_abstractions: { abstractor_subject_id: sentinental_group_abstractor_subjects.map(&:id), about_id: self.id})
+
+        sentinental_abstractor_abstraction_groups = sentinental_group_abstractor_abstraction_groups.where(subtype: Abstractor::Enum::ABSTRACTOR_GROUP_SENTINENTAL_SUBTYPE)
+
+        sentinental_group_abstractor_abstraction_groups.each do |abstractor_abstraction_group|
+          unless abstractor_abstraction_group.abstractor_abstractions.not_deleted.where(about_id: self.id).where('value is not null').any? # skip abstraction groups with curated abstractions
+            # get all suggestion sources
+            abstractor_suggestion_sources = sentinental_group_abstractor_suggestion_sources.where(abstractor_abstraction_groups: { id: abstractor_abstraction_group.id})
+
+            # get all matched sentences
+            sentence_match_values = abstractor_suggestion_sources.select(:sentence_match_value).distinct.map(&:sentence_match_value).compact
+
+            # skip groups where all abstractions come from the same sentence
+            unless sentence_match_values.length == 1
+              # create abstraction group for each sentence
+              sentence_match_values.each do |sentence_match_value|
+                # get all suggestion sources that reference the sentence
+                abstractor_suggestion_sources_by_sentence = abstractor_suggestion_sources.where(sentence_match_value: sentence_match_value)
+
+                abstractor_subjects = abstractor_suggestion_sources_by_sentence.
+                  map{|abstractor_suggestion_source| abstractor_suggestion_source.abstractor_suggestion.abstractor_abstraction.abstractor_subject }.
+                  reject{|abstractor_subject| abstractor_subject.abstractor_subject_group.blank? || abstractor_subject.abstractor_subject_group.id != sentinental_group.id}.uniq
+
+                if abstractor_subjects.length == sentinental_group_abstractor_subjects.length
+                  matching_abstractor_suggestion_sources = sentinental_group_abstractor_suggestion_sources.where(sentence_match_value: sentence_match_value)
+
+                  existing_abstractor_abstraction_group = matching_abstractor_suggestion_sources.
+                    map{|abstractor_suggestion_source| abstractor_suggestion_source.abstractor_suggestion.abstractor_abstraction.abstractor_abstraction_group}.
+                    select{|aag| sentinental_abstractor_abstraction_groups.map(&:id).include? aag.id}.
+                    reject{|aag| aag.id == abstractor_abstraction_group.id}.uniq.first
+
+                  if existing_abstractor_abstraction_group
+                    new_abstractor_abstraction_group = existing_abstractor_abstraction_group
+                  else
+                    new_abstractor_abstraction_group  = Abstractor::AbstractorAbstractionGroup.new(abstractor_subject_group: abstractor_abstraction_group.abstractor_subject_group, about: self, system_generated: true, subtype: abstractor_abstraction_group.abstractor_subject_group.subtype)
+                  end
+
+                  abstractor_suggestion_sources_by_sentence.all.each do |abstractor_suggestion_source|
+                    abstractor_suggestion   = abstractor_suggestion_source.abstractor_suggestion
+                    abstractor_abstraction  = abstractor_suggestion.abstractor_abstraction
+
+                    # if corresponding abstraction has more than one suggestion and should not be moved
+                    # create a new abstraction if the new group does not yet have abstraction for the same subject
+                    abstractor_subject = abstractor_abstraction.abstractor_subject
+                    existing_new_abstractor_abstraction = new_abstractor_abstraction_group.abstractor_abstractions.select{|aa| aa.abstractor_subject_id == abstractor_subject.id}.first
+
+                    if existing_new_abstractor_abstraction
+                      new_abstractor_abstraction = existing_new_abstractor_abstraction
+                    else
+                      if abstractor_abstraction.abstractor_suggestions.length > 1
+                        new_abstractor_abstraction  = Abstractor::AbstractorAbstraction.create!(abstractor_subject: abstractor_suggestion.abstractor_abstraction.abstractor_subject, about: self)
+                      else
+                        new_abstractor_abstraction = abstractor_abstraction
+                        new_abstractor_abstraction.abstractor_abstraction_group_member = nil
+                        new_abstractor_abstraction.build_abstractor_abstraction_group_member(abstractor_abstraction_group: new_abstractor_abstraction_group)
+                      end
+                      unless new_abstractor_abstraction_group.abstractor_abstractions.include? new_abstractor_abstraction
+                        new_abstractor_abstraction_group.abstractor_abstractions << new_abstractor_abstraction
+                      end
+                    end
+
+                    # if new abstraction already has matching suggestion, use it to map sources
+                    new_abstractor_suggestion = new_abstractor_abstraction.detect_abstractor_suggestion(abstractor_suggestion.suggested_value, abstractor_suggestion.unknown, abstractor_suggestion.not_applicable)
+
+                    # if matching suggestion does not exist, create a new suggestion if corresponding suggestion has multiple sources
+                    # and should not be moved of move existing one to the new abstraction
+                    # and map suggestion source to the new suggestion
+                    if new_abstractor_suggestion.blank?
+                      if abstractor_suggestion.abstractor_suggestion_sources.length > 1
+                        new_abstractor_suggestion ||=  Abstractor::AbstractorSuggestion.create!(
+                          abstractor_abstraction: new_abstractor_abstraction,
+                          abstractor_suggestion_status: Abstractor::AbstractorSuggestionStatus.where(name: 'Needs review').first,
+                          suggested_value: abstractor_suggestion.suggested_value,
+                          unknown: abstractor_suggestion.unknown,
+                          not_applicable: abstractor_suggestion.not_applicable
+                        )
+                      else
+                        new_abstractor_suggestion = abstractor_suggestion
+                      end
+                    end
+
+                    new_abstractor_suggestion.abstractor_abstraction  = new_abstractor_abstraction
+                    new_abstractor_suggestion.save!
+
+                    existing_abstractor_suggestion_source = abstractor_suggestion.detect_abstractor_suggestion_source(abstractor_suggestion_source.abstractor_abstraction_source, abstractor_suggestion_source.sentence_match_value, abstractor_suggestion_source.source_id, abstractor_suggestion_source.source_type, abstractor_suggestion_source.source_method, abstractor_suggestion_source.section_name)
+
+                    if existing_abstractor_suggestion_source && existing_abstractor_suggestion_source != abstractor_suggestion_source
+                      abstractor_suggestion_source.delete
+                    else
+                      abstractor_suggestion_source.abstractor_suggestion = new_abstractor_suggestion
+                      abstractor_suggestion_source.save!
+                    end
+                  end
+
+                  # do not save group if it does not have abstractions
+                  new_abstractor_abstraction_group.save! if new_abstractor_abstraction_group.abstractor_abstractions.any?
+                end
+              end
+
+              abstractor_abstraction_group_siblings = AbstractorAbstractionGroup.not_deleted.joins(:abstractor_subject_group, :abstractor_abstractions).where(abstractor_subject_group_id: sentinental_group.id, abstractor_abstractions: {about_id: self.id, abstractor_subject_id: sentinental_group_abstractor_subjects.map(&:id)}).distinct
+
+              if abstractor_abstraction_group_siblings.length > 1
+                abstractor_abstraction_group.reload.abstractor_abstractions.each do |abstractor_abstraction|
+                  abstractor_abstraction.abstractor_suggestions.each do |abstractor_suggestion|
+                    abstractor_suggestion.abstractor_suggestion_sources.delete_all
+                    abstractor_suggestion.abstractor_suggestion_object_value.delete if abstractor_suggestion.abstractor_suggestion_object_value
+                    abstractor_suggestion.delete
+                  end
+                  abstractor_abstraction.abstractor_indirect_sources.each do |abstractor_indirect_source|
+                    abstractor_indirect_source.delete
+                  end
+                  abstractor_abstraction.delete
+                end
+                abstractor_abstraction_group.reload.abstractor_abstraction_group_members.map{|a| a.delete}
+                abstractor_abstraction_group.delete
+              end
+            end
+          end
+        end
+      end
     end
 
     module ClassMethods
@@ -198,7 +343,7 @@ module Abstractor
       # Returns all abstractable entities filtered by the parameter abstractor_suggestion_type:
       #
       # * 'unknown': Filter abstractable entites having at least one suggestion withat a suggested value of 'unknown'
-      # * 'not unknown': Filter abstractable entites having at least one suggestion with an acutal value
+      # * 'suggested': Filter abstractable entites having at least one suggestion with an acutal value
       #
       # @param [String] abstractor_suggestion_type Filter abstactable entities that have a least one 'unknwon' or at least one 'not unknown' suggestion
       # @param [Hash] options The options to filter the entities returned.
@@ -213,7 +358,7 @@ module Abstractor
           case abstractor_suggestion_type
           when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_UNKNOWN
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND sug.unknown = ?)", options[:namespace_type], options[:namespace_id], options[:abstractor_abstraction_schemas], true])
-          when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_NOT_UNKNOWN
+          when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_SUGGESTED
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(sug.unknown, ?) = ? AND sug.suggested_value IS NOT NULL AND COALESCE(sug.suggested_value, '') != '' )", options[:namespace_type], options[:namespace_id], options[:abstractor_abstraction_schemas], false, false])
           else
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? AND sub.abstractor_abstraction_schema_id IN (?) WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id)", options[:namespace_type], options[:namespace_id], options[:abstractor_abstraction_schemas]])
@@ -222,7 +367,7 @@ module Abstractor
           case abstractor_suggestion_type
           when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_UNKNOWN
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND sug.unknown = ?)", options[:abstractor_abstraction_schemas], true])
-          when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_NOT_UNKNOWN
+          when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_SUGGESTED
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(sug.unknown, ?) = ? AND sug.suggested_value IS NOT NULL AND COALESCE(sug.suggested_value, '') != '' )", options[:abstractor_abstraction_schemas], false, false])
           else
             where(nil)
@@ -235,7 +380,7 @@ module Abstractor
       #
       # * '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).
-      #
+      # * 'actually answered': Filter abstractable entites having no abstractions without an actual value (exluding blank, unknown or not_applicable).
       # @param [String] abstractor_abstraction_status Filter abstactable entities that an abstraction that 'needs_review' or are all abstractions are 'reviewed'.
       # @param [Hash] options the options to filter the entities returned.
       # @option options [String] :namespace_type The type parameter of the namespace to filter the entities.
@@ -250,6 +395,8 @@ module Abstractor
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND (aa.value IS NULL OR aa.value = '') AND (aa.unknown IS NULL OR aa.unknown = ?) AND (aa.not_applicable IS NULL OR aa.not_applicable = ?))", options[:namespace_type], options[:namespace_id], false, false])
           when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '' AND COALESCE(aa.unknown, ?) != ? AND COALESCE(aa.not_applicable, ?) != ?)", options[:namespace_type], options[:namespace_id], options[:namespace_type], options[:namespace_id], false, true, false, true])
+          when Abstractor::Enum::ABSTRACTION_STATUS_ACTUALLY_ANSWERED
+            where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '')", options[:namespace_type], options[:namespace_id], options[:namespace_type], options[:namespace_id]])
           else
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id)", options[:namespace_type], options[:namespace_id]])
           end
@@ -259,6 +406,8 @@ module Abstractor
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND (aa.value IS NULL OR aa.value = '') AND (aa.unknown IS NULL OR aa.unknown = ?) AND (aa.not_applicable IS NULL OR aa.not_applicable = ?))", false, false])
           when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
             where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '' AND COALESCE(aa.unknown, ?) != ? AND COALESCE(aa.not_applicable, ?) != ?)", false, true, false, true])
+          when Abstractor::Enum::ABSTRACTION_STATUS_ACTUALLY_ANSWERED
+            where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '')"])
           else
             where(nil)
           end

data/lib/abstractor/core_ext/string.rb

@@ -41,7 +41,11 @@ class String
       rng = range(pattern, i)
       if rng
         r << rng
-        i += reuse ? 1 : rng.end + 1
+        if reuse
+          i +=1
+        else
+          i = rng.end + 1
+        end
       else
         break
       end

data/lib/abstractor/enum.rb

@@ -6,11 +6,12 @@ module Abstractor
 
     ABSTRACTION_STATUS_NEEDS_REVIEW = 'needs review'
     ABSTRACTION_STATUS_REVIEWED = 'reviewed'
-    ABSTRACTION_STATUSES = [ABSTRACTION_STATUS_NEEDS_REVIEW, ABSTRACTION_STATUS_REVIEWED]
+    ABSTRACTION_STATUS_ACTUALLY_ANSWERED = 'actually answered'
+    ABSTRACTION_STATUSES = [ABSTRACTION_STATUS_NEEDS_REVIEW, ABSTRACTION_STATUS_REVIEWED, ABSTRACTION_STATUS_ACTUALLY_ANSWERED]
 
     ABSTRACTION_SUGGESTION_TYPE_UNKNOWN = 'unknown'
-    ABSTRACTION_SUGGESTION_TYPE_NOT_UNKNOWN = 'not unknown'
-    ABSTRACTION_SUGGESTION_TYPES = [ABSTRACTION_SUGGESTION_TYPE_UNKNOWN, ABSTRACTION_SUGGESTION_TYPE_NOT_UNKNOWN]
+    ABSTRACTION_SUGGESTION_TYPE_SUGGESTED = 'suggested'
+    ABSTRACTION_SUGGESTION_TYPES = [ABSTRACTION_SUGGESTION_TYPE_UNKNOWN, ABSTRACTION_SUGGESTION_TYPE_SUGGESTED]
 
     ABSTRACTOR_SECTION_TYPE_CUSTOM = 'custom'
     ABSTRACTOR_SECTION_TYPE_NAME_VALUE = 'name/value'
@@ -20,5 +21,6 @@ module Abstractor
     ABSTRACTOR_SUGGESTION_STATUS_ACCEPTED = 'Accepted'
     ABSTRACTOR_SUGGESTION_STATUS_REJECTED = 'Rejected'
     ABSTRACTOR_SUGGESTION_STATUSES = [ABSTRACTOR_SUGGESTION_STATUS_NEEDS_REVIEW, ABSTRACTOR_SUGGESTION_STATUS_ACCEPTED, ABSTRACTOR_SUGGESTION_STATUS_REJECTED]
+    ABSTRACTOR_GROUP_SENTINENTAL_SUBTYPE = 'sentinental'
   end
 end

data/lib/abstractor/methods/controllers/abstractor_suggestions_controller.rb

@@ -15,7 +15,7 @@ module Abstractor
               abstractor_suggestion = nil
               Abstractor::AbstractorSuggestion.transaction do
                 suggestion[:suggestion_sources].each do |suggestion_source|
-                  abstractor_suggestion = @abstractor_abstraction.abstractor_subject.suggest(@abstractor_abstraction, abstractor_abstraction_source, suggestion_source[:match_value], suggestion_source[:sentence_match_value], suggestion[:source_id], suggestion[:source_type], suggestion[:source_method], nil, suggestion[:value], suggestion[:unknown], suggestion[:not_applicable], nil, nil)
+                  abstractor_suggestion = @abstractor_abstraction.abstractor_subject.suggest(@abstractor_abstraction, abstractor_abstraction_source, suggestion_source[:match_value], suggestion_source[:sentence_match_value], suggestion[:source_id], suggestion[:source_type], suggestion[:source_method], nil, suggestion[:value], suggestion[:unknown].to_s.to_boolean, suggestion[:not_applicable].to_s.to_boolean, nil, nil)
                 end
               end
               format.json { render json: abstractor_suggestion, status: :created }

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

@@ -32,6 +32,10 @@ module Abstractor
             !system_generated
           end
 
+          def has_subtype?(s)
+            subtype == s
+          end
+
           private
             def update_abstractor_abstraction_group_members
               return unless deleted?

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

@@ -14,6 +14,13 @@ module Abstractor
           # base.send :attr_accessible, :deleted_at, :name
           # Validations
           base.send :validates, :cardinality, numericality: { only_integer: true, greater_than: 0 }, unless: Proc.new { |a| a.cardinality.blank? }
+          base.send(:include, InstanceMethods)
+        end
+
+        module InstanceMethods
+          def has_subtype?(s)
+            subtype == s
+          end
         end
       end
     end

data/lib/abstractor/parser.rb

@@ -7,7 +7,6 @@ module Abstractor
       options = { new_line_is_sentence_break: true }.merge(options)
       @abstractor_text = abstractor_text
 
-      puts options[:new_line_is_sentence_break]
       if options[:new_line_is_sentence_break]
         StanfordCoreNLP.custom_properties['ssplit.newlineIsSentenceBreak'] = 'always'
       else

data/lib/abstractor/serializers/abstractor_abstraction_schema_serializer.rb

@@ -7,22 +7,24 @@ module Abstractor
       end
 
       def as_json(options = {})
-        {
-          "predicate" => abstractor_abstraction_schema.predicate,
-          "display_name" => abstractor_abstraction_schema.display_name,
-          "abstractor_object_type" => abstractor_abstraction_schema.abstractor_object_type.value,
-          "preferred_name" => abstractor_abstraction_schema.preferred_name,
-          "predicate_variants" => abstractor_abstraction_schema.abstractor_abstraction_schema_predicate_variants.map { |abstractor_abstraction_schema_predicate_variant|  { 'value' => abstractor_abstraction_schema_predicate_variant.value  } },
-          "object_values" => abstractor_abstraction_schema.abstractor_object_values.map do |abstractor_object_value|
-            {
-              'value' => abstractor_object_value.value,
-              'properties' => abstractor_object_value.properties.nil? ? nil : JSON.parse(abstractor_object_value.properties),
-              'vocabulary_code' => abstractor_object_value.vocabulary_code,
-              'vocabulary' => abstractor_object_value.vocabulary,
-              'vocabulary_version' => abstractor_object_value.vocabulary_version,
-              'object_value_variants' => abstractor_object_value.abstractor_object_value_variants.map { |abstractor_object_value_variant| { 'value' => abstractor_object_value_variant.value } }
-            }
-          end
+        { "abstractor_abstraction_schema" =>
+          {
+            "predicate" => abstractor_abstraction_schema.predicate,
+            "display_name" => abstractor_abstraction_schema.display_name,
+            "abstractor_object_type" => abstractor_abstraction_schema.abstractor_object_type.value,
+            "preferred_name" => abstractor_abstraction_schema.preferred_name,
+            "predicate_variants" => abstractor_abstraction_schema.abstractor_abstraction_schema_predicate_variants.map { |abstractor_abstraction_schema_predicate_variant|  { 'value' => abstractor_abstraction_schema_predicate_variant.value  } },
+            "object_values" => abstractor_abstraction_schema.abstractor_object_values.map do |abstractor_object_value|
+              {
+                'value' => abstractor_object_value.value,
+                'properties' => abstractor_object_value.properties.nil? ? nil : JSON.parse(abstractor_object_value.properties),
+                'vocabulary_code' => abstractor_object_value.vocabulary_code,
+                'vocabulary' => abstractor_object_value.vocabulary,
+                'vocabulary_version' => abstractor_object_value.vocabulary_version,
+                'object_value_variants' => abstractor_object_value.abstractor_object_value_variants.map { |abstractor_object_value_variant| { 'value' => abstractor_object_value_variant.value } }
+              }
+            end
+          }
         }
       end
 

data/lib/abstractor/version.rb

@@ -1,3 +1,3 @@
 module Abstractor
-  VERSION = '4.3.3'
+  VERSION = '4.4.0'
 end

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

@@ -58,18 +58,18 @@ module Abstractor
       unless options["no-install-stanford-core-nlp"]
         puts "Running rake abstractor:setup:stanford_core_nlp"
         puts 'Please be patient...this could take a while.'
-        `rake abstractor:setup:stanford_core_nlp`
+        # `rake abstractor:setup:stanford_core_nlp`
 
         insert_into_file("#{Rails.root}/config/environments/development.rb", :after => /(::Application.configure do\n|application.configure do\n)/) do
 '  StanfordCoreNLP.use :english
   StanfordCoreNLP.model_files = {}
-  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.jar_path = "#{Rails.root}/lib/stanford-corenlp-full-2015-04-20/"
+  StanfordCoreNLP.model_path = "#{Rails.root}/lib/stanford-corenlp-full-2015-04-20/"
   StanfordCoreNLP.default_jars = [
     "joda-time.jar",
     "xom.jar",
-    "stanford-corenlp-3.4.jar",
-    "stanford-corenlp-3.4-models.jar",
+    "stanford-corenlp-3.5.2.jar",
+    "stanford-corenlp-3.5.2-models.jar",
     "jollyday.jar",
     "bridge.jar"
   ]

data/lib/tasks/abstractor_tasks.rake

@@ -14,20 +14,20 @@ namespace :abstractor do
       Abstractor::Setup.system
     end
 
-    desc "Setup Stanford CoreNLP library in lib/stanford-corenlp-full-2014-06-16/ directory"
+    desc "Setup Stanford CoreNLP library in lib/stanford-corenlp-full-2015-04-20/ directory"
     task :stanford_core_nlp => :environment do
       puts 'Please be patient...This could take a while.'
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16.zip"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2015-04-20.zip"
       open(file, 'wb') do |fo|
-        fo.print open('http://nlp.stanford.edu/software/stanford-corenlp-full-2014-06-16.zip').read
+        fo.print open('http://nlp.stanford.edu/software/stanford-corenlp-full-2015-04-20.zip').read
       end
 
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16.zip"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2015-04-20.zip"
       destination = "#{Rails.root}/lib/"
       puts 'Unzipping...'
       unzip_file(file, destination)
 
-      file = "#{Rails.root}/lib/stanford-corenlp-full-2014-06-16/bridge.jar"
+      file = "#{Rails.root}/lib/stanford-corenlp-full-2015-04-20/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: 4.3.3
+  version: 4.4.0
 platform: ruby
 authors:
 - Michael Gurley, Yulia Bushmanova
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-25 00:00:00.000000000 Z
+date: 2015-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -557,6 +557,9 @@ files:
 - db/migrate/20150223033848_add_custom_nlp_provider_to_abstractor_abstraction_sources.rb
 - db/migrate/20150317172523_add_properties_to_abstractor_object_values.rb
 - db/migrate/20150317204748_add_vocabulary_columns_to_abstractor_object_values.rb
+- db/migrate/20150422135935_add_display_order_to_abstractor_abstraction_schema_object_values.rb
+- db/migrate/20150423045055_add_subtype_to_abstractor_subject_groups.rb
+- db/migrate/20150505022228_add_subtype_to_abstractor_abstraction_groups.rb
 - db/seeds.rb
 - lib/abstractor.rb
 - lib/abstractor/abstractable.rb