trax_model 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aadee7f297ba78ffcf101d66d949fd921528e6aa
-  data.tar.gz: 31fc37ab41fbef66ac534734b9c34d223cdc71b7
+  metadata.gz: 72afe4ed91e48868ae5965523a0ece32221a2a42
+  data.tar.gz: 29e28997f27539058bf5a7e131d13cef8696608e
 SHA512:
-  metadata.gz: 135a818db486a91cace4e5787d3de8d7c1685247df963f861af5fc6aabbe0054e0def7f60f66d6bbca2c2cea6f2b690320d5da98fecdf292bfff72a11e913e4c
-  data.tar.gz: d9df19307c0741ac126a5c9a574715f393e4a1947096a1cb17114466d649720ea5f208e8eba65a6dcfdeb815ba37d7474a2cb959df3343a09ec3406ff4bfc4dd
+  metadata.gz: f4e3d8332d31fbabdca1318bf3a504e775e9c1b080df5cd7de76150bdcf24b508786c5c5d2767da8628f933b32b9cb980fe54a9dcb659701a653c0ee3b57b919
+  data.tar.gz: 06619d0356c3b86ffd769c4410be2e59e40838ca6d0af1a60e8c88f40d113e0775dd95c3a6caf4499c29b8fa800bbc94efd0684e5434bdcc5e5e4e0a81f091a1

data/README.md

@@ -1,6 +1,158 @@
-# TraxModel
+# Trax Model
+
+A composeable companion to active record models. Just include ::Trax::Model and you're off to the races.
+
+### UUIDS
+
+Supports uuid prefixes, and recommends next uuid prefix based on all uuid prefixes defined
+in system -- Makes your uuids more discoverable and allows you to identify the model
+itself just by the uuid, or do even cooler stuff programatically
+
+### ITS IMPERATIVE THAT YOU DO NOT CHANGE YOUR UUID PREFIXES AFTER CREATING RECORDS
+
+Sorry for yelling, but the point is, that will throw all the mapping stuff out of whack.
+Don't do it. Treat it as a single point of truth for identifying the model in your system.
+
+### UUID Prefixes should be treated like an enum, values are ordered like
+
+[0a, 0b, 0c...], from 0-9a-f, then back down in reverse, i.e.
+
+[a0, a1, a2], the alpha first prefixes are a higher sort order in the list
+
+### Why?
+
+This library is compatible with postgres's uuid, hexidecimal type. This enables
+you to use the library to generate uuids on the fly, in your application code,
+WITHOUT relying on primary key integer increment, which in case you haven't yet realized,
+is the wild west once you are processing enough writes that you start seeing duplicate
+primary key errors.
+
+### Can't there still be conflicts?
+
+Yes but the odds are astronomically small. From what I understand, probably you are more
+likely to get struck by lightning than see that error. With that said, I am overwriting
+the first 2 generated characters of the uuid function with a fixed character string, which
+may affect the stats slightly, however Im not even sure if thats in a negative manner,
+based on the fact that it splits the likeleyhood of a collision per record type
+
+I.E.
+
+``` ruby
+class Product < ActiveRecord::Base
+  include ::Trax::Model
+  defaults :uuid_prefix => "0a"
+end
+```
+
+``` ruby
+Product.new
+
+=> #<Product id: nil, name: nil, category_id: nil, user_id: nil, price: nil, in_stock_quantity: nil, on_order_quantity: nil, active: nil, uuid: "0a97ad3e-1673-41f3-b356-d62dd53629d8", created_at: nil, updated_at: nil>
+```
+
+### Get next available prefix, useful when setting models up
+
+``` ruby
+bx rails c
+::Trax::Model::Registry.next_prefix
+=> "1a"
+```
+
+But wait theires more!
+
+### UUID utility methods
+
+``` ruby
+product_uuid = Product.first.uuid
+=> "0a97ad3e-1673-41f3-b356-d62dd53629d8"
+
+product_uuid.record_type
+=> Product
+product_uuid.record
+```
+
+will return the product instance
+
+Which opens up quite a few possibilites via the newfound discoverability of your uuids...
+
+# MTI (Multiple Table Inheritance)
+
+### Note: you must use Trax UUIDS w/ prefixes to use this feature (as we map each entity to its specific table, via the prefixed uuid.
+
+Going to be a very brief documentation but:
+
+### Set up MTI structure like this:
+```
+models/post.rb (your entity model)
+models/post_types/abstract.rb (abstract, inherit from this)
+models/post_types/entity.rb
+models/post_types/video.rb
+models/post_types/text.rb
+models/post_types/audio.rb
+```
+
+Post is your entity class, entity is essentially a flat table which contains a list of
+any common attributes, as well as the ids for each of your MTI data models. The beauty
+of this, is that since Trax model uuids tell us what type the record is, we don't
+need to use STI, or have a type column to determine the type of the record.
+
+Basically, the entity model when loaded, will eager load the real model. If the real model is created, updated, or destroyed, a callback will ensure that the corresponding entity record is kept in sync.
+
+``` ruby
+module Blog
+  class Post < ActiveRecord::Base
+    include ::Trax::Model::MTI::Entity
+
+    mti_namespace ::Blog::Posts
+  end
+end
+
+#no database table to this class as its abstract.
+module Blog
+  module Posts
+    class Abstract < ::ActiveRecord::Base
+      # following line sets abstract_class = true when including module
+      include ::Trax::Model::MTI::Abstract
+
+      entity_model :class_name => "Blog::Post"
+
+      ### Define your base inherited logic / methods here ###
+
+      belongs_to :user_id
+      belongs_to :category_id
+
+      validates :user_id
+      validates :category_id
+    end
+  end
+end
+
+module Blog
+  module Posts
+    class Video < ::Blog::Posts::Abstract
+
+    end
+  end
+end
+```
+
+### MTI VS STI
+
+The main advantages of Multiple Table Inheritance versus Single Table inheritance I see are:
+
+1) Table size. As databases grow, vertically adding more length to traverse the table will continue to get slower. One way to mitigate this issue would be to split up your table into multiple horizontal tables, if it makes sense for your data structure to do so (i.e. like above)
+
+2) STI will get out of proportion likely. I.e. if 90% of your posts are text posts, then when you are looking for a video post, you are to some degree being slowed down by the video posts in your table. (or at least at some point when you reach past xxxxxx number of records)
+
+3) Further on that note, only storing what you need for each individual subset of your data, on that particular subset. I.e. if video post has a video_url attribute, but none of the other post types have that, it will keep holes out of your data tables since video_url is only on the video_posts table.
+
+4) Real separation at the data level of non common attributes, so you dont have to write safeguards in child classes to make sure that a value didnt slip into a field or whatever, because each child class has its own individual interpretation of the schema.
+
+The main disadvantages are:
+
+1) No shared view between child types. I.E. thats what the MTI entity is for. (want to find all blog posts? You cant unless you select a type first, or are using this gem, or a postgres view or something else)
+2) More difficult to setup since each child table needs its own table.
 
-TODO: Write a gem description
 
 ## Installation
 

data/lib/trax.rb

@@ -1,4 +1,6 @@
+require 'trax/core'
 require 'trax/model'
+
 module Trax
 
 end

data/lib/trax/model.rb

@@ -21,6 +21,7 @@ module Trax
     autoload :UUIDPrefix
     autoload :UniqueId
     autoload :Matchable
+    autoload :MTI
     autoload :Validators
 
     include ::Trax::Model::Matchable
@@ -34,7 +35,6 @@ module Trax
       register_trax_models(self)
     end
 
-
     module ClassMethods
       delegate :register_trax_model, :to => "::Trax::Model::Registry"
       delegate :[], :to => :find

data/lib/trax/model/mti.rb

@@ -0,0 +1,11 @@
+module Trax
+  module Model
+    module MTI
+      extend ::ActiveSupport::Autoload
+
+      autoload :Abstract
+      autoload :Entity
+      autoload :Namespace
+    end
+  end
+end

data/lib/trax/model/mti/abstract.rb

@@ -0,0 +1,62 @@
+module Trax
+  module Model
+    module MTI
+      module Abstract
+        extend ::ActiveSupport::Concern
+
+        included do
+          class_attribute :mti_config
+
+          self.abstract_class = true
+          self.mti_config = ::Hashie::Mash.new(:foreign_key => :id)
+
+          scope :records, lambda{
+            map(&:entity)
+          }
+        end
+
+        module ClassMethods
+          def inherited(subklass)
+            super(subklass)
+
+            subklass.after_create do |record|
+              entity_model = mti_config[:class_name].constantize.new
+
+              record.attributes.each_pair do |k,v|
+                entity_model.__send__("#{k}=", v) if entity_model.respond_to?(k)
+              end
+
+              entity_model.save
+            end
+
+            subklass.after_update do |record|
+              entity_model = record.entity
+
+              if record.changed.any?
+                record.changes.each_pair do |k,v|
+                  entity_model.__send__("#{k}=", v[1]) if entity.respond_to?(:"#{k}")
+                end
+              end
+
+              entity_model.save if entity_model.changed.any?
+            end
+
+            subklass.after_destroy do |record|
+              entity_model = record.entity
+
+              entity_model.destroy
+            end
+          end
+
+          def entity_model(options)
+            valid_options = options.assert_valid_keys(:class_name, :foreign_key)
+            mti_config.merge!(valid_options)
+
+            self.has_one(:entity, mti_config.symbolize_keys)
+            self.accepts_nested_attributes_for(:entity)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/mti/entity.rb

@@ -0,0 +1,63 @@
+module Trax
+  module Model
+    module MTI
+      module Entity
+        extend ::ActiveSupport::Concern
+
+        included do
+          class_attribute :_mti_namespace
+
+          scope :records, lambda{
+            map(&:entity)
+          }
+        end
+
+        def model_type
+          @model_type ||= uuid.record_type
+        end
+
+        def model_type_key
+          :"#{model_type.name.demodulize.underscore}_entity"
+        end
+
+        def model
+          @model ||= __send__(model_type_key)
+        end
+
+        def uuid
+          @uuid ||= self[:id].uuid
+        end
+
+        module ClassMethods
+          def all
+            relation = super
+            entity_ids = relation.pluck(:id)
+            entity_types = entity_ids.map { |id| ::Trax::Model::UUID.new(id[0..1]) }
+                                     .map(&:record_type)
+                                     .flatten
+                                     .compact
+                                     .uniq
+
+            relation_names = entity_types.map{ |type| :"#{type.name.demodulize.underscore}_entity" }
+
+            relation.includes(relation_names).references(relation_names)
+          end
+
+          def mti_namespace(namespace)
+            _mti_namespace = (namespace.is_a?(String)) ? namespace.constantize : namespace
+
+            _mti_namespace.all.reject{|model| model.abstract_class }.each do |subclass|
+              key = :"#{subclass.name.demodulize.underscore}_entity"
+              has_one key, :class_name => subclass.name, :foreign_key => :id
+            end
+          end
+
+          def multiple_table_inheritance_namespace(namespace)
+            mti_namespace(namespace)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/mti/namespace.rb

@@ -0,0 +1,21 @@
+module Trax
+  module Model
+    module MTI
+      module Namespace
+        extend ::Trax::Core::EagerAutoloadNamespace
+
+        class << self
+          attr_reader :base_mti_model
+        end
+
+        def self.base_model(model)
+          @base_mti_model = model
+        end
+
+        def self.all
+          @all ||= base_mti_model.subclasses
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/registry.rb

@@ -52,7 +52,7 @@ module Trax
       end
 
       def self.uuid_map
-        @uuid_map ||= models.values.reject!{|model| !model.try(:uuid_prefix) }.inject(::Hashie::Mash.new) do |result, model|
+        models.values.reject{|model| model.try(:uuid_prefix) == nil }.inject(::Hashie::Mash.new) do |result, model|
           result[model.uuid_prefix] = model
           result
         end

data/lib/trax_model.rb

@@ -1,4 +1,4 @@
-require 'trax'
+require_relative './trax'
 
 module TraxModel
 end

data/lib/trax_model/version.rb

@@ -1,3 +1,3 @@
 module TraxModel
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/trax_model.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trax_core"
+  spec.add_dependency "trax_core", "~> 0.0.3"
   spec.add_dependency "default_value_for", "~> 3.0.0"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "bundler", "~> 1.6"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: trax_model
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-04 00:00:00.000000000 Z
+date: 2014-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trax_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: default_value_for
   requirement: !ruby/object:Gem::Requirement
@@ -268,6 +268,10 @@ files:
 - lib/trax/model/config.rb
 - lib/trax/model/freezable.rb
 - lib/trax/model/matchable.rb
+- lib/trax/model/mti.rb
+- lib/trax/model/mti/abstract.rb
+- lib/trax/model/mti/entity.rb
+- lib/trax/model/mti/namespace.rb
 - lib/trax/model/registry.rb
 - lib/trax/model/unique_id.rb
 - lib/trax/model/uuid.rb
@@ -317,7 +321,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Higher level ActiveRecord models for rails