abstractor 1.0.8

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

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

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

@@ -0,0 +1,17 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSuggestionSource
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_abstraction_source
+          base.send :belongs_to, :abstractor_suggestion
+
+          base.send :attr_accessible, :abstractor_abstraction_source, :abstractor_abstraction_source_id, :abstractor_suggestion, :abstractor_suggestion_id, :source_id, :source_type, :source_method, :match_value, :deleted_at, :sentence_match_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorSuggestionStatus
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :has_many, :abstractor_suggestions
+
+          base.send :attr_accessible, :deleted_at, :name
+        end
+
+        # Instance Methods
+        def needs_review?
+          name == 'Needs review'
+        end
+
+        def accepted?
+          name == 'Accepted'
+        end
+
+        def rejected?
+          name == 'Rejected'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Abstractor
+  module Methods
+    module Models
+      module SoftDelete
+        def self.included(base)
+          attr_accessor :soft_delete
+          base.send(:scope, :not_deleted, -> { base.where(:deleted_at => nil) })
+        end
+
+        def process_soft_delete
+          self.deleted_at = Time.zone.now
+        end
+
+        def soft_delete=(removed)
+          if (removed.is_a?(TrueClass) || removed.to_s == 't' || removed.to_s == '1')
+            process_soft_delete
+          end
+        end
+
+        def soft_delete
+          !self.deleted_at.blank?
+        end
+
+        def soft_delete!
+          process_soft_delete
+          save!
+        end
+
+        def deleted?
+          !deleted_at.blank?
+        end
+      end
+    end
+  end
+end

data/lib/abstractor/negation_detection.rb

@@ -0,0 +1,43 @@
+module Abstractor
+  module NegationDetection
+    def self.clear_invalid_utf8_bytes(scoped_sentence)
+      scoped_sentence = scoped_sentence.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+    end
+
+    def self.parse_negation_scope(sentence)
+      parse_results = { :sentence => nil, :scoped_sentence => nil }
+      if sentence
+        parse_results[:sentence] = sentence
+        parse_results[:scoped_sentence] = clear_invalid_utf8_bytes(NegationDetection.parse(sentence))
+      end
+      parse_results
+    end
+
+    def self.negated_match_value?(scoped_sentence, match_value)
+      negated = !scoped_sentence.scan('|B-S').empty? && match_value.split(' ').all? do |match_value_token|
+        !(scoped_sentence.scan(Regexp.new(match_value_token + '\|I-S')).empty?)
+      end
+    end
+
+    def self.manual_negated_match_value?(sentence, match_value)
+      negated = false
+      ['non-','\bthere is no evidence of a ', '\bthere is no evidence of a metastatic ',  '\binsufficient to make the diagnosis of ', '\binsufficient to make the diagnosis of metastatic ',  '\binsufficient for the diagnosis of ',  '\binsufficient for the diagnosis of metastatic ',  '\brule out ', '\brule out metastatic ', '\bnegative for ', '\bnegative for metastatic ',  '\bno ', '\bno metastatic ', '\bnot ', '\bnot metastatic ',  '\bno evidence of ', '\bno evidence of metastatic ',  '\bno evidence of a ', '\bno evidence of a metastatic ',  '\brules out the possibility of a ', '\brules out the possibility of a metastatic ',  '\bto exclude the possibility of ', '\bto exclude the possibility of metastic '].each do |negation_cue|
+        if !(sentence.downcase.scan(Regexp.new(negation_cue + match_value.downcase)).empty?)
+          negated = true
+        end
+      end
+
+      [' is not seen\b', ' less likely\b'].each do |negation_cue|
+        if !(sentence.downcase.scan(Regexp.new(match_value.downcase + negation_cue)).empty?)
+          negated = true
+        end
+      end
+
+      negated
+    end
+
+    def self.parse(sentence)
+      `java lingscope.drivers.SentenceTagger scope crf #{File.expand_path('../../', __FILE__)}/lingscope/negation_models/crf_scope_words_all_both.model "#{sentence}"`
+    end
+  end
+end

data/lib/abstractor/parser.rb

@@ -0,0 +1,76 @@
+require 'stanford-core-nlp'
+module Abstractor
+  class Parser
+    attr_accessor :sentences, :abstractor_text
+
+    def initialize(abstractor_text)
+      @abstractor_text = abstractor_text
+
+      pipeline =  StanfordCoreNLP.load(:tokenize, :ssplit)
+      t = StanfordCoreNLP::Annotation.new(@abstractor_text)
+      pipeline.annotate(t)
+      if @abstractor_text
+        @sentences = t.get(:sentences).to_a.map do |s|
+          {
+            :range => s.get(:character_offset_begin).to_s.to_i..s.get(:character_offset_end).to_s.to_i,
+            :begin_position  => s.get(:character_offset_begin).to_s.to_i,
+            :end_position => s.get(:character_offset_end).to_s.to_i,
+            :sentence => @abstractor_text[s.get(:character_offset_begin).to_s.to_i..s.get(:character_offset_end).to_s.to_i].downcase
+          }
+        end
+      end
+    end
+
+    def scan(token, options = {})
+      options[:word_boundary] = true if options[:word_boundary].nil?
+      regular_expression = prepare_token(token, options)
+      at = prepare_abstractor_text
+      if (regular_expression.nil? || at.nil?)
+        []
+      else
+        at.scan(regular_expression)
+      end
+    end
+
+    def match(token)
+      regular_expression = prepare_token(token)
+      prepare_abstractor_text.match(regular_expression) unless regular_expression.nil?
+    end
+
+    def range_all(token)
+      regular_expression = prepare_token(token)
+      prepare_abstractor_text.range_all(regular_expression) unless regular_expression.nil?
+    end
+
+    def match_position(match)
+      match.pre_match.size
+    end
+
+    def match_sentence(sentence, token)
+      regular_expression = prepare_token(token)
+      sentence.match(prepare_token(token)) unless regular_expression.nil?
+    end
+
+    def find_sentence(range)
+      @sentences.detect { |sentence| sentence[:range].include?(range) }
+    end
+
+    private
+      def prepare_abstractor_text
+        @abstractor_text.downcase unless @abstractor_text.nil?
+      end
+
+      def prepare_token(token, options = {})
+        options[:word_boundary] = true if options[:word_boundary].nil?
+        begin
+          if options[:word_boundary]
+            Regexp.new('\b' + token.downcase + '\b')
+          else
+            Regexp.new(token.downcase)
+          end
+        rescue
+          nil
+        end
+      end
+  end
+end

data/lib/abstractor/setup.rb

@@ -0,0 +1,24 @@
+module Abstractor
+  module Setup
+    def self.system
+      Abstractor::AbstractorObjectType.create(:value => 'list')
+      Abstractor::AbstractorObjectType.create(:value => 'number')
+      Abstractor::AbstractorObjectType.create(:value => 'boolean')
+      Abstractor::AbstractorObjectType.create(:value => 'string')
+      Abstractor::AbstractorObjectType.create(:value => 'radio button list')
+
+      Abstractor::AbstractorRuleType.create(:name => 'name/value', :description => 'search for value associated with name')
+      Abstractor::AbstractorRuleType.create(:name =>'name', :description => 'search for name match')
+      Abstractor::AbstractorRuleType.create(:name =>'value', :description => 'search for value match')
+      Abstractor::AbstractorRuleType.create(:name =>'unknown', :description => 'do not try to abstract, always assign "unknown"')
+      Abstractor::AbstractorRuleType.create(:name =>'custom', :description => 'use whatever from_method returns as a value')
+
+      Abstractor::AbstractorSuggestionStatus.create(:name => 'Needs review')
+      Abstractor::AbstractorSuggestionStatus.create(:name => 'Accepted')
+      Abstractor::AbstractorSuggestionStatus.create(:name => 'Rejected')
+
+      Abstractor::AbstractorRelationType.create(:name => 'member_of')
+      Abstractor::AbstractorRelationType.create(:name => 'preceded_by')
+    end
+  end
+end

data/lib/abstractor/user_interface.rb

@@ -0,0 +1,40 @@
+module Abstractor
+  ##
+  # A collection of helper methods used in the Abstactor user interface.
+  module UserInterface
+    #2/16/2014 MGURLEY Stolen from http://api.rubyonrails.org/classes/ActionView/Helpers/TextHelper.html.  Rails 3.2.16.
+    #                 Removed the cleverness trying skip highlighting content it thinks is html markup.
+    def self.highlight(text, phrases, *args)
+      options = args.extract_options!
+      unless args.empty?
+        options[:highlighter] = args[0] || '<strong class="highlight">\1</strong>'
+      end
+      options.reverse_merge!(:highlighter => '<strong class="highlight">\1</strong>')
+
+      # text = sanitize(text) unless options[:sanitize] == false
+      if text.blank? || phrases.blank?
+        text
+      else
+        match = Array(phrases).map { |p| Regexp.escape(p) }.join('|')
+        text.gsub(/(#{match})/i, options[:highlighter])
+      end.html_safe
+    end
+
+    ##
+    # Transforms a path to account for a relative url root.
+    # URL helpers in Rails Engine views and partials embedded in view in the host application don't play well with relative url roots.
+    # @param path [String] the URL path that should have a relative prefix added if needed
+    # @return [String] the processed URL
+    def self.abstractor_relative_path(path)
+      prefix = Rails.application.config.action_controller.relative_url_root
+
+      if prefix.blank? || path.include?(prefix)
+        url = path
+      else
+        url = prefix + path
+      end
+
+      url
+    end
+  end
+end

data/lib/abstractor/utility.rb

@@ -0,0 +1,8 @@
+module Abstractor
+  module Utility
+    def self.dehumanize(target)
+      result = target.to_s.dup
+      result.downcase.gsub(/ +/,'_')
+    end
+  end
+end

data/lib/abstractor/version.rb

@@ -0,0 +1,3 @@
+module Abstractor
+  VERSION = '1.0.8'
+end

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

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+require "rails/generators"
+
+module Abstractor
+  class InstallGenerator < Rails::Generators::Base
+    class_option "no-migrate", :type => :boolean
+    class_option "customize-all", :type => :boolean
+    class_option "customize-controllers", :type => :boolean
+    class_option "customize-models", :type => :boolean
+    class_option "customize-helpers", :type => :boolean
+    class_option "customize-layout", :type => :boolean
+    class_option "current-user-helper", :type => :string
+
+    def self.source_paths
+      paths = self.superclass.source_paths
+      paths << File.expand_path("../templates", __FILE__)
+      paths.flatten
+    end
+
+    desc "Used to install Abstractor"
+
+    def install_migrations
+      unless options["no-migrations"]
+        puts "Copying over Abstractor migrations..."
+        Dir.chdir(Rails.root) do
+          `rake abstractor:install:migrations`
+        end
+      end
+    end
+
+    ## shameless steal from forem git://github.com/radar/forem.git
+    def add_abstractor_user_method
+      current_user_helper = options["current-user-helper"].presence ||
+                            ask("What is the current_user helper called in your app? [current_user]").presence ||
+                            'current_user if defined?(current_user)'
+      puts "Defining abstractor_user method inside ApplicationController..."
+
+      abstractor_user_method = %Q{
+  def abstractor_user
+    #{current_user_helper}
+  end
+  helper_method :abstractor_user
+}
+      inject_into_file("#{Rails.root}/app/controllers/application_controller.rb",
+                       abstractor_user_method,
+                       :after => "ActionController::Base\n")
+    end
+
+    def run_migrations
+      unless options["no-migrate"]
+        puts "Running rake db:migrate"
+        `rake db:migrate`
+      end
+    end
+
+    def seed_database_with_setup_system
+      unless options["no-migrate"]
+        puts "Running rake abstractor:setup:system"
+        `rake abstractor:setup:system`
+      end
+    end
+
+    def mount_engine
+      puts "Mounting Abstractor::Engine at \"/\" in config/routes.rb..."
+      insert_into_file("#{Rails.root}/config/routes.rb", :after => /routes.draw.do\n/) do
+        %Q{  mount Abstractor::Engine, :at => "/"\n}
+      end
+    end
+
+    # def sample_abstraction_schema
+    #   path = "#{Rails.root}/lib"
+    #   empty_directory "#{path}/setup"
+    #   copy_file "abstraction_schema.yml", "#{path}/setup/abstraction_schema.yml"
+    # end
+
+    def make_customizable
+      if options["customize-all"] || options["customize-controllers"]
+        path = "#{Rails.root}/app/controllers/abstractor"
+        empty_directory path
+        copy_file "controllers/abstractor_abstraction_groups_controller.rb", "#{path}/abstractor_abstraction_groups_controller.rb"
+        copy_file "controllers/abstractor_abstractions_controller.rb", "#{path}/abstractor_abstractions_controller.rb"
+        copy_file "controllers/abstractor_suggestions_controller.rb", "#{path}/abstractor_suggestions_controller.rb"
+      end
+
+      if options["customize-all"] || options["customize-helpers"]
+        path = "#{Rails.root}/app"
+        empty_directory "#{path}/helpers/abstractor"
+        copy_file "helpers/abscractions_helper.rb", "#{path}/helpers/abstractor/abscractions_helper.rb"
+      end
+
+      if options["customize-all"] || options["customize-models"]
+        path = "#{Rails.root}/app"
+        empty_directory "#{path}/models/abstractor"
+        copy_file "models/abstractor_abstraction_group_member.rb", "#{path}/models/abstractor/abstractor_abstraction_group_member.rb"
+        copy_file "models/abstractor_abstraction_group.rb", "#{path}/models/abstractor/abstractor_abstraction_group.rb"
+        copy_file "models/abstractor_abstraction_schema_object_value.rb", "#{path}/models/abstractor/abstractor_abstraction_schema_object_value.rb"
+        copy_file "models/abstractor_abstraction_schema_predicate_variant.rb", "#{path}/models/abstractor/abstractor_abstraction_schema_predicate_variant.rb"
+        copy_file "models/abstractor_abstraction_schema_relation.rb", "#{path}/models/abstractor/abstractor_abstraction_schema_relation.rb"
+        copy_file "models/abstractor_abstraction_schema.rb", "#{path}/models/abstractor/abstractor_abstraction_schema.rb"
+        copy_file "models/abstractor_abstraction_source.rb", "#{path}/models/abstractor/abstractor_abstraction_source.rb"
+        copy_file "models/abstractor_abstraction.rb", "#{path}/models/abstractor/abstractor_abstraction.rb"
+        copy_file "models/abstractor_object_type.rb", "#{path}/models/abstractor/abstractor_object_type.rb"
+        copy_file "models/abstractor_object_value_variant.rb", "#{path}/models/abstractor/abstractor_object_value_variant.rb"
+        copy_file "models/abstractor_object_value.rb", "#{path}/models/abstractor/abstractor_object_value.rb"
+        copy_file "models/abstractor_relation_type.rb", "#{path}/models/abstractor/abstractor_relation_type.rb"
+        copy_file "models/abstractor_rule_type.rb", "#{path}/models/abstractor/abstractor_rule_type.rb"
+        copy_file "models/abstractor_subject_group_member.rb", "#{path}/models/abstractor/abstractor_subject_group_member.rb"
+        copy_file "models/abstractor_subject_group.rb", "#{path}/models/abstractor/abstractor_subject_group.rb"
+        copy_file "models/abstractor_subject_relation.rb", "#{path}/models/abstractor/abstractor_subject_relation.rb"
+        copy_file "models/abstractor_subject.rb", "#{path}/models/abstractor/abstractor_subject.rb"
+        copy_file "models/abstractor_suggestion_object_value.rb", "#{path}/models/abstractor/abstractor_suggestion_object_value.rb"
+        copy_file "models/abstractor_suggestion_source.rb", "#{path}/models/abstractor/abstractor_suggestion_source.rb"
+        copy_file "models/abstractor_suggestion_status.rb", "#{path}/models/abstractor/abstractor_suggestion_status.rb"
+        copy_file "models/abstractor_suggestion_status.rb", "#{path}/models/abstractor/abstractor_suggestion.rb"
+      end
+    end
+  end
+end

data/lib/generators/abstractor/install/templates/controllers/abstractor_abstraction_groups_controller.rb

@@ -0,0 +1,16 @@
+module Abstractor
+  module AbstractorAbstractionGroupsControllerCustomMethods
+    def create
+      super
+    end
+
+    def destroy
+      super
+    end
+  end
+
+  class AbstractorAbstractionGroupsController < ApplicationController
+    include Abstractor::Methods::Controllers::AbstractorAbstractionGroupsController
+    include Abstractor::AbstractorAbstractionGroupsControllerCustomMethods
+  end
+end