trax_model 0.0.99 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aff3b6b4389df830349e17d6b8ed2a378effd6af
-  data.tar.gz: c2e220e45e53c87812eabf18c772db0067bd9f90
+  metadata.gz: ff781e2ed15ed9b8de74a0bc0524c36f1dff35f1
+  data.tar.gz: 310c34411bca3ed6e975a68f65dfe5dd7b0d3a4c
 SHA512:
-  metadata.gz: 6c808f53684e7ed77a9509597cd2d8c4b11d52313f6e7246de544aa54db24d83695a7780331afa6626c32f8552e6c8a786132e0e7226347b56c43247d70c5341
-  data.tar.gz: 91bcf1d6bf4f70155ac262f58f82b38fc15aff0dca066cccc901d93028c1b24cb739c0f582e6575354e264d21afecb10c92eb4368ae90c9382d0cf70a7b47fb8
+  metadata.gz: 883b1cb879b34e218a1687aeb9a315154622b90b4b31de104278e7df4348eb630f8a1b3ebbfd865b202aa4cf93415092635c751a6ef1d30d2922627445e46d72
+  data.tar.gz: d64469203fda20f16669269aab3d462f3060f317ef684e2ad7c67cde6b5d1644b4cf0f47113c3a04c31083f15bc472795b15aa013e6de3ad4be5517bdebca3c7

data/Rakefile

@@ -1,2 +1 @@
 require "bundler/gem_tasks"
-

data/lib/trax/model.rb

@@ -22,7 +22,9 @@ module Trax
     extend ::ActiveSupport::Autoload
 
     autoload :Attributes
+    autoload :CacheKey
     autoload :Config
+    autoload :Concerns
     autoload :CoreExtensions
     autoload :ExtensionsFor
     autoload :Errors
@@ -42,6 +44,7 @@ module Trax
     define_configuration_options! do
       option :auto_include, :default => false
       option :auto_include_mixins, :default => []
+      option :cache, :default => ::ActiveSupport::Cache::MemoryStore.new
     end
 
     #like reverse merge, only assigns attributes which have not yet been assigned
@@ -64,11 +67,23 @@ module Trax
       mixin_registry[mixin_key] = mixin_klass
     end
 
+    def self.cache
+      ::Trax::Model.config.cache
+    end
+
+    def self.cache=(cache_store)
+      ::Trax::Model.configure do |config|
+        config.cache = cache_store
+      end
+    end
+
     def self.root
       ::Pathname.new(::File.path(__FILE__))
     end
 
     def self.eager_autoload_mixins!
+      ::Trax::Model::Mixins::CachedFindBy
+      ::Trax::Model::Mixins::CachedRelations
       ::Trax::Model::Mixins::FieldScopes
       ::Trax::Model::Mixins::Freezable
       ::Trax::Model::Mixins::IdScopes
@@ -104,7 +119,7 @@ module Trax
         raise ::Trax::Model::Errors::MixinNotRegistered.new(
           model: self.name,
           mixin: key
-        )  unless ::Trax::Model.mixin_registry.key?(key)
+        ) unless ::Trax::Model.mixin_registry.key?(key)
 
         mixin_module = ::Trax::Model.mixin_registry[key]
         self.registered_mixins[key] = mixin_module

data/lib/trax/model/attributes/dsl.rb

@@ -13,18 +13,6 @@ module Trax
             self.instance_variable_set("@_attribute_definitions_block", block)
           end
 
-          #recursively search direct parent classes for attribute definitions, so we can fully support
-          #inheritance
-          def fetch_attribute_definitions_in_chain(_attribute_definitions_blocks = [], klass=nil)
-            _attribute_definitions_blocks.push(klass.instance_variable_get("@_attribute_definitions_block")) if klass && klass.instance_variable_defined?("@_attribute_definitions_block")
-
-            if klass && klass.superclass != ::ActiveRecord::Base
-              return fetch_attribute_definitions_in_chain(_attribute_definitions_blocks, klass.superclass)
-            else
-              return _attribute_definitions_blocks.compact
-            end
-          end
-
           def fields_module
             @fields_module ||= begin
               module_name = "#{self.name}::Fields"

data/lib/trax/model/attributes/types/enum.rb

@@ -7,8 +7,8 @@ module Trax
           def self.define_attribute(klass, attribute_name, **options, &block)
             klass_name = "#{klass.fields_module.name.underscore}/#{attribute_name}".camelize
 
-            attribute_klass = if options.key?(:extend)
-              _klass_prototype = options[:extend].is_a?(::String) ? options[:extend].safe_constantize : options[:extend]
+            attribute_klass = if options.key?(:extends)
+              _klass_prototype = options[:extends].is_a?(::String) ? options[:extends].safe_constantize : options[:extends]
               _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => klass, &block)
               _klass
             else

data/lib/trax/model/attributes/types/string.rb

@@ -17,7 +17,7 @@ module Trax
 
           class Value < ::Trax::Model::Attributes::Value
             include ::Trax::Model::ExtensionsFor::String
-            
+
             def self.type; :string end;
           end
 

data/lib/trax/model/attributes/types/struct.rb

@@ -7,8 +7,8 @@ module Trax
         class Struct < ::Trax::Model::Attributes::Type
           def self.define_attribute(klass, attribute_name, **options, &block)
             klass_name = "#{klass.fields_module.name.underscore}/#{attribute_name}".camelize
-            attribute_klass = if options.key?(:extend)
-              _klass_prototype = options[:extend].is_a?(::String) ? options[:extend].safe_constantize : options[:extend]
+            attribute_klass = if options.key?(:extends)
+              _klass_prototype = options[:extends].is_a?(::String) ? options[:extends].safe_constantize : options[:extends]
               _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => klass, &block)
               _klass.include(::Trax::Model::ExtensionsFor::Struct)
               _klass
@@ -82,8 +82,6 @@ module Trax
               end
 
               model.delegate(getter_method, :to => attribute_name)
-
-              model.attribute_names << _property.to_s unless model.attribute_names.include?(_property.to_s)
             end
           end
         end

data/lib/trax/model/cache_key.rb

@@ -0,0 +1,20 @@
+module Trax
+  module Model
+    class CacheKey < SimpleDelegator
+      CACHE_OPTION_KEYS = [ :expires_in ].freeze
+
+      attr_reader :options, :search_params
+
+      def initialize(*args, **params)
+        params.symbolize_keys!
+        @options = params.extract!(*CACHE_OPTION_KEYS)
+        @search_params = params
+        @obj = ::Set[*args.sort, params.sort].flatten.to_a
+      end
+
+      def __getobj__
+        @obj
+      end
+    end
+  end
+end

data/lib/trax/model/errors.rb

@@ -17,7 +17,7 @@ module Trax
         argument :model
 
         message {
-          "#{model} tried to load mixin: #{mixin}, whichdoes not exist in " \
+          "#{model} tried to load mixin: #{mixin}, which does not exist in " \
           "registry. Registered mixins were #{::Trax::Model.mixin_registry.keys.join(', ')} \n"
         }
       end

data/lib/trax/model/mixins.rb

@@ -3,6 +3,8 @@ module Trax
     module Mixins
       extend ::ActiveSupport::Autoload
 
+      autoload :CachedFindBy
+      autoload :CachedRelations
       autoload :FieldScopes
       autoload :Freezable
       autoload :IdScopes

data/lib/trax/model/mixins/cached_find_by.rb

@@ -0,0 +1,39 @@
+module Trax
+  module Model
+    module Mixins
+      module CachedFindBy
+        extend ::Trax::Model::Mixin
+
+        module ClassMethods
+          def cached_find_by(**params)
+            cache_key = ::Trax::Model::CacheKey.new(self.name.underscore.pluralize, '.find_by', **params)
+
+            ::Trax::Model.cache.fetch(cache_key, cache_key.options) do
+              self.find_by(cache_key.search_params)
+            end
+          end
+
+          def cached_where(**params)
+            cache_key = ::Trax::Model::CacheKey.new(self.name.underscore.pluralize, '.where', **params)
+
+            ::Trax::Model.cache.fetch(cache_key, cache_key.options) do
+              self.where(cache_key.search_params).to_a
+            end
+          end
+
+          def clear_cached_find_by(**params)
+            cache_key = ::Trax::Model::CacheKey.new(self.name.underscore.pluralize, '.find_by', **params)
+
+            ::Trax::Model.cache.delete(cache_key)
+          end
+
+          def clear_cached_where(**params)
+            cache_key = ::Trax::Model::CacheKey.new(self.name.underscore.pluralize, '.where', **params)
+
+            ::Trax::Model.cache.delete(cache_key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/mixins/cached_relations.rb

@@ -0,0 +1,63 @@
+module Trax
+  module Model
+    module Mixins
+      module CachedRelations
+        extend ::Trax::Model::Mixin
+
+        include ::Trax::Model::Mixins::CachedFindBy
+
+        module ClassMethods
+          def cached_belongs_to(relation_name, **options)
+            define_method("cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = (relation.foreign_key || "#{relation.name}_id").to_sym
+              params = { :id => self.__send__(foreign_key) }.merge(options)
+              relation.klass.cached_find_by(**params)
+            end
+
+            define_method("clear_cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = (relation.foreign_key || :"#{relation.name}_id").to_sym
+              params = { :id => self.__send__(foreign_key) }.merge(options)
+              relation.klass.clear_cached_find_by(**params)
+            end
+          end
+
+          def cached_has_one(relation_name, **options)
+            define_method("cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = (relation.foreign_key || "#{relation.name}_id").to_sym
+              params = { foreign_key => self.__send__(:id) }.merge(options)
+              params.merge!(relation.klass.instance_eval(&relation.scope).where_values_hash.symbolize_keys) if relation.scope
+              relation.klass.cached_find_by(**params)
+            end
+
+            define_method("clear_cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = (relation.foreign_key || :"#{relation.name}_id").to_sym
+              params = { foreign_key => self.__send__(:id) }.merge(options)
+              params.merge!(relation.klass.instance_eval(&relation.scope).where_values_hash.symbolize_keys) if relation.scope
+              relation.klass.clear_cached_find_by(**params)
+            end
+          end
+
+          def cached_has_many(relation_name, **options)
+            define_method("cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = :"#{relation.foreign_key}"
+              params = {foreign_key => self.__send__(:id)}.merge(options)
+              relation.klass.cached_where(**params)
+            end
+
+            define_method("clear_cached_#{relation_name}") do
+              relation = self.class.reflect_on_association(relation_name)
+              foreign_key = :"#{relation.foreign_key}"
+              params = {foreign_key => self.__send__(:id)}.merge(options)
+              relation.klass.clear_cached_where(**params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax_model/version.rb

@@ -1,3 +1,3 @@
 module TraxModel
-  VERSION = '0.0.99'
+  VERSION = '0.1.0'
 end

data/spec/db/schema/default_tables.rb

@@ -1,10 +1,29 @@
 DEFAULT_TABLES = Proc.new do
+  create_table "subscribers", :force => true do |t|
+    t.string   "name"
+    t.string   "uuid"
+    t.datetime "created_at",        :null => false
+    t.datetime "updated_at",        :null => false
+  end
+
+  create_table "manufacturers", :force => true do |t|
+    t.string   "name"
+    t.string   "url"
+    t.string   "uuid"
+    t.integer  "subscriber_id"
+    t.datetime "created_at",        :null => false
+    t.datetime "updated_at",        :null => false
+  end
+
   create_table "vehicles", :force => true do |t|
+    t.string   "name"
     t.string   "type"
     t.integer  "kind"
     t.integer  "make"
     t.integer  "model"
     t.string   "uuid"
+    t.integer  "cost"
+    t.integer  "manufacturer_id"
     t.datetime "created_at",        :null => false
     t.datetime "updated_at",        :null => false
   end
@@ -41,6 +60,8 @@ DEFAULT_TABLES = Proc.new do
     t.string  "subdomain"
     t.string  "website"
     t.integer  "status"
+    t.integer  "subscriber_id"
+    t.string   "name"
     t.datetime "created_at",        :null => false
     t.datetime "updated_at",        :null => false
   end
@@ -55,6 +76,25 @@ DEFAULT_TABLES = Proc.new do
   create_table "people", :force => true do |t|
     t.string "name"
     t.string "uuid"
+    t.integer "vehicle_id"
+    t.datetime "created_at",        :null => false
+    t.datetime "updated_at",        :null => false
+  end
+
+  create_table "users", :force => true do |t|
+    t.string "name"
+    t.string "uuid"
+    t.integer "role"
+    t.integer "subscriber_id"
+    t.datetime "created_at",        :null => false
+    t.datetime "updated_at",        :null => false
+  end
+
+  create_table "animals", :force => true do |t|
+    t.string "name"
+    t.string "uuid"
+    t.string "type"
+    t.string "characteristics" # `string` is a workaround for lack of jsonb support in sqlite
     t.datetime "created_at",        :null => false
     t.datetime "updated_at",        :null => false
   end

data/spec/spec_helper.rb

@@ -5,6 +5,8 @@ require 'simplecov'
 require 'trax_model'
 require 'rails'
 require 'active_record'
+::Rails.cache = ::ActiveSupport::Cache::MemoryStore.new
+::Trax::Model.cache = ::Rails.cache
 
 SimpleCov.start do
   add_filter '/spec/'

data/spec/support/models.rb

@@ -14,15 +14,6 @@ end
 if ENV["DB"] == "postgres"
   require_relative 'pg/models'
 end
-#
-# class Blueprint < ::Trax::Core::Blueprint
-#   class Vehicle < ::Trax::Core::Blueprint
-#     enum :kind do
-#       define :car, 1, :type => "Vehicle::Car"
-#       define :truck, 2, :type => "Vehicle::Truck"
-#     end
-#   end
-# end
 
 class Product < ::ActiveRecord::Base
   include ::Trax::Model
@@ -35,7 +26,6 @@ class Product < ::ActiveRecord::Base
 
   define_attributes do
     string :name
-    # float :price
 
     integer :in_stock_quantity
     integer :out_of_stock_quantity
@@ -76,18 +66,65 @@ module Products
   end
 end
 
+class Subscriber < ::ActiveRecord::Base
+  include ::Trax::Model
+  include ::Trax::Model::Attributes::Dsl
+
+  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "4f" },
+         :cached_find_by => true,
+         :cached_relations => true
+
+  has_many :manufacturers, :class_name => "Manufacturer"
+  cached_has_many :manufacturers
+
+  has_one :admin_user, -> { by_role(:admin) }, :class_name => "User", :foreign_key => :subscriber_id
+  cached_has_one :admin_user
+  has_one :widget
+  cached_has_one :widget
+end
+
+class Manufacturer < ::ActiveRecord::Base
+  include ::Trax::Model
+  include ::Trax::Model::Attributes::Dsl
+
+  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "3d" },
+         :cached_find_by => true,
+         :cached_relations => true
+
+  has_many :vehicles
+  def cached_vehicles
+    ::Vehicle.cached_where(:manufacturer_id => self.id)
+  end
+
+  belongs_to :subscriber
+  cached_belongs_to :subscriber
+end
+
 class Vehicle < ::ActiveRecord::Base
   include ::Trax::Model
   include ::Trax::Model::Attributes::Dsl
 
   mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "9c" },
-         :sti_enum  => true
+         :sti_enum  => true,
+         :cached_find_by => true
+
 
   define_attributes do
     enum :kind do
       define :car, 1, :type => "Vehicle::Car"
       define :truck, 2, :type => "Vehicle::Truck"
     end
+
+    integer :cost
+  end
+
+  def subscriber_id
+    self.manufacturer.subscriber_id
+  end
+
+  belongs_to :manufacturer
+  def cached_manufacturer
+    ::Manufacturer.cached_find_by(:id => self.manufacturer_id)
   end
 
   class Car < ::Vehicle
@@ -100,14 +137,15 @@ end
 class Widget < ::ActiveRecord::Base
   include ::Trax::Model
 
-  mixins :unique_id => {
-    :uuid_column => "uuid",
-    :uuid_prefix => "2a"
-  }
+  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "2a" },
+         :cached_relations => true
 
   validates :subdomain, :subdomain => true, :allow_nil => true
   validates :email_address, :email => true, :allow_nil => true
   validates :website, :url => true, :allow_nil => true
+
+  belongs_to :subscriber
+  cached_belongs_to :subscriber
 end
 
 class Message < ::ActiveRecord::Base
@@ -141,7 +179,13 @@ end
 class Person < ::ActiveRecord::Base
   include ::Trax::Model
 
-  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "5a" }
+  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "5a" },
+         :cached_find_by => true
+
+  belongs_to :vehicle
+  def cached_vehicle
+    ::Vehicle.cached_find_by(:id => self.vehicle_id)
+  end
 end
 
 class StoreCategory < ::Trax::Core::Types::Struct
@@ -153,3 +197,36 @@ class StoreCategory < ::Trax::Core::Types::Struct
     string :keywords
   end
 end
+
+class User < ::ActiveRecord::Base
+  include ::Trax::Model
+  include ::Trax::Model::Attributes::Dsl
+
+  mixins :unique_id => { :uuid_column => "uuid", :uuid_prefix => "3e" },
+         :cached_find_by => true,
+         :cached_relations => true
+
+  define_attributes do
+    enum :role, :default => :staff do
+      define :staff, 1
+      define :admin, 2
+      define :billing, 3
+    end
+  end
+end
+
+class Animal < ::ActiveRecord::Base
+  include ::Trax::Model
+  include ::Trax::Model::Attributes::Dsl
+end
+
+class Mammal < ::Animal
+  include ::Trax::Model
+  include ::Trax::Model::Attributes::Dsl
+
+  define_attributes do
+    struct :characteristics, :model_accessors => true do
+      string :fun_facts
+    end
+  end
+end

data/spec/support/pg/models.rb

@@ -119,7 +119,7 @@ module Ecommerce
         string :name, :default => "Some Shoe Name"
         boolean :active, :default => true
 
-        struct :custom_fields, :extend => ::Ecommerce::Product::Fields::CustomFields do
+        struct :custom_fields, :extends => ::Ecommerce::Product::Fields::CustomFields do
           string :primary_utility, :default => "Skateboarding"
           string :sole_material
           boolean :has_shoelaces

data/spec/trax/model/attributes/types/struct_spec.rb

@@ -16,12 +16,6 @@ describe ::Trax::Model::Attributes::Types::Struct, :postgres => true do
         end
       }
 
-      it {
-        ::Ecommerce::ShippingAttributes.fields[:specifics].properties.each do |_property|
-          expect(subject.class.attribute_names).to include(_property.to_s)
-        end
-      }
-
       context "initializing model and setting delegated attributes directly", :delegated_attributes =>  { :cost => 5, :tax => 5, :delivery_time => "5 days" } do
         self::DELEGATED_ATTRIBUTES = { :cost => 5, :tax => 5, :delivery_time => "5 days" }
 

data/spec/trax/model/cache_key_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ::Trax::Model::CacheKey do
+  subject{ described_class }
+
+  context "cache key" do
+    let(:fake_id) { 1 }
+    let(:expires) { 2.hours }
+    let(:cache_options) { {:expires_in => expires } }
+    subject { ::Trax::Model::CacheKey.new("posts", :id => fake_id, :expires_in => expires) }
+    it { expect(subject.first).to eq "posts" }
+    it { expect(subject.options).to eq cache_options }
+  end
+end

data/spec/trax/model/mixins/cached_find_by_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe ::Trax::Model::Mixins::CachedFindBy do
+  before(:all) do
+    ::ActiveRecord::Base.logger = ::Logger.new(::STDOUT)
+  end
+
+  before { ::Vehicle.destroy_all }
+  before { ::Manufacturer.destroy_all }
+  before { ::Subscriber.destroy_all }
+  before { ::Person.destroy_all }
+  before { ::Trax::Model.cache.clear }
+
+  let(:subscriber) { ::Subscriber.create(:name => "automatch_usa") }
+  let(:subscriber_2) { ::Subscriber.create(:name => "larryhmiller") }
+
+  let(:ford) { ::Manufacturer.create(:name => "ford", :url => "ford.com", :subscriber_id => subscriber.id) }
+  let(:toyota) { ::Manufacturer.create(:name => "toyota", :url => "toyota.com", :subscriber_id => subscriber_2.id) }
+  let(:vehicle_1) { ::Vehicle.create(:kind => :car, :manufacturer => ford, :cost => 20_000, :name => "pinto") }
+  let(:vehicle_2) { ::Vehicle.create(:kind => :truck, :manufacturer => ford, :cost => 20_000, :name => "f150")}
+  let(:vehicle_3) { ::Vehicle.create(:kind => :truck, :manufacturer => toyota, :cost => 15_000) }
+  let(:person_1) { ::Person.create(:name => "jason", :vehicle_id => vehicle_1.id) }
+  let(:person_2) { ::Person.create(:name => "steve", :vehicle_id => vehicle_1.id) }
+
+  subject { ford }
+
+  context ".cached_find_by" do
+    before do
+      person_1
+      person_2
+      subject
+    end
+
+    it "cache key exists" do
+      ::Manufacturer.cached_find_by(:id => vehicle_1.manufacturer_id)
+
+      cache_key = ::Trax::Model::CacheKey.new('manufacturers', '.find_by', {:id => vehicle_1.manufacturer_id})
+      expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+    end
+
+    it "caches relation" do
+      vehicle_1
+      expect(vehicle_1.cached_manufacturer.name).to eq subject.name
+
+      man = ::Manufacturer.find(vehicle_1.cached_manufacturer.id)
+      man.update_attributes(:name => "whatever")
+      vehicle_1.reload
+      expect(vehicle_1.cached_manufacturer.name).to eq "ford"
+    end
+
+    it "cache can be cleared by params" do
+      vehicle_1
+      expect(vehicle_1.cached_manufacturer.name).to eq subject.name
+
+      man = ::Manufacturer.find(vehicle_1.cached_manufacturer.id)
+      man.update_attributes(:name => "whatever")
+      vehicle_1.reload
+      expect(vehicle_1.cached_manufacturer.name).to eq "ford"
+      ::Manufacturer.clear_cached_find_by(:id => man.id)
+      expect(vehicle_1.cached_manufacturer.name).to eq "whatever"
+    end
+  end
+
+  context ".cached_where" do
+    subject { ::Vehicle.cached_where(:manufacturer_id => ford.id) }
+
+    before do
+      ford
+      vehicle_1
+      vehicle_2
+      subject
+    end
+
+    it "cache key exists" do
+      cache_key = ::Trax::Model::CacheKey.new('vehicles', '.where', {:manufacturer_id => ford.id})
+      expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+    end
+
+    it "caches result" do
+      expect(subject[0].name).to eq vehicle_1.name
+      vehicle_1.update_attributes(:name => "whatever")
+      vehicle_1.reload
+      expect(subject[0].name).to eq "pinto"
+    end
+
+    context ".clear_cached_where" do
+      it do
+        cache_key = ::Trax::Model::CacheKey.new('vehicles', '.where', {:manufacturer_id => ford.id})
+        expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+        ::Vehicle.clear_cached_where(cache_key.search_params)
+        expect(::Trax::Model.cache.exist?(cache_key)).to eq false
+      end
+    end
+  end
+end

data/spec/trax/model/mixins/cached_relations_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe ::Trax::Model::Mixins::CachedRelations do
+  before(:all) do
+    ::ActiveRecord::Base.logger = ::Logger.new(::STDOUT)
+  end
+
+  before { ::Vehicle.destroy_all }
+  before { ::Manufacturer.destroy_all }
+  before { ::Subscriber.destroy_all }
+  before { ::Person.destroy_all }
+  before { ::Trax::Model.cache.clear }
+
+  let(:subscriber) { ::Subscriber.create(:name => "automatch_usa") }
+
+  let(:ford) { ::Manufacturer.create(:name => "ford", :url => "ford.com", :subscriber_id => subscriber.id) }
+  let(:toyota) { ::Manufacturer.create(:name => "toyota", :url => "toyota.com", :subscriber_id => subscriber.id) }
+  let(:vehicle_1) { ::Vehicle.create(:kind => :car, :manufacturer => ford, :cost => 20_000, :name => "pinto") }
+  let(:vehicle_2) { ::Vehicle.create(:kind => :truck, :manufacturer => ford, :cost => 20_000, :name => "f150") }
+  let(:vehicle_3) { ::Vehicle.create(:kind => :truck, :manufacturer => toyota, :cost => 15_000) }
+
+  subject{ ford }
+
+  context ".cached_belongs_to" do
+    before do
+      subject.cached_subscriber
+    end
+
+    it "cache key exists" do
+      cache_key = ::Trax::Model::CacheKey.new('subscribers', '.find_by', {:id => subject.subscriber_id} )
+      expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+    end
+
+    it "caches relation" do
+      expect(subject.cached_subscriber.name).to eq subscriber.name
+      _subscriber = ::Subscriber.find(subscriber.id)
+      _subscriber.update_attributes(:name => 'whatever')
+      expect(subject.cached_subscriber.name).to eq subscriber.name
+    end
+
+    it "clears cached belongs to relation" do
+      expect(subject.cached_subscriber.name).to eq subscriber.name
+      _subscriber = ::Subscriber.find(subscriber.id)
+      _updated_subscriber_name = 'whatever'
+      _subscriber.update_attributes(:name => _updated_subscriber_name)
+      expect(subject.cached_subscriber.name).to eq subscriber.name
+      subject.clear_cached_subscriber
+      expect(subject.cached_subscriber.name).to eq _updated_subscriber_name
+    end
+  end
+
+  context ".cached_has_one" do
+    subject! { subscriber }
+    let!(:widget) { ::Widget.create(:name => "anything", :subscriber_id => subscriber.id) }
+    let!(:cached_widget) { subject.cached_widget }
+
+    it "cache key exists" do
+      cache_key = ::Trax::Model::CacheKey.new('widgets', '.find_by', {:subscriber_id => subject.id} )
+      expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+    end
+
+    it "caches relation" do
+      widget_name = widget.name
+      expect(cached_widget.name).to eq widget_name
+      _widget = ::Widget.find(cached_widget.id)
+      _widget.update_attributes(:name => "bob")
+      _widget.reload
+      expect(subject.cached_widget.name).to eq widget_name
+    end
+
+    it "clears cached has one relation" do
+      widget_name = widget.name
+      updated_widget_name = 'new_widget_name'
+      expect(cached_widget.name).to eq widget_name
+      _widget = ::Widget.find(cached_widget.id)
+      _widget.update_attributes(:name => updated_widget_name)
+      _widget.reload
+      expect(subject.cached_widget.name).to eq widget_name
+      subject.clear_cached_widget
+      expect(subject.cached_widget.name).to eq updated_widget_name
+    end
+
+    context "scoped by proc" do
+      subject! { subscriber }
+      let!(:admin_user) { ::User.create(:name => "milton", :role => :admin, :subscriber_id => subscriber.id) }
+      let!(:cached_admin_user) { subject.cached_admin_user }
+
+      it "cache key exists" do
+        cache_key = ::Trax::Model::CacheKey.new('users', '.find_by', {:subscriber_id => subject.id, :role => ::User::Fields::Role.new(:admin).to_i} )
+        expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+      end
+
+      it "caches relation" do
+        admin_user_name = admin_user.name
+        expect(cached_admin_user.name).to eq admin_user_name
+        _user = ::User.find(admin_user.id)
+        _user.update_attributes(:name => "bob")
+        _user.reload
+        expect(subject.cached_admin_user.name).to eq admin_user_name
+      end
+
+      it "clears cached has one relation" do
+        admin_user_name = admin_user.name
+        updated_admin_user_name = "bob"
+        expect(cached_admin_user.name).to eq admin_user_name
+        _user = ::User.find(admin_user.id)
+        _user.update_attributes(:name => updated_admin_user_name)
+        _user.reload
+        expect(subject.cached_admin_user.name).to eq admin_user_name
+        subject.clear_cached_admin_user
+        expect(subject.cached_admin_user.name).to eq updated_admin_user_name
+      end
+    end
+  end
+
+  context ".cached_has_many" do
+    before do
+      ford
+      toyota
+    end
+
+    subject!{ subscriber.cached_manufacturers }
+
+    it "cache key exists" do
+      cache_key = ::Trax::Model::CacheKey.new('manufacturers', '.where', {:subscriber_id => subscriber.id} )
+      expect(::Trax::Model.cache.exist?(cache_key)).to eq true
+    end
+
+    it "caches relation" do
+      expect(subject).to eq subscriber.manufacturers
+      first_manufacturer_name = subject.first.name
+
+      expect(subject.first.name).to eq subscriber.manufacturers.first.name
+      _manufacturer = ::Manufacturer.find(subject.first.id)
+      _manufacturer.update_attributes(:name => 'whatever')
+      expect(subject.first.name).to eq first_manufacturer_name
+    end
+
+    it "clears cached has many relation" do
+      expect(subject).to eq subscriber.manufacturers
+      first_manufacturer_name = subject.first.name
+      updated_manufacturer_name = 'whatever'
+      expect(subject.first.name).to eq subscriber.manufacturers.first.name
+      _manufacturer = ::Manufacturer.find(subject.first.id)
+      _manufacturer.update_attributes(:name => updated_manufacturer_name)
+      _manufacturer.reload
+      expect(subject.first.name).to eq first_manufacturer_name
+      subscriber.clear_cached_manufacturers
+      expect(subscriber.cached_manufacturers.detect{|m| m.id == _manufacturer.id}.name).to eq updated_manufacturer_name
+    end
+  end
+end

data/spec/trax/model_spec.rb

@@ -3,6 +3,30 @@ require 'spec_helper'
 describe ::Trax::Model do
   subject { ::Product }
 
-  its(:trax_registry_key) { should eq "product" }
+  its(:trax_registry_key) { is_expected.to eq "product" }
   it { subject.unique_id_config.uuid_prefix }
+
+  context "with model accessors for struct attribute" do
+    let(:name) { "platypus" }
+    subject { ::Animal.new(:name => name) }
+
+    it { expect(::Animal.fields.constants).to_not include(:Characteristics) }
+
+    context "inheriting model" do
+      let(:fun_facts) { "is most like edible" }
+      let(:characteristics) { {:fun_facts => fun_facts} }
+      subject { ::Mammal.new(:name => name, :characteristics => characteristics) }
+
+      it { expect(::Mammal.fields.constants).to include(:Characteristics) }
+
+      its(:"characteristics.fun_facts") { is_expected.to eq(fun_facts) }
+      it { expect(subject.characteristics.respond_to?(:fun_facts)).to eq(true) }
+
+      context "model accessors" do
+        its(:name) { is_expected.to eq(name) }
+        its(:fun_facts) { is_expected.to eq(fun_facts) }
+        it { expect(subject.respond_to?(:fun_facts)).to eq(true) }
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trax_model
 version: !ruby/object:Gem::Version
-  version: 0.0.99
+  version: 0.1.0
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-02 00:00:00.000000000 Z
+date: 2016-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trax_core
@@ -311,6 +311,7 @@ files:
 - lib/trax/model/attributes/types/struct.rb
 - lib/trax/model/attributes/types/uuid_array.rb
 - lib/trax/model/attributes/value.rb
+- lib/trax/model/cache_key.rb
 - lib/trax/model/core_extensions.rb
 - lib/trax/model/core_extensions/string.rb
 - lib/trax/model/errors.rb
@@ -334,6 +335,8 @@ files:
 - lib/trax/model/matchable.rb
 - lib/trax/model/mixin.rb
 - lib/trax/model/mixins.rb
+- lib/trax/model/mixins/cached_find_by.rb
+- lib/trax/model/mixins/cached_relations.rb
 - lib/trax/model/mixins/field_scopes.rb
 - lib/trax/model/mixins/freezable.rb
 - lib/trax/model/mixins/id_scopes.rb
@@ -369,6 +372,7 @@ files:
 - spec/trax/model/attributes/types/set_spec.rb
 - spec/trax/model/attributes/types/struct_spec.rb
 - spec/trax/model/attributes_spec.rb
+- spec/trax/model/cache_key_spec.rb
 - spec/trax/model/errors_spec.rb
 - spec/trax/model/extensions_for/boolean_spec.rb
 - spec/trax/model/extensions_for/numeric_spec.rb
@@ -376,6 +380,8 @@ files:
 - spec/trax/model/extensions_for/struct_spec.rb
 - spec/trax/model/extensions_for_spec.rb
 - spec/trax/model/matchable_spec.rb
+- spec/trax/model/mixins/cached_find_by_spec.rb
+- spec/trax/model/mixins/cached_relations_spec.rb
 - spec/trax/model/mixins/field_scopes_spec.rb
 - spec/trax/model/mixins/freezable_spec.rb
 - spec/trax/model/mixins/restorable_spec.rb
@@ -428,6 +434,7 @@ test_files:
 - spec/trax/model/attributes/types/set_spec.rb
 - spec/trax/model/attributes/types/struct_spec.rb
 - spec/trax/model/attributes_spec.rb
+- spec/trax/model/cache_key_spec.rb
 - spec/trax/model/errors_spec.rb
 - spec/trax/model/extensions_for/boolean_spec.rb
 - spec/trax/model/extensions_for/numeric_spec.rb
@@ -435,6 +442,8 @@ test_files:
 - spec/trax/model/extensions_for/struct_spec.rb
 - spec/trax/model/extensions_for_spec.rb
 - spec/trax/model/matchable_spec.rb
+- spec/trax/model/mixins/cached_find_by_spec.rb
+- spec/trax/model/mixins/cached_relations_spec.rb
 - spec/trax/model/mixins/field_scopes_spec.rb
 - spec/trax/model/mixins/freezable_spec.rb
 - spec/trax/model/mixins/restorable_spec.rb