abstractor 1.0.8

data/lib/abstractor/core_ext/string.rb

@@ -0,0 +1,99 @@
+class Regexp
+  NUMERIC = Regexp.union(%r{^-?\d{1,3}(,\d{3}|\d+)*(\.\d+)*$},
+    %r{^\(?\d{1,3}(,\d{3}|\d+)*(\.\d+)*\)?$})
+end
+
+class String
+  def to_boolean
+    return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
+    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> (10..13)
+  #
+  # CREDIT: Trans
+
+  def range(pattern, offset=0)
+    unless Regexp === pattern
+      pattern = Regexp.new(Regexp.escape(pattern.to_s))
+    end
+    string = self[offset..-1]
+    if md = pattern.match(string)
+      return (md.begin(0)+offset)..(md.end(0)+offset-1)
+    end
+    nil
+  end
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  # TODO: Add offset ?
+  #
+  # CREDIT: Trans
+
+  def range_all(pattern, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(pattern, i)
+      if rng
+        r << rng
+        i += reuse ? 1 : rng.end + 1
+      else
+        break
+      end
+    end
+    r.uniq
+  end
+
+  # Returns an array of ranges mapping
+  # the characters per line.
+  #
+  #   "this\nis\na\ntest".range_of_line
+  #   #=> [0..4, 5..7, 8..9, 10..13]
+  #
+  # CREDIT: Trans
+
+  def range_of_line
+    offset=0; charmap = []
+    each_line do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+
+  def numeric?
+    match(Regexp::NUMERIC) != nil
+  end
+
+  def integer?
+    begin
+      Integer(self)
+      self
+    rescue ArgumentError => e
+      nil
+    end
+  end
+
+  def date?
+    begin
+      d = Date.parse(self)
+    rescue ArgumentError => e
+      nil
+    end
+  end
+
+  def ssn?
+    if  (integer? && length == 9)
+      self
+    elsif ((self =~ /[0-9]{3}-[0-9]{2}-[0-9]{4}/ ) == 0)
+      self.gsub('-','')
+    else
+      nil
+    end
+  end
+end

data/lib/abstractor/engine.rb

@@ -0,0 +1,14 @@
+require 'haml'
+
+module Abstractor
+  class Engine < ::Rails::Engine
+    isolate_namespace Abstractor
+    root = File.expand_path('../../', __FILE__)
+    config.autoload_paths << root
+    config.generators do |g|
+      g.test_framework   :rspec
+      g.integration_tool :rspec
+      g.template_engine  :haml
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Abstractor
+  module Methods
+    module Controllers
+      module AbstractorAbstractionGroupsController
+        def self.included(base)
+          base.send :helper, :all
+        end
+
+        def create
+          @abstractor_abstraction_group = Abstractor::AbstractorAbstractionGroup.create(abstractor_subject_group_id: params[:abstractor_subject_group_id], about_type: params[:about_type], about_id: params[:about_id])
+          @abstractor_abstraction_group.abstractor_subject_group.abstractor_subjects.each do |abstractor_subject|
+            abstraction = abstractor_subject.abstractor_abstractions.build(about_id: params[:about_id], about_type: params[:about_type])
+            abstraction.build_abstractor_abstraction_group_member(abstractor_abstraction_group: @abstractor_abstraction_group)
+            abstraction.save!
+          end
+
+          respond_to do |format|
+            format.html { render action: "edit", layout: false }
+          end
+        end
+
+        def destroy
+          abstractor_abstraction_group = Abstractor::AbstractorAbstractionGroup.find(params[:id])
+          if abstractor_abstraction_group.soft_delete!
+            flash[:notice] = "Group was successfully deleted."
+          else
+            flash[:error] = "Group could not be deactivated: #{abstractor_abstraction_group.errors.full_messages.join(',')}"
+          end
+          respond_to do |format|
+            format.js   { head :no_content }
+            format.json { head :no_content }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Abstractor
+  module Methods
+    module Controllers
+      module AbstractorAbstractionsController
+        def self.included(base)
+          base.send :before_filter, :set_abstractor_abstraction, :only => [:show, :edit, :update]
+        end
+
+        def index
+        end
+
+        def show
+          respond_to do |format|
+            format.html { render :layout => false }
+          end
+        end
+
+        def edit
+          respond_to do |format|
+            format.html { render :layout => false }
+          end
+        end
+
+        def update
+          respond_to do |format|
+            if @abstractor_abstraction.update_attributes(params[:abstractor_abstraction])
+              format.html { redirect_to(abstractor_abstraction_path(@abstractor_abstraction)) }
+            else
+              format.html { render :action => "edit" }
+            end
+          end
+        end
+
+        private
+          def set_abstractor_abstraction
+            @abstractor_abstraction = Abstractor::AbstractorAbstraction.find(params[:id])
+            @about = @abstractor_abstraction.about
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Abstractor
+  module Methods
+    module Controllers
+      module AbstractorSuggestionsController
+        def self.included(base)
+          base.send :before_filter, :set_abstractor_suggestion, :only => [:update]
+        end
+
+        def update
+          respond_to do |format|
+            if @abstractor_suggestion.update_attributes(params[:abstractor_suggestion])
+              format.html { redirect_to(abstractor_abstraction_path(@abstractor_abstraction)) }
+            else
+              format.html { render "abstractor_abstractions/show" }
+            end
+          end
+        end
+
+        private
+          def set_abstractor_suggestion
+            @abstractor_abstraction = Abstractor::AbstractorAbstraction.find(params[:abstractor_abstraction_id])
+            @abstractor_suggestion = Abstractor::AbstractorSuggestion.find(params[:id])
+            @about = @abstractor_abstraction.about
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstraction
+        def self.included(base)
+          base.send :include, SoftDelete
+          base.send :has_paper_trail
+
+          # Associations
+          base.send :belongs_to, :abstractor_subject
+
+          base.send :has_many, :abstractor_suggestions
+          base.send :has_many, :abstractor_abstraction_sources, :through => :abstractor_abstractor_suggestions
+
+          base.send :has_one, :abstractor_abstraction_group_member
+          base.send :has_one, :abstractor_abstraction_group, :through => :abstractor_abstraction_group_member
+          base.send :has_one, :abstractor_abstraction_schema, :through => :abstractor_subject
+
+          base.send :accepts_nested_attributes_for, :abstractor_suggestions
+
+          base.send :belongs_to, :about, polymorphic: true
+
+          base.send :attr_accessible, :about, :abstractor_subject, :abstractor_subject_id, :value, :about_type, :about_id, :unknown, :not_applicable, :deleted_at
+
+          # Hooks
+          base.send :after_save, :review_matching_suggestions#, :if => lambda {|abstractor_abstraction| abstractor_abstraction.value_changed?}
+        end
+
+        def review_matching_suggestions
+          accepted_status = Abstractor::AbstractorSuggestionStatus.where(:name => 'Accepted').first
+          matching_abstractor_suggestions.each do |abstractor_suggestion|
+            abstractor_suggestion.abstractor_suggestion_status = accepted_status
+            abstractor_suggestion.save!
+          end
+        end
+
+        def matching_abstractor_suggestions
+          unknown_values        = unknown ? unknown : [unknown, nil]
+          not_applicable_values = not_applicable ? not_applicable : [not_applicable, nil]
+          suggested_values = value.blank? ? ['', nil] : value
+          abstractor_suggestions.where(unknown: unknown_values, not_applicable: not_applicable_values, suggested_value: suggested_values)
+        end
+
+        def display_value
+          if unknown
+            'unknown'
+          elsif not_applicable
+            'not applicable'
+          elsif value.blank?
+            '[Not set]'
+          else
+            value
+          end
+        end
+
+        def detect_abstractor_suggestion(suggested_value)
+          abstractor_suggestion = nil
+          abstractor_suggestion = abstractor_suggestions(true).detect do |abstractor_suggestion|
+            abstractor_suggestion.suggested_value == suggested_value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstractionGroup
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_subject_group
+          base.send :belongs_to, :about, polymorphic: true
+
+          base.send :has_many, :abstractor_abstraction_group_members
+          base.send :has_many, :abstractor_abstractions, :through => :abstractor_abstraction_group_members
+
+          base.send :attr_accessible, :abstractor_subject_group, :abstractor_subject_group_id, :deleted_at, :about, :about_type, :about_id
+
+          # Hooks
+          base.send :after_commit, :update_abstractor_abstraction_group_members, :on => :update, :if => Proc.new { |record| record.previous_changes.include?('deleted_at') }
+        end
+
+        # Instance Methods
+        def removable?
+          abstractor_abstractions.map(&:abstractor_suggestions).flatten.empty?
+        end
+
+        private
+          def update_abstractor_abstraction_group_members
+            return unless deleted?
+            abstractor_abstraction_group_members.each do |gm|
+              gm.soft_delete!
+              gm.abstractor_abstraction.soft_delete!
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstractionGroupMember
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_abstraction_group
+          base.send :belongs_to, :abstractor_abstraction
+
+          base.send :attr_accessible, :abstractor_abstraction_group, :abstractor_abstraction_group_id, :abstractor_abstraction, :abstractor_abstraction_id, :deleted_at
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstractionSchema
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_object_type
+          base.send :has_many, :abstractor_subjects
+          base.send :has_many, :abstractor_abstraction_schema_predicate_variants
+          base.send :has_many, :abstractor_abstraction_schema_object_values
+          base.send :has_many, :abstractor_object_values, :through => :abstractor_abstraction_schema_object_values
+          base.send :has_many, :object_relations,   :class_name => "Abstractor::AbstractorAbstractionSchemaRelation", :foreign_key => "object_id"
+          base.send :has_many, :subject_relations,  :class_name => "Abstractor::AbstractorAbstractionSchemaRelation", :foreign_key => "subject_id"
+
+          base.send :attr_accessible, :abstractor_object_type, :abstractor_object_type_id, :display_name, :predicate, :preferred_name, :deleted_at
+        end
+
+        # Instance Methods
+        def predicate_variants
+          [preferred_name].concat(abstractor_abstraction_schema_predicate_variants.map(&:value))
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+module Abstractor
+  module Methods
+    module Models
+      module AbstractorAbstractionSource
+        def self.included(base)
+          base.send :include, SoftDelete
+
+          # Associations
+          base.send :belongs_to, :abstractor_subject
+          base.send :has_many, :abstractor_suggestion_sources
+          base.send :has_many, :abstractor_abstractions, :through => :abstractor_suggestion_sources
+
+          base.send :attr_accessible, :abstractor_subject, :abstractor_subject_id, :deleted_at, :from_method
+        end
+
+        def normalize_from_method_to_sources(about)
+          sources = []
+          fm = about.send(from_method)
+          if fm.is_a?(String) || fm.nil?
+            sources = [{ source_type: about.class , source_id: about.id , source_method: from_method }]
+          else
+            sources = fm
+          end
+          sources
+        end
+      end
+    end
+  end
+end