multi_tabular 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 92cbe3c16e1fc9900bea20bb3639e58ebc986ba3
+  data.tar.gz: 4c0b92455f9d66494462fae3df726388f77144b2
+SHA512:
+  metadata.gz: 507ccebc9e858d9dc1ef6369eddc49d0cd25840c64e90120fa91c11c6ecf5e9e54fd231bec76394ed5791fc6a02ece1eed7d2ab1cf438f836faf976847965e85
+  data.tar.gz: b3e5d0b1702d0a503c748ac62192889859bf9fe48131215f8642ec83757f0474f4c9955221b82cdc57dd466c18781e1c1c4abd61cf02349da10b6866ea6f8551

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Gem's dependencies are specified in multitabular.gemspec
+gemspec

data/lib/multi_tabular.rb

@@ -0,0 +1,9 @@
+require 'multi_tabular/references'
+require 'multi_tabular/super'
+require 'multi_tabular/sub'
+require 'multi_tabular/version'
+
+module MultiTabular
+  class InvalidBaseClassError
+  end
+end

data/lib/multi_tabular/references.rb

@@ -0,0 +1,91 @@
+module MultiTabular
+  # For classes that reference an MTI class
+  module References
+    extend ActiveSupport::Concern
+
+    included do
+      def reflection_assignment_method(klass)
+        self.class.reflect_on_association(reflection_symbol(klass)).name.to_s + '='
+      end
+
+      def reflection_assignment_symbol(sym)
+        self.class.reflect_on_association(sym).name.to_s + '='
+      end
+
+      # for all subclasses of the given base class, returns a
+      # list of defined associations within the current class
+      def association_methods(mti_base_class)
+        (mti_base_class.descendants << mti_base_class).map{|s|
+          assoc = self.class.reflect_on_association(reflection_symbol s)
+          assoc ? assoc.name : nil
+        }.compact
+      end
+
+      # for a given class, returns the appropriate symbol
+      # to pass to the ActiveRecord method reflect_on_association
+      def reflection_symbol(klass)
+        klass.to_s.sub('::', '_').underscore.to_sym
+      end
+    end
+
+    module ClassMethods
+      # create a polymorphic association to an MTI construct in a belongs_to fashion,
+      # meaning that the table of the class including this mixin has a foreign key to each of the MTI construct's
+      # concrete models. It defines a getter and setter method named like the assoc_sym argument.
+      # The method tries to guess the base class itself based on the association name, but if namespaces or an arbitrary
+      # association name is used, the name of the base class should be passed as string with base_class: 'BaseClassName"
+      def belongs_to_mti(assoc_sym, params = {})
+        # Check if guessed or passed in constant is a class and is a descendant of ActiveRecord::Base
+        def validate_base_class(bc)
+          bc.is_a?(Class) && bc < ActiveRecord::Base
+        end
+
+        # for a given class, returns the appropriate symbol
+        # to pass to the ActiveRecord method reflect_on_association
+        def reflection_symbol(klass)
+          klass.to_s.sub('::', '_').underscore.to_sym
+        end
+
+        if params.key? :base_class
+          base_class = Module.const_get params[:base_class]
+        else
+          base_class = Module.const_get assoc_sym.capitalize
+        end
+
+        # Raise an error if the base class doesn't saturate the conditions.
+        unless validate_base_class base_class
+          fail InvalidBaseClassError.new "#{base_class} is not a valid base class."
+        end
+
+        # Define the getter method for retrieving a referenced MTI record.
+        # Each association method for the base class is invoked and first that returns a result will be used.
+        define_method(assoc_sym.to_s) do
+          association_methods(base_class).map do|a|
+            send a
+          end.reduce do |a, b|
+            a || b
+          end
+        end
+
+        define_method("count_#{assoc_sym.to_s.pluralize}") do
+          association_methods(base_class).reduce(0) do |sum, method|
+            send(method) ? sum + 1 : sum
+          end
+        end
+
+        # Define the setter method that dynamically accesses the concrete setter for the type of the assignee.
+        define_method("#{assoc_sym}=") do |assignee|
+          association_methods(base_class).each do |association|
+            send reflection_assignment_symbol(association), nil
+          end
+
+          send reflection_assignment_method(assignee.class), assignee
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include MultiTabular::References
+end

data/lib/multi_tabular/sub.rb

@@ -0,0 +1,13 @@
+module MultiTabular
+  # For subclasses of an MTI construct.
+  # These classes inherit logic from a superclass and are persisted in their own table.
+  module Sub
+    extend ActiveSupport::Concern
+
+    # Set the table name to be the class name, including namespaces.
+    # If a different table should be used, override this variable in your class.
+    included do
+      self.table_name = name.underscore.sub('/', '_').pluralize
+    end
+  end
+end

data/lib/multi_tabular/super.rb

@@ -0,0 +1,18 @@
+module MultiTabular
+  # For superclasses of an MTI construct.
+  # These classes can provide shared logic, but are not an activerecord-model on their own,
+  # meaning they have no corresponding table in the database.
+  module Super
+    extend ActiveSupport::Concern
+
+    included do
+      self.abstract_class = true
+
+      # Allow converting the class name to an assumed foreign key in an associated model's database.
+      # If a different foreign should be used, you can override this method or simply declare the foreign key manually.
+      def self.to_foreign_key
+        name.underscore.sub('/', '_').singularize << '_id'
+      end
+    end
+  end
+end

data/lib/multi_tabular/version.rb

@@ -0,0 +1,3 @@
+module MultiTabular
+  VERSION = '0.0.2'
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: multi_tabular
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Alexander Junger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: |-
+  Facilitates true multi table inheritance of ActiveRecord models by providing methods for
+  super- and subclasses as well as models with a foreign-key association to MTI records.
+email: hello@alexanderjunger.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lib/multi_tabular.rb
+- lib/multi_tabular/references.rb
+- lib/multi_tabular/sub.rb
+- lib/multi_tabular/super.rb
+- lib/multi_tabular/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: True multi table inheritance for ActiveRecord.
+test_files: []