abstractor 2.1.2 → 4.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGYyMTA2ODY2YWM5ZTgzNzNhM2Y4NmM3ZDBiMDhlZWRmYjcwZmVmYg==
+    MjcxMTgwOGI0Y2QwNDNjMjc4NDE2Y2I0YmIwYWQ2ZTg5YzU0NjI2Zg==
   data.tar.gz: !binary |-
-    YjhkNzBiNTMwMzAzNTQyYWZlNTJmMzgzYjc2ZTcyYjc3NWM0YzcyMQ==
+    ZTJmNWM0ZTcwMzZmMzk5YTRjYjBiMWU5Y2JkZWI1NTFkZjc5NGU1NA==
 SHA512:
   metadata.gz: !binary |-
-    OGQ3NWMwNmNmYzlkYzgyZjUxNDYyOTg4M2E0MmNjMmFkOTAwMjU1Yzg0YTAz
-    NDVmN2Q2MzVmY2VmYWI5MjkwMjZjZDcyN2VlOTYwNmFmZjVhZjFmNzJmZDZi
-    NDIzYTA3YTgwY2M4MWU2ZWVjMGU0NTY0NzE4MzUwM2MwZTEyNzg=
+    ZjE5NjUwNDVjNDcwMGVlZWEwNjM3MDQ2ODI5NzdiOTExNjZjZjY0Y2RmNzc5
+    NjcwMjljNDg4YmU2MDkwMmUxNjk2MTg0MWQ4NTM0OTlkZWUxMjc3YTI2Mzk1
+    YjE4NmIyODlkMjRhMDYwZGQ1NTgwMDg0NGYwMWM4OTExMmNlODg=
   data.tar.gz: !binary |-
-    ZTI0YmIyMDI2N2Q0ODk5ZDdmYzU3YTI0NDUzYTBlZjQ1OTA1OWY4Mjg1OWU1
-    MTVmNzQ0YjI2NjQxZmJmODc1MGE4OWU1ZjU1OTA0ZGM5MjJiNzNhNTQxMDBi
-    ZWJlZTZiZWJjYjlmYmE0YTRjN2U0NDNmYzQxMWMzOTNmMjYzYmU=
+    MTNmMjNjZDQ1OGNmM2U5MGFhODFlNWZjNDZkOWVlODE5OWZiYjMwNDAwYjU0
+    OTFjZTI5MjQ5OGZmYWZlNzczZDVhMThmMzEwN2QxMWYxZWJjMGI4YWY2ZTEx
+    OTJiMDdiMzM2YTVhZTdkMzNkNmNkMGRjYTM4ZTA5MWJmZWI4MmI=

data/README.md

@@ -5,10 +5,6 @@ from narrative text via natural language processing.  The gem includes
 a user interface to present the abstracted data points for
 confirmation/revision by a curator.
 
-Reader's note: this README uses [YARD][] markup to provide links to
-Abstractor's API documentation. If you aren't already, consider reading it
-on [rubydoc.info][] so that the links will be followable.
-
 [YARD]: http://yardoc.org/
 [rubydoc.info]: http://rubydoc.info/github/NUBIC/abstractor/master/file/README.md
 
@@ -20,7 +16,9 @@ on [rubydoc.info][] so that the links will be followable.
 Abstractor works with:
 
 * Ruby 1.9.3, 2.0.0 and 2.1.1
-* Rails 3.2 (not Rails 4.0 or later yet)
+* >= Rails 4.1
+* Rails 3.2 branch now available [here][]
+[here]: https://github.com/NUBIC/abstractor/tree/rails-3
 
 Some key dependencies are:
 
@@ -47,11 +45,16 @@ Add abstractor to your Gemfile:
 ```ruby
 gem 'abstractor'
 ```
+or if using Rails 3
+
+```ruby
+gem 'abstractor', :git => 'https://github.com/NUBIC/abstractor', branch: 'rails-3'
+```
 
 Add the stanford-core-nlp gem to your Gemfile.  Currently need to use the master branch of the official repository until a new version of the gem is released:
 
 ```ruby
-gem 'stanford-core-nlp', :git => 'https://github.com/louismullie/stanford-core-nlp', :branch => 'master',
+gem 'stanford-core-nlp', :git => 'https://github.com/louismullie/stanford-core-nlp', branch: 'master'
 ```
 
 Also add the paper\_trail gem to your Gemfile (if it is not already there):

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

@@ -0,0 +1,115 @@
+Abstractor = {}
+Abstractor.AbstractionUI = ->
+  $(document).on "click", ".abstractor_abstraction_value a.edit_link", (e) ->
+    e.preventDefault()
+    parent_div = $(this).closest(".abstractor_abstraction")
+    parent_div.load $(this).attr("href"), ->
+      parent_div.find(".combobox").combobox watermark: "a value"
+      $(".abstractor_datepicker").datepicker
+        altFormat: "yy-mm-dd"
+        dateFormat: "yy-mm-dd"
+        changeMonth: true
+        changeYear: true
+
+      return
+
+    parent_div.addClass "highlighted"
+    return
+
+  $(document).on "ajax:success", "form.edit_abstractor_abstraction", (e, data, status, xhr) ->
+    parent_div = $(this).closest(".abstractor_abstraction")
+    parent_div.html xhr.responseText
+
+    parent_div.removeClass "highlighted"
+    return
+
+  $(document).on "click", ".edit_abstractor_abstraction input[type='radio']", ->
+    $(this).siblings("input[type='checkbox']").prop "checked", false
+    return
+
+  $(document).on "click", ".edit_abstractor_abstraction input[type='checkbox']", ->
+    $(this).siblings("input[type='checkbox']").prop "checked", false
+    $(this).siblings("input[type='text']").prop "value", ""
+    autocompleters = $(this).siblings("select.combobox")
+    autocompleters.combobox "setValue", ""
+    autocompleters.change()
+    $.each $(this).siblings("input[type='radio']"), ->
+      if $(this).prop("value") is ""
+        $(this).prop "checked", true
+      else
+        $(this).prop "checked", false
+      return
+
+    return
+
+  $(document).on "change", ".edit_abstractor_abstraction select.combobox", ->
+    $(this).siblings("input[type='checkbox']").prop "checked", false  if $(this).find("option:selected").prop("value").length
+    return
+
+  $(document).on "change", ".edit_abstractor_abstraction input[type='text']", ->
+    $(this).siblings("input[type='checkbox']").prop "checked", false
+    return
+
+  $(document).on "click", ".abstractor_abstraction_source_tooltip_img", (evt) ->
+    target = $(this).attr("rel")
+    html = $(target).html()
+    title = $(this).attr("title")
+    evt.preventDefault()
+    $("#abstractor_abstraction_dialog_tooltip").dialog
+      maxHeight: 400
+      autoOpen: false
+      width: 600
+      zIndex: 40000
+      dialogClass: "ui-dialog_abstractor"
+    $("#abstractor_abstraction_dialog_tooltip").html html
+    $("#abstractor_abstraction_dialog_tooltip").dialog "option", "title", title
+    $("#abstractor_abstraction_dialog_tooltip").dialog "option", "width", ($(window).width() * 0.80)
+    $("#abstractor_abstraction_dialog_tooltip").dialog "open"
+    return
+
+  $(document).on "change", "select.indirect_source_list", ->
+    source_type = $(this).attr("rel")
+    value = $(this).find("option:selected").prop("value")
+    $(this).siblings(".indirect_source_text").addClass "hidden"
+    $(this).siblings("." + source_type + "_" + value).removeClass "hidden"
+    return
+
+  return
+
+Abstractor.AbstractionSuggestionUI = ->
+  $(document).on "change", ".abstractor_suggestion_status_selection", ->
+    $(this).closest("form").submit()
+    return
+
+  $(document).on "ajax:success", "form.edit_abstractor_suggestion", (e, data, status, xhr) ->
+    $(this).closest(".abstractor_abstraction").html xhr.responseText
+    return
+
+  return
+
+Abstractor.AbstractionGroupUI = ->
+  $(document).on "ajax:success", ".abstractor_abstraction_group .abstractor_group_delete_link", (e, data, status, xhr) ->
+    parent_div = $(this).closest(".abstractor_abstraction_group")
+    parent_div.html xhr.responseText
+    return
+
+  $(document).on "ajax:success", ".abstractor_subject_groups_container .abstractor_group_add_link", (e, data, status, xhr) ->
+    parent_div = $(this).closest(".abstractor_subject_groups_container")
+    parent_div.find(".abstractor_subject_groups").append xhr.responseText
+    return
+
+  $(document).on "ajax:success", ".abstractor_abstraction_group .abstractor_group_not_applicable_all_link", (e, data, status, xhr) ->
+    parent_div = $(this).closest(".abstractor_abstraction_group")
+    parent_div.html xhr.responseText
+    return
+
+  $(document).on "ajax:success", ".abstractor_abstraction_group .abstractor_group_unknown_all_link", (e, data, status, xhr) ->
+    parent_div = $(this).closest(".abstractor_abstraction_group")
+    parent_div.html xhr.responseText
+    return
+
+  return
+
+new Abstractor.AbstractionUI()
+new Abstractor.AbstractionSuggestionUI()
+new Abstractor.AbstractionGroupUI()

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

@@ -10,12 +10,4 @@
 // WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
 // GO AFTER THE REQUIRES BELOW.
 //
-//= require jquery
-//= require jquery_ujs
-//= require jquery.ui.widget
-//= require jquery.ui.autocomplete
-//= require jquery.ui.datepicker
-//= require jquery.ui.button
-//= require jquery.ui.dialog
-
 //= require_tree .

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

@@ -207,8 +207,27 @@
   margin-bottom: 0.5em;
 }
 
+.abstractor_abstractions fieldset .abstractor_abstraction_value .version {
+  margin-top: .5em;
+  margin-bottom: .5em;
+  border-bottom: 1px #969696 dashed;
+}
+
+.abstractor_abstractions fieldset .abstractor_abstraction_value .version .version_date {
+  margin-bottom: .5em;
+}
+
+.abstractor_abstractions fieldset .abstractor_abstraction_value .version .version_value {
+  margin-bottom: .5em;
+}
+
+.abstractor_abstractions fieldset .abstractor_abstraction_value .version .version_user {
+  margin-bottom: .5em;
+}
+
 .abstractor_abstractions fieldset .editable_abstraction {
   border-bottom: 1px #969696 dashed;
+  margin-right: .5em;
 }
 
 .abstractor_abstractions fieldset .abstractor_abstraction_source_tooltip_img img {
@@ -321,7 +340,8 @@ span.tooltip_img {
 }
 
 .indirect_source_list {
-  width: 35%;
+  width: 50%;
+  height: auto;
 }
 
 .indirect_source_text {

data/app/views/abstractor/abstractor_abstraction_groups/_form.html.haml

@@ -6,8 +6,8 @@
       = render :partial => 'abstractor/abstractor_abstractions/fields', :locals => {:abstractor_abstraction => abstractor_abstraction}
 
   .abstractor_abstraction_actions
-    = link_to 'Not applicable group ', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group, abstractor_abstraction_value: 'not applicable')), :confirm => 'Are you sure?', :method => :put, :class => "icon_link update_link", :remote => true
-    = link_to 'Unknown group ', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group, abstractor_abstraction_value: 'unknown')), :confirm => 'Are you sure?', :method => :put, :class => "icon_link update_link", :remote => true
+    = link_to 'Not applicable group ', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group, abstractor_abstraction_value: 'not applicable')), data: { confirm: 'Are you sure?'} , method: :put, class: "abstractor_group_not_applicable_all_link", remote: true
+    = link_to 'Unknown group ', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group, abstractor_abstraction_value: 'unknown')), data: { confirm: 'Are you sure?'}, method: :put, class: 'abstractor_group_unknown_all_link', remote: true
     - if abstractor_abstraction_group.removable?
-      = link_to 'Delete group', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group)), :confirm => 'Are you sure?', :method => :delete, :class => "icon_link delete_link", :remote => true
+      = link_to 'Delete group', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_group_path(abstractor_abstraction_group)), data: { confirm: 'Are you sure?'}, method: :delete, class: "abstractor_group_delete_link", remote: true
   %hr

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

@@ -22,9 +22,19 @@
           %br
           %b History:
           - versions.each do |version|
-            %br
-            %i
-              = "#{version.reify.display_value} - #{version.created_at.to_date.to_s(:date)} (#{version.originator})"
+            .version
+              .version_date
+                %i
+                  Date:
+                = "#{version.created_at.to_date.to_s(:date)}"
+              .version_value
+                %i
+                  Value:
+                = "#{version.reify.display_value}"
+              .version_user
+                %i
+                  User:
+                = "#{version.originator}"
     - if abstractor_suggestions.any?
       .column-9
         - abstractor_suggestions.each do |abstractor_suggestion|
@@ -38,7 +48,7 @@
                     - source_about = abstractor_suggestion_source.source_type.constantize.find(abstractor_suggestion_source.source_id)
                     - from_method = abstractor_suggestion_source.source_method
                     - if from_method && source_about.respond_to?(from_method)
-                      %span{ :class => 'abstractor_abstraction_source_tooltip_img label', :rel => "#abstraction_text_#{abstractor_suggestion_source.id}", :title => "#{source_about.class.to_s} #{from_method}"}
+                      %span{ :class => 'abstractor_abstraction_source_tooltip_img', :rel => "#abstraction_text_#{abstractor_suggestion_source.id}", :title => "#{source_about.class.to_s} #{from_method}"}
                         = image_tag('abstractor/page.png', :id => "abstraction_text_link_#{abstractor_suggestion_source.id}")
                       %div{ :id => "abstraction_text_#{abstractor_suggestion_source.id}", :class => 'abstractor_abstraction_source_tooltip'}
                         - abstractable_from_column = source_about.send(from_method)
@@ -67,7 +77,7 @@
         - abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.select { |s| s.abstractor_abstraction_source_type.name == 'nlp suggestion' }.each do |abstractor_abstraction_source|
           - abstractor_abstraction_source.normalize_from_method_to_sources(abstractor_abstraction.about).each do |source|
             - dom_id = "#{abstractor_abstraction_source.id}_#{source[:source_type]}_#{source[:source_id]}_#{source[:source_method]}"
-            %span{ :class => 'abstractor_abstraction_source_tooltip_img label', :rel =>"#abstraction_text_#{dom_id}", :title => "#{source[:source_type].to_s} #{source[:source_method]}"}
+            %span{ :class => 'abstractor_abstraction_source_tooltip_img', :rel =>"#abstraction_text_#{dom_id}", :title => "#{source[:source_type].to_s} #{source[:source_method]}"}
               = image_tag('abstractor/page.png', :id => "abstraction_text_link_#{dom_id}")
               %br
             %div{ :id => "abstraction_text_#{dom_id}", :class => 'tooltip'}

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

@@ -1,8 +1,10 @@
 - about ||= @about
+- namespace_type ||= @namespace_type
+- namespace_id ||= @namespace_id
 .abstractor_abstractions
-  = link_to 'Not applicable all', Abstractor::UserInterface.abstractor_relative_path(abstractor.update_all_abstractor_abstractions_path(about_type: about.class, about_id: about.id, abstractor_abstraction_value: 'not applicable')), :confirm => 'Are you sure?', :method => :put, :class => "icon_link update_link"
-  = link_to 'Unknown all', Abstractor::UserInterface.abstractor_relative_path(abstractor.update_all_abstractor_abstractions_path(about_type: about.class, about_id: about.id, abstractor_abstraction_value: 'unknown')), :confirm => 'Are you sure?', :method => :put, :class => "icon_link update_link"
-  - abstractor_subject_groups = Abstractor::AbstractorSubjectGroup.joins(:abstractor_subjects).where(:abstractor_subjects => {:subject_type => about.class}).order('abstractor_subject_groups.id').not_deleted.to_a.uniq
+  = link_to 'Not applicable all', Abstractor::UserInterface.abstractor_relative_path(abstractor.update_all_abstractor_abstractions_path(about_type: about.class, about_id: about.id, abstractor_abstraction_value: 'not applicable')), data: { confirm: 'Are you sure?'}, method: :put, class: 'abstractor_not_applicable_all_link'
+  = link_to 'Unknown all', Abstractor::UserInterface.abstractor_relative_path(abstractor.update_all_abstractor_abstractions_path(about_type: about.class, about_id: about.id, abstractor_abstraction_value: 'unknown')), data: { confirm: 'Are you sure?'}, method: :put,  class: 'abstractor_unknown_all_link'
+  - abstractor_subject_groups = about.class.abstractor_subject_groups(namespace_type: namespace_type, namespace_id: namespace_id)
   - abstractor_subject_groups.each do |abstractor_subject_group|
     .abstractor_subject_groups_container
       %b= abstractor_subject_group.name
@@ -17,13 +19,12 @@
           %b Status
         %hr
         .abstractor_subject_groups
-          - abstractor_abstraction_groups = abstractor_subject_group.abstractor_abstraction_groups.not_deleted.joins(:abstractor_abstractions).where(:abstractor_abstractions => {:about_id => about.id}).order('abstractor_abstraction_groups.id').to_a.uniq
+          - abstractor_abstraction_groups = about.abstractor_abstraction_groups_by_namespace(namespace_type: namespace_type, namespace_id: namespace_id)
           - abstractor_abstraction_groups.each_with_index do |abstractor_abstraction_group, index|
             = render partial: 'abstractor/abstractor_abstraction_groups/form', locals: {abstractor_abstraction_group: abstractor_abstraction_group}
-        = link_to 'Add group', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_groups_path(about_id: about.id, about_type: about.class.name, abstractor_subject_group_id: abstractor_subject_group.id)), method: :post, class: "icon_link add_link", remote: true
-
+        = link_to 'Add group', Abstractor::UserInterface.abstractor_relative_path(abstractor.abstractor_abstraction_groups_path(about_id: about.id, about_type: about.class.name, abstractor_subject_group_id: abstractor_subject_group.id)),  data: { confirm: 'Are you sure?'}, method: :post, class: 'abstractor_group_add_link', remote: true
   .clear
-  - ungrouped_subjects = Abstractor::AbstractorSubject.not_deleted.includes(:abstractor_subject_group_member).where(:subject_type => about.class.to_s, :abstractor_subject_group_members => {:id => nil})
+  - ungrouped_subjects = about.class.abstractor_subjects(grouped: false, namespace_type: namespace_type, namespace_id: namespace_id)
   - if ungrouped_subjects.any?
     %fieldset
       .column-3
@@ -39,9 +40,4 @@
         - ungrouped_subject.abstractor_abstractions.not_deleted.where(:about_id => about.id).each do |abstractor_abstraction|
           %div{ class: "abstractor_abstraction #{Abstractor::Utility.dehumanize(abstractor_abstraction.abstractor_subject.abstractor_abstraction_schema.predicate)}" }
             = render :partial => 'abstractor/abstractor_abstractions/fields', :locals => {:abstractor_abstraction => abstractor_abstraction}
-:javascript
-  $(function () {
-    new Abstractor.AbstractionUI();
-    new Abstractor.AbstractionSuggestionUI();
-    new Abstractor.AbstractionGroupUI();
-  });
+#abstractor_abstraction_dialog_tooltip

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

@@ -48,14 +48,14 @@
         - abstraction_source.normalize_from_method_to_sources(abstractor_abstraction.about).each do |source|
           - if source[:source_type] && source[:source_id] && source[:source_method]
             - dom_id = "#{abstraction_source.id}_#{source[:source_type]}_#{source[:source_id]}_#{source[:source_method]}"
-            %span{ :class => 'abstractor_abstraction_source_tooltip_img label', :rel =>"#abstraction_text_#{dom_id}", :title => "#{source[:source_type].to_s} #{source[:source_method]}"}
+            %span{ :class => 'abstractor_abstraction_source_tooltip_img', :rel =>"#abstraction_text_#{dom_id}", :title => "#{source[:source_type].to_s} #{source[:source_method]}"}
               = image_tag('abstractor/page.png', :id => "abstraction_text_link_#{dom_id}")
               %br
             %div{ :id => "abstraction_text_#{dom_id}", :class => 'tooltip'}
               = simple_format(source[:source_type].find(source[:source_id]).send(source[:source_method]))
     .column-4
-      = f.submit 'Save', :class => 'button positive'
-      = link_to 'Cancel', abstractor_abstraction, :class => 'button negative', :remote => true
+      = f.submit 'Save'
+      = link_to 'Cancel', abstractor_abstraction, :remote => true
     .clear
     .indirect_sources
       - abstraction_sources = abstractor_abstraction.abstractor_subject.abstractor_abstraction_sources.select { |s| s.abstractor_abstraction_source_type.name == 'indirect' }

data/db/migrate/20140816005228_add_namespace_to_abstractor_subjects.rb

@@ -0,0 +1,6 @@
+class AddNamespaceToAbstractorSubjects < ActiveRecord::Migration
+  def change
+    add_column :abstractor_subjects, :namespace_type, :string
+    add_column :abstractor_subjects, :namespace_id, :integer
+  end
+end

data/lib/abstractor/abstractable.rb

@@ -15,8 +15,57 @@ module Abstractor
     end
 
     module InstanceMethods
-      def abstract
-        self.class.abstractor_subjects.each do |abstractor_subject|
+      ##
+      # Returns all abstractions for the abstractable entity by a namespace.
+      #
+      # @param [Hash] options the options to filter the list of abstractions to a namespace.
+      # @option options [String] :namespace_type The type parameter of the namespace.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace.
+      # @return [ActiveRecord::Relation] List of [Abstractor::AbstractorAbstraction].
+      def abstractor_abstractions_by_namespace(options = {})
+        options = { namespace_type: nil, namespace_id: nil }.merge(options)
+        if options[:namespace_type] || options[:namespace_id]
+          abstractor_abstractions.not_deleted.where(abstractor_subject_id: self.class.abstractor_subjects(options).map(&:id))
+        else
+          abstractor_abstractions.not_deleted
+        end
+      end
+      ##
+      # Returns all abstraction groups for the abstractable entity by a namespace.
+      #
+      # @param [Hash] options the options to filter the list of abstraction groups to a namespace.
+      # @option options [String] :namespace_type The type parameter of the namespace.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace.
+      # @return [ActiveRecord::Relation] List of [Abstractor::AbstractorAbstractionGroup].
+      def abstractor_abstraction_groups_by_namespace(options = {})
+        options = { namespace_type: nil, namespace_id: nil }.merge(options)
+        if options[:namespace_type] || options[:namespace_id]
+          abstractor_abstractions_by_namespace(options).map(&:abstractor_abstraction_group).compact.uniq
+        else
+          abstractor_abstraction_groups.not_deleted
+        end
+      end
+
+      ##
+      # The method for generating abstractions from the abstractable entity.
+      #
+      # The generation of abstactions is based on the setup of Abstactor::AbstractorAbstactionSchema,
+      # Abstractor::AbstractorSubject, Abstractor::AbstractorSubjectGroup and Abstractor::AbstractorAbstractionSource associated to the abstractable entity.
+      #
+      # Namespacing allows for different sets data points to be associated to the same abstractable entity.
+      #
+      # Namespacing is achieved by setting the Abstractor::AbstractorSubject#namespace_type and Abstractor::AbstractorSubject#namespace_id attributes.
+      #
+      # Passing a namespace to this method will restrict the generation of abstractions to the given namespace. Otherwise, all configured abstractions associated to the abstractable entity will be generated.
+      #
+      # A practical example of the use of a namespace would be two different clincal departments wanting to chart abstract two distinct sets of datapoints for progress notes extracted from an electronic medical record system.
+      # @param [Hash] options the options to filter the generation of abstractions to a namespace.
+      # @option options [String] :namespace_type The type parameter of the namespace.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace.
+      # @return [void]
+      def abstract(options = {})
+        options = { namespace_type: nil, namespace_id: nil }.merge(options)
+        self.class.abstractor_subjects(options).each do |abstractor_subject|
           abstractor_subject.abstract(self)
         end
       end
@@ -56,24 +105,32 @@ module Abstractor
       # * 'reviewed': Filter abstractions having a determined value (value, unknown or not_applicable).
       #
       # @param [String] abstractor_abstraction_status Filter abstractions that need review or are reviews.
-      # @return [ActiveRecord::Relation] List of [Abstractor::AbstractorAbstraction].
-      def abstractor_abstractions_by_abstractor_abstraction_status(abstractor_abstraction_status)
+      # @param [Hash] options the options to filter abstractions to a namespace.
+      # @option options [String] :namespace_type the type parameter of the namespace.
+      # @option options [Integer] :namespace_id the instance parameter of the namespace.
+      # @return [ActiveRecord::Relation] list of [Abstractor::AbstractorAbstraction].
+      def abstractor_abstractions_by_abstractor_abstraction_status(abstractor_abstraction_status, options = {})
+        options = { namespace_type: nil, namespace_id: nil }.merge(options)
         case abstractor_abstraction_status
-        when 'needs_review'
-          abstractor_abstractions.not_deleted.select { |abstractor_abstraction| abstractor_abstraction.value.blank? && abstractor_abstraction.unknown.blank? && abstractor_abstraction.not_applicable.blank? }
-        when 'reviewed'
-          abstractor_abstractions.not_deleted.select { |abstractor_abstraction| !abstractor_abstraction.value.blank? || !abstractor_abstraction.unknown.blank? || !abstractor_abstraction.not_applicable.blank? }
+        when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
+          abstractor_abstractions_by_namespace(options).select { |abstractor_abstraction| abstractor_abstraction.value.blank? && abstractor_abstraction.unknown.blank? && abstractor_abstraction.not_applicable.blank? }
+        when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
+          abstractor_abstractions_by_namespace(options).select { |abstractor_abstraction| !abstractor_abstraction.value.blank? || !abstractor_abstraction.unknown.blank? || !abstractor_abstraction.not_applicable.blank? }
         end
       end
 
       ##
-      # Removes all abstractions, suggestions and indirect sources for the abstractable entity.  Optionally filtred to only 'unreviewd' abstractions.
+      # Removes all abstractions, suggestions and indirect sources for the abstractable entity.  Optionally filtred to only 'unreviewed' abstractions and to a given namespace.
       #
-      # @param [Boolean] only_unreviewed Instructs whther to confine removal to only 'unreviewd' abstractions.
+      # @param [Hash] options the options to filter the removal of abstractions.
+      # @option options [Booelan] :only_unreviewed Instructs whether to confine removal to only 'unreviewed' abstractions.
+      # @option options [String] :namespace_type The type parameter of the namespace to remove.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to remove.
       # @return [void]
-      def remove_abstractions(only_unreviewed = true)
-        abstractor_abstractions.each do |abstractor_abstraction|
-          if !only_unreviewed || (only_unreviewed && abstractor_abstraction.unreviewed?)
+      def remove_abstractions(options = {})
+        options = { only_unreviewed: true, namespace_type: nil, namespace_id: nil }.merge(options)
+        abstractor_abstractions_by_namespace(options).each do |abstractor_abstraction|
+          if !options[:only_unreviewed] || (options[:only_unreviewed] && abstractor_abstraction.unreviewed?)
             abstractor_abstraction.abstractor_suggestions.each do |abstractor_suggestion|
               abstractor_suggestion.abstractor_suggestion_sources.destroy_all
               abstractor_suggestion.abstractor_suggestion_object_value.destroy if abstractor_suggestion.abstractor_suggestion_object_value
@@ -96,15 +153,31 @@ module Abstractor
       # * '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'.
+      # @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.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to filter the entities.
       # @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_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 '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])
+      def by_abstractor_abstraction_status(abstractor_abstraction_status, options = {})
+        options = { namespace_type: nil, namespace_id: nil }.merge(options)
+
+        if options[:namespace_type] || options[:namespace_id]
+          case abstractor_abstraction_status
+          when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
+            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])
+          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
         else
-          where(nil)
+          case abstractor_abstraction_status
+          when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
+            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])
+          else
+            where(nil)
+          end
         end
       end
 
@@ -113,21 +186,25 @@ module Abstractor
       #
       # By default, the method will return all abstractor subjects.
       #
-      # @param [Hash] options the options to filter the objects returned
+      # @param [Hash] options the options to filter the subjects returned.
       # @option options [Boolean] :grouped Filters the list of Abstactor::AbstractorSubject objects to grouped and non-grouped.  Defaults to nil which returns all objects.
+      # @option options [String] :namespace_type The type parameter of the namespace to filter the subjects.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to filter the subjects.
       # @return ActiveRecord::Relation list of Abstactor::AbstractorSubject objects
       def abstractor_subjects(options = {})
-        options = { grouped: nil }.merge(options)
+        options = { grouped: nil, namespace_type: nil, namespace_id: nil }.merge(options)
         subjects = Abstractor::AbstractorSubject.where(subject_type: self.to_s)
+        if options[:namespace_type] || options[:namespace_id]
+          subjects = subjects.select { |subject| subject.namespace_type == options[:namespace_type] && subject.namespace_id == options[:namespace_id] }
+        end
         subjects = case options[:grouped]
         when true
-          subjects.select{ |s| s.abstractor_subject_group_member}
+          subjects.select{ |s| s.abstractor_subject_group_member }
         when false
-          subjects.reject{ |s| s.abstractor_subject_group_member}
+          subjects.reject{ |s| s.abstractor_subject_group_member }
         when nil
           subjects
         end
-        subjects
       end
 
       ##
@@ -135,16 +212,19 @@ module Abstractor
       #
       # By default, the method will return all abstractor abstraction schemas.
       #
-      # @param [Hash] options the options to filter the objects returned
-      # @option options [Boolean] :grouped Filters the list of Abstractor::AbstractorAbstractionSchema objects to grouped and non-grouped.  Defaults to nil which returns all objects.
+      # @param [Hash] options the options to filter the abstaction schemas.
+      # @option options [Boolean] :grouped Filters the list of Abstractor::AbstractorAbstractionSchema objects to grouped and non-grouped.  Defaults to nil which returns all abstraction schemas.
+      # @option options [String] :namespace_type The type parameter of the namespace to filter the abstaction schemas.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to filter the abstaction schemas.
       # @return ActiveRecord::Relation list of Abstactor::AbstractorAbstractionSchema objects
-      def abstractor_abstraction_schemas(options= {})
-        options = { grouped: nil }.merge(options)
+      def abstractor_abstraction_schemas(options = {})
+        options = { grouped: nil, namespace_type: nil, namespace_id: nil }.merge(options)
         abstractor_subjects(options).map(&:abstractor_abstraction_schema)
       end
 
-      def abstractor_subject_groups
-        abstractor_subjects.map(&:abstractor_subject_group).compact.uniq
+      def abstractor_subject_groups(options = {})
+        options = { grouped: true, namespace_type: nil, namespace_id: nil }.merge(options)
+        abstractor_subjects(options).map(&:abstractor_subject_group).compact.uniq
       end
 
       ##
@@ -159,17 +239,21 @@ module Abstractor
       # it was strucutred like so:
       # 'select id, collection_date, report_text, has_cancer_diagnosis from pathology_cases'
       #
+      # @param [Hash] options the options to pivot the abstractions.
+      # @option options [String] :namespace_type The type parameter of the namespace to pivot abstractions.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to pivot abstractions.
       # @return ActiveRecord::Relation
-      def pivot_abstractions
-        select = prepare_pivot_select(grouped: false)
+      def pivot_abstractions(options = {})
+        options = { grouped: false, namespace_type: nil, namespace_id: nil }.merge(options)
+        select = prepare_pivot_select(options)
         adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
         j = case adapter
         when 'sqlite3'
-          prepare_pivot_joins(select, "'t'")
+          prepare_pivot_joins(select, "'t'", options)
         when 'sqlserver'
-          prepare_pivot_joins(select, '1')
+          prepare_pivot_joins(select, '1', options)
         when 'postgresql'
-          prepare_pivot_joins(select, 'true')
+          prepare_pivot_joins(select, 'true', options)
         end
         joins(j).select("#{self.table_name}.*, pivoted_abstractions.*")
       end
@@ -191,18 +275,22 @@ module Abstractor
       # If an abstractable entity has multiple instances of grouped abstractions the entity will be returned mutlple times.
       #
       # @param [String] abstractor_subject_groups_name name of {Abstractor::Methods::Models:AbtractorSubjectGroup}
+      # @param [Hash] options the options to pivot the grouped abstractions.
+      # @option options [String] :namespace_type The type parameter of the namespace to pivot grouped abstractions.
+      # @option options [Integer] :namespace_id The instance parameter of the namespace to pivot grouped abstractions.
       # @return ActiveRecord::Relation
       # @see Abstractor::Methods::Models:AbstractorSubjectGroup
-      def pivot_grouped_abstractions(abstractor_subject_groups_name)
-        select = prepare_pivot_select(grouped: true)
+      def pivot_grouped_abstractions(abstractor_subject_groups_name, options = {})
+        options = { grouped: true, namespace_type: nil, namespace_id: nil }.merge(options)
+        select = prepare_pivot_select(options)
         adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
         j = case adapter
         when 'sqlite3'
-          prepare_grouped_pivot_joins(select, "'t'", abstractor_subject_groups_name)
+          prepare_grouped_pivot_joins(select, "'t'", abstractor_subject_groups_name, options)
         when 'sqlserver'
-          prepare_grouped_pivot_joins(select, '1', abstractor_subject_groups_name)
+          prepare_grouped_pivot_joins(select, '1', abstractor_subject_groups_name, options)
         when 'postgresql'
-          prepare_grouped_pivot_joins(select, 'true', abstractor_subject_groups_name)
+          prepare_grouped_pivot_joins(select, 'true', abstractor_subject_groups_name, options)
         end
         joins(j).select("#{self.table_name}.*, pivoted_abstractions.*")
       end
@@ -219,55 +307,108 @@ module Abstractor
           select = select.join(',')
         end
 
-        def prepare_pivot_joins(select, bool)
-          "LEFT JOIN
-          (
-          SELECT #{self.table_name}.id AS subject_id,
-          #{select}
-          FROM
-          (SELECT   aas.predicate
-                  , aas.id AS abstractor_abstraction_schema_id
-                  , asb.subject_type
-                  , aa.about_id
-                  , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
-          FROM abstractor_abstractions aa JOIN abstractor_subjects asb            ON aa.abstractor_subject_id = asb.id
-                                          JOIN abstractor_abstraction_schemas aas ON asb.abstractor_abstraction_schema_id = aas.id
-          WHERE asb.subject_type = '#{self.to_s}'
-          AND NOT EXISTS (
-            SELECT 1
-            FROM abstractor_abstraction_group_members aagm
-            WHERE aa.id = aagm.abstractor_abstraction_id
-          )
-          ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
-          GROUP BY #{self.table_name}.id
-          ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
-          "
+        def prepare_pivot_joins(select, bool, options = {})
+          if options[:namespace_type] || options[:namespace_id]
+            "LEFT JOIN
+            (
+            SELECT #{self.table_name}.id AS subject_id,
+            #{select}
+            FROM
+            (SELECT   aas.predicate
+                    , aas.id AS abstractor_abstraction_schema_id
+                    , asb.subject_type
+                    , aa.about_id
+                    , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
+            FROM abstractor_abstractions aa JOIN abstractor_subjects asb            ON aa.abstractor_subject_id = asb.id
+                                            JOIN abstractor_abstraction_schemas aas ON asb.abstractor_abstraction_schema_id = aas.id
+            WHERE asb.subject_type = '#{self.to_s}'
+            AND asb.namespace_type = '#{options[:namespace_type]}'
+            AND asb.namespace_id = #{options[:namespace_id]}
+            AND NOT EXISTS (
+              SELECT 1
+              FROM abstractor_abstraction_group_members aagm
+              WHERE aa.id = aagm.abstractor_abstraction_id
+            )
+            ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
+            GROUP BY #{self.table_name}.id
+            ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
+            "
+          else
+            "LEFT JOIN
+            (
+            SELECT #{self.table_name}.id AS subject_id,
+            #{select}
+            FROM
+            (SELECT   aas.predicate
+                    , aas.id AS abstractor_abstraction_schema_id
+                    , asb.subject_type
+                    , aa.about_id
+                    , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
+            FROM abstractor_abstractions aa JOIN abstractor_subjects asb            ON aa.abstractor_subject_id = asb.id
+                                            JOIN abstractor_abstraction_schemas aas ON asb.abstractor_abstraction_schema_id = aas.id
+            WHERE asb.subject_type = '#{self.to_s}'
+            AND NOT EXISTS (
+              SELECT 1
+              FROM abstractor_abstraction_group_members aagm
+              WHERE aa.id = aagm.abstractor_abstraction_id
+            )
+            ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
+            GROUP BY #{self.table_name}.id
+            ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
+            "
+          end
         end
 
-        def prepare_grouped_pivot_joins(select, bool, abstractor_subject_groups_name)
-          abstractor_subject_group = abstractor_subject_groups.detect { |abstractor_subject_group| abstractor_subject_group.name ==  abstractor_subject_groups_name }
+        def prepare_grouped_pivot_joins(select, bool, abstractor_subject_groups_name, options = {})
+          abstractor_subject_group = abstractor_subject_groups(options).detect { |abstractor_subject_group| abstractor_subject_group.name ==  abstractor_subject_groups_name }
 
-          "JOIN
-           (
-           SELECT #{self.table_name}.id AS subject_id,
-           #{select}
-           FROM
-           (SELECT   aas.predicate
-                   , aas.id AS abstraction_schema_id
-                   , asb.subject_type
-                   , aa.about_id
-                   , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
-                   , aag.id AS abstractor_abstraction_group_id
-           FROM abstractor_abstractions aa JOIN abstractor_subjects asb                    ON aa.abstractor_subject_id = asb.id
-                                           JOIN abstractor_abstraction_schemas aas         ON asb.abstractor_abstraction_schema_id = aas.id
-                                           JOIN abstractor_abstraction_group_members aagm  ON aa.id = aagm.abstractor_abstraction_id
-                                           JOIN abstractor_abstraction_groups aag          ON aagm.abstractor_abstraction_group_id= aag.id
-           WHERE asb.subject_type = '#{self.to_s}'
-           AND aag.abstractor_subject_group_id = #{abstractor_subject_group.id}
-           ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
-           GROUP BY #{self.table_name}.id, abstractor_abstraction_group_id
-           ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
-           "
+          if options[:namespace_type] || options[:namespace_id]
+            "JOIN
+             (
+             SELECT #{self.table_name}.id AS subject_id,
+             #{select}
+             FROM
+             (SELECT   aas.predicate
+                     , aas.id AS abstraction_schema_id
+                     , asb.subject_type
+                     , aa.about_id
+                     , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
+                     , aag.id AS abstractor_abstraction_group_id
+             FROM abstractor_abstractions aa JOIN abstractor_subjects asb                    ON aa.abstractor_subject_id = asb.id
+                                             JOIN abstractor_abstraction_schemas aas         ON asb.abstractor_abstraction_schema_id = aas.id
+                                             JOIN abstractor_abstraction_group_members aagm  ON aa.id = aagm.abstractor_abstraction_id
+                                             JOIN abstractor_abstraction_groups aag          ON aagm.abstractor_abstraction_group_id= aag.id
+             WHERE asb.subject_type = '#{self.to_s}'
+             AND asb.namespace_type = '#{options[:namespace_type]}'
+             AND asb.namespace_id = #{options[:namespace_id]}
+             AND aag.abstractor_subject_group_id = #{abstractor_subject_group.id}
+             ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
+             GROUP BY #{self.table_name}.id, abstractor_abstraction_group_id
+             ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
+             "
+           else
+             "JOIN
+              (
+              SELECT #{self.table_name}.id AS subject_id,
+              #{select}
+              FROM
+              (SELECT   aas.predicate
+                      , aas.id AS abstraction_schema_id
+                      , asb.subject_type
+                      , aa.about_id
+                      , CASE WHEN aa.value IS NOT NULL AND aa.value != '' THEN aa.value WHEN aa.unknown = #{bool} THEN 'unknown' WHEN aa.not_applicable = #{bool} THEN 'not applicable' END AS value
+                      , aag.id AS abstractor_abstraction_group_id
+              FROM abstractor_abstractions aa JOIN abstractor_subjects asb                    ON aa.abstractor_subject_id = asb.id
+                                              JOIN abstractor_abstraction_schemas aas         ON asb.abstractor_abstraction_schema_id = aas.id
+                                              JOIN abstractor_abstraction_group_members aagm  ON aa.id = aagm.abstractor_abstraction_id
+                                              JOIN abstractor_abstraction_groups aag          ON aagm.abstractor_abstraction_group_id= aag.id
+              WHERE asb.subject_type = '#{self.to_s}'
+              AND aag.abstractor_subject_group_id = #{abstractor_subject_group.id}
+              ) data join #{self.table_name} ON  data.about_id = #{self.table_name}.id
+              GROUP BY #{self.table_name}.id, abstractor_abstraction_group_id
+              ) pivoted_abstractions ON pivoted_abstractions.subject_id = #{self.table_name}.id
+              "
+           end
         end
     end
   end