activerecord-cti 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ae47e6580bbe7ed9941cce85c4233042889acbdb1ec1ebcffcfa5b9383b383b
+  data.tar.gz: 21320a42fe6ae3f20e6805ee6975c6e316a16486f358a01a5daecf7cf216c588
+SHA512:
+  metadata.gz: 0ff27306a2099339cef9f29bda3e6b6dad3e0edfc48c1b91fa36d5e53385a5563561f0529a635495c098cada33cb3bde9476cd19eee0e00d190489f8d4e5813d
+  data.tar.gz: 8c9d4683555a12478cb779ae042b08233975b55513d5a4ad64023738526fc8b3510065940bf9f87867fc2ee7497cbabad758555646d3b885066a8991b747435c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 
+
+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/README.md

@@ -0,0 +1,115 @@
+# ActiveRecord::Cti
+ActiveRecord-Cti is a library implemented [Class Table Inheritance](https://martinfowler.com/eaaCatalog/classTableInheritance.html) on ActiveRecord.
+Class Table Inheritance (CTI) is useful under the circumstances that an ActiveRecord object is in multiple positions or has multiple roles, and you want to describe it's structure on the database. 
+For Example, one person may be a player and a coach in a soccer team.
+
+## Why use activerecord-cti ?
+In ActiveRecord, Single Table Inheritance(STI) is implemented as a method of how to express inheritance model on database. Class Table Inheritance (CTI) has more powerful and flexible expressiveness for inheritance model on database than it of STI.
+
+For Example, Suppose you want to describe the following class structure on database.
+
+![Class Diagram](public/images/class_diagram.png)
+
+But STI has a disadvantage that it is not possible to represent one record as an object of two different models at the same time.
+
+#### people talbe (STI)
+| id | type | name      | birth_year | position_name   | licence_name |
+|----|------|-----------|------------|-----------------|---------------|
+| 1  |Player| Ryan Giggs|  1973      | midfielder      |               |
+| 2  |Coach | Ryan Giggs|  1973      |                 | UEFA Pro      |
+
+As mentiond above, for expressing two `Person`'s subclasses objects, which are `Player` and `Coach`, you have to insert two records into people table in STI.
+It is cursed that the contents of `name` and `birth_year` columns are duplicated and `position_name` and `licence_name` columns are sparse.
+
+CTI can solve these problems by using multiple related tables like shown below, literally for class table inheritance.
+
+![ER Diagram](public/images/er_diagram.png)
+
+## How to use
+### Preparation
+First of all, generate the files of models you want to apply CTI to, and execute migration.
+
+```bash
+$ rails g model Person name:string birth_year:integer
+$ rails g model Player person_id:integer position_name:string 
+$ rails g model Coach person_id:integer licence_name:string
+$ rake db:migrate
+```
+
+Next, add the following line into `Person` model, which is base class.
+
+```ruby
+class Person < ApplicationRecord
+  include ActiveRecord::Cti::BaseClass #added
+end
+```
+By this mix-in, `Person` model is configured as base class in CTI, and automatically becomes abstract class as well.
+
+And then, rewrite files of subclass models for inheriting base class.
+
+```ruby
+class Player < Person
+end
+```
+
+```ruby
+class Coach < Person
+end
+```
+
+### Coding
+To save data of Ryan Giggs as a football player, describe following:
+
+```ruby
+player = Player.new(
+  name: 'Ryan Giggs',
+  birth_year: 1973,
+  position_name: 'midfielder'
+)
+player.save
+```
+So that his data is automatically split into two related tables.
+```bash
+MariaDB> SELECT * FROM people limit 1;
++----+----------------+------------+
+| id | name           | birth_year |
++----+----------------+------------+
+|  1 | Ryan Giggs     | 1973       |
++----+----------------+------------+
+
+MariaDB> SELECT * FROM players limit 1;
++----+----------------+---------------+
+| id | person_id      | position_name |
++----+----------------+---------------+
+|  1 | 1              | midfielder    |
++----+----------------+---------------+
+```
+
+Then, Ryan Giggs started coaching at Manchester United in 2013 as well as being a player.
+To save the data of Giggs as a coach to DB, describe following:
+
+```ruby
+player = Player.find_by(name: 'Ryan Giggs')
+coach = player.to_coach(licence_name: 'UEFA Pro')
+coach.save
+```
+
+So that his data is newly inserted into only coaches table.
+```bash
+MariaDB> SELECT * FROM coaches limit 1;
++----+----------------+--------------+
+| id | person_id      | licence_name |
++----+----------------+--------------+
+|  1 | 1              | UEFA Pro     |
++----+----------------+--------------+
+```
+
+To get Ryan Giggs's Data as a coach, describe following:
+```ruby
+Coach.find_by_name('Ryan Giggs') #<Coach id: 1, name: "Ryan Giggs", licence_name: 'UEFA Pro'>
+```
+
+Like this, pserson_id, which coaches table has as foreign_key reffered to base class object, is concealed.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+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    = 'Activerecord::Cti'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/activerecord/cti.rb

@@ -0,0 +1,8 @@
+require "activerecord/cti/railtie"
+require "activerecord/cti/base_class"
+require "activerecord/cti/sub_class"
+
+module ActiveRecord
+  module Cti
+  end
+end

data/lib/activerecord/cti/base_class.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  module Cti
+    module BaseClass
+      extend ActiveSupport::Concern
+
+      included do
+        self.abstract_class = true
+      end
+
+      class_methods do
+        def inherited(subclass)
+          super
+          subclass.include(ActiveRecord::Cti::SubClass)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/cti/railtie.rb

@@ -0,0 +1,6 @@
+module Activerecord
+  module Cti
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/activerecord/cti/sub_class.rb

@@ -0,0 +1,177 @@
+module ActiveRecord
+  module Cti
+    module SubClass
+      extend ActiveSupport::Concern
+
+      included do
+        default_scope { joins("INNER JOIN #{superclass_table_name} ON #{table_name}.#{foreign_key_name} = #{superclass_table_name}.id").select(default_select_columns) }
+
+        # Define dinamically to_* methods, which convert self to other subclass has same CTI superclass.
+        Pathname.glob("#{Rails.root}/app/models/*").collect do
+          |path| path.basename.to_s.split('.').first.classify.safe_constantize
+        end.compact.delete_if do |model|
+          !model.superclass.include?(ActiveRecord::Cti::BaseClass) or model == self
+        end.each do |model|
+          define_method("to_#{model.to_s.underscore}") do |args = {}|
+            model_instance = model.new(args)
+            model_instance.attributes = attributes.slice(*superclass_for_rw.column_names - [@primary_key])
+            model_instance.send(:foreign_key_value=, foreign_key_value)
+            model_instance
+          end
+        end
+      end
+
+      class_methods do
+        # Generates all the attribute related methods for columns in the database
+        # accessors, mutators and query methods.
+        def define_attribute_methods # :nodoc:
+          return false if @attribute_methods_generated
+          generated_attribute_methods.synchronize do
+            return false if @attribute_methods_generated
+            @attribute_methods_generated = true
+          end
+        end
+
+        def superclass_name
+          superclass.to_s
+        end
+
+        def superclass_table_name
+          superclass_name.tableize
+        end
+
+        def subclass_table_name
+          table_name
+        end
+
+        def foreign_key_name
+          superclass.to_s.foreign_key
+        end
+
+        # Get columns to pass +joins+ while calling +default_scope+.
+        def default_select_columns
+          ((superclass_column_names - [primary_key]).collect do |key|
+            "#{superclass_table_name}.#{key}"
+          end + subclass_column_names.collect do |key|
+            "#{subclass_table_name}.#{key}"
+          end).join(',')
+        end
+
+        def find_by(*args)
+          unless subclass_column_names.include?(args.first.keys.first)
+            args = [{"#{superclass_table_name}.#{args.first.keys.first.to_s}": args.first.values.first}]
+          end
+          super
+        end
+
+        def where(opts = :chain, *rest)
+          unless subclass_column_names.include?(opts.keys.first)
+            opts = {"#{superclass_table_name}.#{opts.keys.first.to_s}": opts.values.first}
+          end
+          super
+        end
+
+        private
+          def load_schema!
+            @columns_hash = superclass_columns_hash.merge(subclass_columns_hash)
+            @columns_hash.each do |name, column|
+              define_attribute(
+                name,
+                connection.lookup_cast_type_from_column(column),
+                default: column.default,
+                user_provided_default: false
+              )
+            end
+          end
+
+          def superclass_columns_hash
+            connection.schema_cache.columns_hash(superclass_table_name).except(*superclass_ignored_columns)
+          end
+
+          def superclass_column_names
+            superclass_columns_hash.keys
+          end
+
+          def subclass_columns_hash
+            connection.schema_cache.columns_hash(subclass_table_name).except(*subclass_ignored_columns)
+          end
+
+          def subclass_column_names
+            subclass_columns_hash.keys
+          end
+
+          def superclass_ignored_columns
+            ["created_at", "updated_at"]
+          end
+
+          def subclass_ignored_columns
+            [foreign_key_name]
+          end
+      end #end of class_methods
+
+      # To save into two related tables while inserting.
+      def save(*args, &block)
+        _superclass_instance_for_rw = superclass_instance_for_rw
+        _subclass_instance_for_rw = subclass_instance_for_rw
+        ActiveRecord::Base.transaction do
+          _superclass_instance_for_rw.send(:create_or_update)
+          _subclass_instance_for_rw.send("#{foreign_key_name}=", _superclass_instance_for_rw.id)
+          _subclass_instance_for_rw.send(:create_or_update)
+        end
+        self.id = _subclass_instance_for_rw.id
+        _superclass_instance_for_rw.id.present? and _subclass_instance_for_rw.id.present?
+      rescue ActiveRecord::RecordInvalid
+        false
+      end
+
+      private
+        def superclass_instance_for_rw(*args, &block)
+          if foreign_key_value.present?
+            superclass_instance_for_rw = superclass_for_rw.find(foreign_key_value)
+            superclass_instance_for_rw.attributes = attributes.slice(*superclass_for_rw.column_names - [@primary_key])
+            superclass_instance_for_rw
+          else
+            superclass_for_rw.new(attributes.slice(*superclass_for_rw.column_names), &block)
+          end
+        end
+
+        def subclass_instance_for_rw(*args, &block)
+          if self.id.present?
+            subclass_instance_for_rw = subclass_for_rw.find(self.id)
+            subclass_instance_for_rw.attributes = attributes.except(*superclass_for_rw.column_names)
+            subclass_instance_for_rw
+          else
+            subclass_for_rw.new(attributes.except(*superclass_for_rw.column_names), &block)
+          end
+        end
+
+        def foreign_key_name
+          self.class.foreign_key_name
+        end
+
+        def foreign_key_value
+          return @foreign_key_value if @foreign_key_value.present?
+          return nil if self.id.nil?
+          @foreign_key = subclass_for_rw.find(self.id)&.send(foreign_key_name)
+        end
+
+        def foreign_key_value=(value)
+          @foreign_key_value = value
+        end
+
+        def superclass_for_rw
+          table_name = self.class.superclass_table_name
+          @superclass_for_rw || @superclass_for_rw = Class.new(ActiveRecord::Base) do
+            self.table_name = table_name
+          end
+        end
+
+        def subclass_for_rw
+          table_name = self.class.subclass_table_name
+          @subclass_for_rw || @subclass_for_rw = Class.new(ActiveRecord::Base) do
+            self.table_name = table_name
+          end
+        end
+    end
+  end
+end

data/lib/activerecord/cti/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module Cti
+    VERSION = '0.1.1'
+  end
+end

data/lib/tasks/activerecord/cti_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :activerecord_cti do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-cti
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- khata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.2.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveRecord-Cti is a library implemented Class Table Inheritance on
+  ActiveRecord. Class Table Inheritance (CTI) is useful under the circumstances that
+  an ActiveRecord object is in multiple positions or has multiple roles, and you want
+  to describe it's structure on the database. For Example, one person may be a player
+  and a coach in a soccer team.
+email:
+- hata_kentaro_es@tokushima-inc.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/activerecord/cti.rb
+- lib/activerecord/cti/base_class.rb
+- lib/activerecord/cti/railtie.rb
+- lib/activerecord/cti/sub_class.rb
+- lib/activerecord/cti/version.rb
+- lib/tasks/activerecord/cti_tasks.rake
+homepage: https://bs.tokushima-inc.jp/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveRecord-Cti is a library implemented Class Table Inheritance on ActiveRecord.
+test_files: []