enterprise_mti 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2b1b8964e6ee113a1a9e254983691b9c26cbcdc
+  data.tar.gz: a14f2076d338fc4ee3833c179870e439ef623659
+SHA512:
+  metadata.gz: b0d8aa4f7ca07d83f93e4ce7b2920a54d83a1569b7784947ab3820c58a532dba43f217195496bb1d8baf1bfe7765e7e1e354db37cc5e75c9d5562f7d4c874edc
+  data.tar.gz: d9c434e75b93e4fbef5f48956e981f18c7512c08af68317e7f112cc2ede9653962f349de4ef75cbcd719d74d4fc839671733a136b7e0b57ec171bacdd9c715de

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Ersin Akinci
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'EnterpriseMti'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/enterprise_mti.rb

@@ -0,0 +1,9 @@
+require 'enterprise_mti/class_methods'
+require 'enterprise_mti/migration'
+
+module EnterpriseMti
+  extend ActiveSupport::Concern
+end
+
+ActiveRecord::Base.send :include, ::EnterpriseMti
+ActiveRecord::Migration.send :include, ::EnterpriseMti::Migration

data/lib/enterprise_mti/class_methods.rb

@@ -0,0 +1 @@
+require_relative 'class_methods/class_methods'

data/lib/enterprise_mti/class_methods/class_methods.rb

@@ -0,0 +1,175 @@
+module EnterpriseMti
+  module ClassMethods
+    def has_subclass(subclass_symbol, options={})
+    
+      subclass_name           = subclass_symbol.to_s.camelize
+      subclass                = nil
+      subclass_qualified_name = (options[:module] || '') + '::' + subclass_name
+      superclass              = self
+      superclass_name         = self.name.demodulize.underscore
+      superclass_symbol       = self.name.demodulize.underscore.to_sym
+      table_name              = options[:table_name] || subclass_symbol.to_s.pluralize
+    
+      # Get subclass
+      Kernel.const_get(options[:module] || 'Kernel').module_eval {
+        subclass = const_get subclass_name }
+    
+      subclass.class_eval do
+        # Set table name on subclass to prevent it from inheriting
+        # superclass' attributes, etc.
+        self.table_name = table_name
+        has_one superclass_symbol
+        attr_accessor :superclass_instance
+        validates :superclass_instance, presence: true
+      
+        define_method "#{superclass_name}_transaction" do
+          superclass_instance.send "#{subclass_symbol.to_s}_id=", self.id
+          superclass_instance.save
+        end
+        after_save "#{superclass_name}_transaction".to_sym, on: :create
+      end
+    
+      # Superclass belongs to subclass
+      self.belongs_to subclass_symbol, :class_name => subclass_qualified_name
+    end
+  
+    def is_a_superclass
+
+      # Require subclasses' files as dependencies, otherwise we get circular
+      # dependency errors (see https://github.com/rails/rails/issues/3364)
+      if descendants.empty?
+        module_path_tokens = self.name.underscore.split('/')
+        module_path_tokens[-1] += '_subclasses'
+        Dir[Rails.root.join('app', 'models', File.join(module_path_tokens), "*.rb")].each do |file|
+          require_dependency file
+        end
+      end
+    
+      # Call has_sublcass on the superclass for each subclass
+      descendants.each do |subclass|
+        name_tokens = subclass.to_s.split('::')
+        subclass_name = name_tokens.last
+        module_name = name_tokens[0...-1].join('::') if name_tokens.count > 1
+        self.send :has_subclass, subclass_name.underscore.to_sym, :module => module_name
+      end
+    
+      # Populate container_classes, an array that contains classes that "have"
+      # the superclass (and thus have foreign key constraints on the
+      # superclass)
+      reflection_class = Proc.new do |r|
+        if r.options[:class_name]
+          r.options[:class_name].constantize
+        else
+          prefix = self.name.deconstantize || ''
+          "#{prefix}::#{r.name.to_s.camelize}".constantize
+        end
+      end
+      
+      @container_classes = self.reflect_on_all_associations.keep_if { |r|
+        r.macro == :belongs_to &&
+        #self.column_names.include?(r.association_foreign_key) &&
+        !self.descendants.include?(reflection_class.call(r))
+      }.collect { |r| reflection_class.call(r) }
+    
+      # Add read-only access to container_classes
+      class << self
+        def container_classes
+          @container_classes
+        end
+      end
+    end
+  
+    def has_one_superclass(superclass_symbol, options={})
+    
+      superclass_name                 = superclass_symbol.to_s.camelize
+      superclass_qualified_name       = (options[:module] || '') + '::' + superclass_name
+      superclass                      = superclass_qualified_name.constantize
+      container_class                 = self
+      container_class_camel_name      = self.name.demodulize
+      container_class_underscore_name = self.name.demodulize.underscore
+      superclass_relation_name        = superclass_symbol.to_s + "_superclass"
+      superclass_relation_symbol      = superclass_relation_name.to_sym
+    
+      has_one superclass_relation_symbol, class_name: superclass_qualified_name
+    
+      # Create build and create methods for each subclass
+      superclass.descendants.each do |subclass|
+        subclass_underscore_name = subclass.name.demodulize.underscore
+        actions = [:build, :create, :create!]
+      
+        actions.each do |action|
+          action_suffix = nil
+          action_name   = action.to_s
+        
+          if action.to_s.last(1) == '!'
+            action_suffix = '!'
+            action_name   = action.to_s[0..-2]
+          end
+
+          subclass.define_singleton_method "#{action_name}_with_superclass_instance#{action_suffix}" do |*args, &block|
+            self.send("#{action_name}#{action_suffix}", *args, &block).superclass_instance = args.last[:superclass_instance]
+          end
+        
+          superclass.class_eval do
+          
+            define_method "#{action_name}_#{subclass_underscore_name}_subclass#{action_suffix}" do |*args, &block|
+              args.last[:superclass_instance] = self
+              subclass.send "#{action_name}_with_superclass_instance#{action_suffix}", *args, &block
+            end
+          
+            define_method "#{subclass_underscore_name}_with_superclass_instance=" do |value|
+              value.superclass_instance = self
+              self.send "#{subclass_underscore_name}=", value
+            end
+          end
+
+          container_class.class_eval do
+          
+            define_method "#{action_name}_#{subclass_underscore_name}#{action_suffix}" do |*args, &block|
+              unless superclass_instance = self.send(superclass_relation_symbol)
+                superclass_instance = self.send("build_#{superclass_relation_name}")
+              end
+              superclass_instance.instance_eval do
+                send "#{action_name}_#{subclass_underscore_name}_subclass#{action_suffix}", *args, &block
+              end
+            end
+          end
+        end
+      end
+    
+      # Create getter
+      define_method superclass_symbol do
+
+        association_methods = superclass.descendants.collect { |subclass|
+          reflection_symbol =
+            subclass.to_s.demodulize.underscore.to_sym
+          assoc = superclass.reflect_on_association(reflection_symbol)
+          assoc ? assoc.name : nil
+        }.compact
+      
+        if superclass_model_instance = self.send(superclass_relation_symbol)
+          association_methods.collect{ |a|
+            superclass_model_instance.send a
+          }.inject do |a, b|
+            a || b
+          end
+        end
+      end
+    
+      # Create setter
+      define_method "#{superclass_symbol.to_s}=" do |value|
+        reflection_symbol =
+          value.class.name.demodulize.underscore.to_sym
+
+        unless superclass_instance = self.send(superclass_relation_symbol)
+          superclass_instance = self.send("build_#{superclass_relation_name}")
+        end
+      
+        reflection_assignment_method =
+          superclass.reflect_on_association(reflection_symbol).name.to_s + '_with_superclass_instance='
+        
+        superclass_instance.send reflection_assignment_method, value
+      end
+    end
+  end
+end

data/lib/enterprise_mti/migration.rb

@@ -0,0 +1 @@
+require_relative 'migration/migration'

data/lib/enterprise_mti/migration/migration.rb

@@ -0,0 +1,34 @@
+require_relative 'sql_factory'
+
+module EnterpriseMti
+  module Migration
+    
+    def enterprise_mti_run(opts={})
+      if opts[:superclass_table] && opts[:subclass_tables] && opts[:direction]
+
+        case Rails.configuration.database_configuration[Rails.env]['adapter']
+        when 'postgresql'
+          sql_factory = SqlFactory::PostgresSqlFactory.new
+        end
+    
+        sql_factory.superclass_table = opts[:superclass_table]
+        sql_factory.subclass_tables = opts[:subclass_tables]
+    
+        sql = sql_factory.sql_for_up if opts[:direction] == :up
+        sql = sql_factory.sql_for_down if opts[:direction] == :down
+        
+        execute sql
+      end
+    end
+    
+    def enterprise_mti_up(opts={})
+      enterprise_mti_run opts.merge!(direction: :up)
+    end
+
+    def enterprise_mti_down(opts={})
+      enterprise_mti_run opts.merge!(direction: :down)
+    end
+  end
+end
+
+ActiveRecord::Migration.send :include, EnterpriseMti::Migration

data/lib/enterprise_mti/migration/sql_factory.rb

@@ -0,0 +1,2 @@
+require_relative 'sql_factory/sql_factory'
+require_relative 'sql_factory/postgres_sql_factory'

data/lib/enterprise_mti/migration/sql_factory/postgres_sql_factory.rb

@@ -0,0 +1,16 @@
+module EnterpriseMti
+  module Migration
+    module SqlFactory
+      
+      class PostgresSqlFactory < SqlFactory
+        def integer
+          "INTEGER"
+        end
+        
+        def id_type
+          "BIGINT"
+        end
+      end
+    end
+  end
+end

data/lib/enterprise_mti/migration/sql_factory/sql_factory.rb

@@ -0,0 +1,132 @@
+module EnterpriseMti
+  module Migration
+    module SqlFactory
+      
+      class SqlFactory
+        attr_accessor :superclass_table, :subclass_tables
+      
+        def sql_for_up
+          [superclass_table_up, subclass_tables_up].join
+        end
+      
+        def sql_for_down
+          [subclass_tables_down, superclass_table_down].join
+        end
+      
+        ## Up methods (superclass) ##
+      
+        def superclass_table_up
+          [superclass_table_foreign_keys_up, superclass_table_xor_constraint_up]
+        end
+      
+        def superclass_table_foreign_keys_up
+          subclass_tables.map { |subclass_table|
+            alter_table superclass_table do
+              add_column "#{subclass_table}_id",
+              type: id_type,
+              nullable: false,
+              unique: true,
+              references: { table: subclass_table, column: "id" },
+              defer: true
+            end
+          }
+        end
+        
+        def superclass_table_xor_constraint_up
+          alter_table superclass_table do
+            add_constraint "#{superclass_table}_xor", type: :check do
+              subclass_tables.map { |subclass_table|
+                "(#{subclass_table}_id IS #{not_null})::#{integer}"
+              }.join(' + ') << ' = 1'
+            end
+          end
+        end
+        
+        ## Up methods (subclass) ##
+        
+        def subclass_tables_up
+          subclass_tables_id_alterations_up
+        end
+        
+        def subclass_tables_id_alterations_up
+          subclass_tables.map { |subclass_table|
+            alter_table subclass_table do
+              add_constraint "id_fkey", type: :foreign_key, column: 'id' do
+                options_parser references: { table: superclass_table, column: "#{subclass_table}_id" }, defer: true
+              end
+            end
+          }
+        end
+      
+        ## Down methods (superclass) ##
+      
+        def superclass_table_down
+          [superclass_table_xor_constraint_down, superclass_table_foreign_keys_down]
+        end
+      
+        def superclass_table_xor_constraint_down
+          alter_table superclass_table do
+            drop_constraint "#{superclass_table}_xor"
+          end
+        end
+      
+        def superclass_table_foreign_keys_down
+          subclass_tables.map do |subclass_table|
+            alter_table superclass_table do
+              drop_column("#{subclass_table}_id")
+            end
+          end
+        end
+        
+        ## Down methods (subclass) ##
+        
+        def subclass_tables_down
+          subclass_tables_id_alterations_down
+        end
+        
+        def subclass_tables_id_alterations_down
+          subclass_tables.map do |subclass_table|
+            alter_table subclass_table do
+              drop_constraint 'id_fkey'
+            end
+          end
+        end
+      
+        ## DSL ##
+      
+        def options_parser(opts={})
+          sql = []
+          sql.push opts[:type]
+          sql.push not_null if opts[:nullable] == false
+          sql.push unique if opts[:unique]
+          sql.push references table: opts[:references][:table], column: opts[:references][:column] if opts[:references]
+          sql.push defer if opts[:defer]
+          sql.join(' ')
+        end
+        def alter_table(table);              "ALTER TABLE #{table} #{yield};"; end
+        def add_column(column, opts={})
+          "ADD COLUMN #{column} #{options_parser opts}"
+        end
+        def alter_column(column, opts={})
+          "ALTER COLUMN #{column} SET #{options_parser opts}"
+        end
+        def drop_column(column);             "DROP COLUMN #{column}"; end
+        def not_null;                        "NOT NULL"; end
+        def unique;                          "UNIQUE"; end
+        def references(opts={});             "REFERENCES #{opts[:table]}(#{opts[:column]})"; end
+        def add_constraint(name, opts={})
+          case opts[:type]
+          when :check
+            type = 'CHECK ('
+            suffix = ')'
+          when :foreign_key
+            type = "FOREIGN KEY(#{opts[:column]})"
+          end
+          "ADD CONSTRAINT #{name} #{type} #{yield} #{suffix}"
+        end
+        def drop_constraint(name);           "DROP CONSTRAINT #{name}"; end
+        def defer;                           "DEFERRABLE INITIALLY DEFERRED"; end
+      end
+    end
+  end
+end

data/lib/enterprise_mti/version.rb

@@ -0,0 +1,3 @@
+module EnterpriseMti
+  VERSION = "0.0.1"
+end