cacheable_delegator 1.0.0 → 1.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTY0OTYzZmI1MjFmYmQ4YTMwZDk0MDNjMTFkNzZhYTAyNTMzMzJjYw==
+    NjBhNDAxOGI2NDljOWZiOTMwMjI2YmE1YTgyYjc0ZDdkNGMwMjE2MQ==
   data.tar.gz: !binary |-
-    YzgxYjBmZjVjMzUxMjEzMDA4NjY4ZjZjYTc2Nzk3OTRiMDI2YWFkMQ==
+    YmU2NGMwNmU2NzUwNDEzMzI5MGE4OWFlMjZhOTM4OTM5NTk5MGVjZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NDQ4YTI3Mjg0NzE0ZDk3NDI3NGZjMjA5MzMwMmI3NjM3MDFkYjNiYmVhMTYz
-    ZDA1Mzk2M2U2MDQ0OGJiNzcyMmIyNTk0OWM3ZDc3YTk2ZWRiMGE1MmVhNDI1
-    NTVhNzU2YjI2OTYyMmI4YzVmM2MwMzQ1OTg2ZTA1OTRiNWM4NDY=
+    NmU3ZjQ4NTM5MDNmYmFmZDNmOGYyZTdjOGZmYjViYTE5NzgyMjRkZDdmNmMy
+    ZDJlNDk4ODQxMjk0ZGZiNDgwYzUzYTc3MWJkNmNiZWFkZjcwYmIyN2M4MWUw
+    ZTUyYWQ2ZGE2Zjk3OGJkZTZjZGJhNjFiNGFjZWU2ZDgyZGVkNzk=
   data.tar.gz: !binary |-
-    NGRlZjEzODY2YWUxNGJmYzAwNzlkZmEyZDZkZmQzYzgyMzlkMGZhODc0OGEy
-    YzUzNmI5NDFmMzJiNGZhYWEwYTU5ZTViMTM3YmIzNWJkOTIzMmI3YWY3Mjk5
-    NGRlNjMwMjc0NzljYjZjM2IzYjliZjE4NTRjNWM2MjUzYTg4NWI=
+    OTgyYWUzMjJkMjY0MWY2Zjg3MjM3NDc1YzZlNGMwZjNlNTc4MWZkMzQyNTRk
+    ZGI3OWMxNjAxYmY5NGJjYzgwY2ZhOTA4NTY0YjFkYzhkM2Q2MzBhMGRjZGU0
+    NWExZThlNTM4MzY2NWFkMGIxNGRiZmRjYmUxMTMwNDE4MGNiZWE=

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/cacheable_delegator.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "cacheable_delegator"
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dan Nguyen"]
-  s.date = "2013-10-09"
+  s.date = "2013-10-27"
   s.description = "Create a cache model for your active records"
   s.email = "dansonguyen@gmail.com"
   s.extra_rdoc_files = [

data/lib/cacheable_delegator.rb

@@ -10,69 +10,136 @@ module CacheableDelegator
 
   included do 
     class_attribute :source_class
+    class_attribute :_custom_columns
   end
 
   module ClassMethods
 
-    def build_cache(source_obj)
-      att_hsh = self.value_column_names.inject({}) do |hsh, cname|
-        hsh[cname] = source_obj.send cname
-        hsh
+    # this method defines the relation to an existing ActiveModel
+    # it does not change the schema unless invoked with the bang!
+    def cache_and_delegate(klass, opts={}, &blk)
+      raise ArgumentError, "Must pass in a class, not a #{klass}" unless klass.is_a?(Class)
+      self.source_class = klass
+      belongs_to :source_record, class_name: self.source_class.to_s      
+
+      # This is why you have to define custom columns in the given block
+      # or after the call to cache and delegate
+
+      reset_custom_columns!
+      if block_given?
+        yield self
       end
 
-      obj = self.new(att_hsh)
-      obj.source_record = source_obj
 
-      obj
+      self.source_class
     end
 
-    def create_cache(obj)
-      c = build_cache(obj)
-      c.save 
 
-      c
+    # also runs upgrade_schema!
+    def cache_and_delegate!(*args)
+      cache_and_delegate(*args)
+
+      upgrade_schema!
     end
 
-    def cache_and_delegate(klass, opts={}, &blk)
-      raise ArgumentError, "Must pass in a class, not a #{klass}" unless klass.is_a?(Class)
-      self.source_class = klass
-      belongs_to :source_record, class_name: self.source_class.to_s      
 
-      self.source_class
+    # assumes @@source_class has been set
+    # 
+    # will call ActiveRecord::Base.serialize based on parameters passed in
+    # from 
+    def upgrade_schema!
+      # first we create a hash of source_columns
+      source_column_hash = source_columns.inject({}) do |shash, source_col|
+        source_col_atts = COL_ATTRIBUTES_TO_UPGRADE.inject({}){|hsh, att| hsh[att.to_sym] = source_col.send att; hsh  }
+        shash[source_col.name] = source_col_atts
+
+        shash
+      end
+
+      # then we merge it with custom_columns
+      columns_to_add = source_column_hash.merge(custom_columns)
+
+
+      # then we add them all in using .col method from active_record_inline_schema
+      columns_to_add.each_pair do |col_name, col_atts|
+        is_serialize = col_atts.delete(:serialize)
+        col col_name, col_atts
+
+        # by default, the client passes in serialize: true for plain serialization
+        #  and has the option to pass in serialize: Hash
+        if is_serialize
+          serialize_klass = (is_serialize == true) ? Object : is_serialize
+          serialize col_name, serialize_klass
+        end
+      end
+
+      self.auto_upgrade!( :gentle => true )
     end
 
 
+##################### source conveniences
+
+
     def source_columns
       source_class.columns.reject{|c| EXCLUDED_FIELDS.any?{|f| f.to_s == c.name }}
     end
 
+    def source_reflections
+      source_class.reflections
+    end
+
     # value columns are just columns that aren't in EXCLUDED_FIELDS
     def value_column_names
       self.column_names - EXCLUDED_FIELDS.map{|f| f.to_s}
     end
+  
+###### column adding
+
+    # Note: This must occur either during the .cache_and_delegate call
+    #   or after it. 
+    #   .cache_and_delegate *will* empty out custom_columns
+    # And implicitly, @@source_class has already been defined at this point
+    #   By default, raise an error if the column_name does not correspond
+    #    to an instance_method of @@source_class, unless the :bespoke option
+    #    is true
+    #
+    # opts: Hash of standard ActiveRecord::ConnectionAdapters::Column options
+    #       and several custom opts:
+    #         :bespoke => if true, then create this column on CachedRecord even
+    #               if its source_class does not have method_defined?(column_name)
+    #         :serialize => this is passed along to upgrade_schema!
+    #               which will then serialize the column via ActiveRecord.serialize
+    def add_custom_column(col_name, opts={})
+      col_str = col_name.to_s
+      is_bespoke = opts.delete :bespoke     
+      if !self.source_class.method_defined?(col_str) && is_bespoke != true
+        raise ArgumentError, "Since :bespoke != true, #{self.source_class} was expected to respond_to? :#{col_str}"
+      end
 
+      custom_columns[col_name.to_s] = opts
+    end
 
-    # assumes @@source_class has been set
-    def upgrade_schema!
-      source_columns.each do |source_col|
-        source_col_atts = COL_ATTRIBUTES_TO_UPGRADE.inject({}){|hsh, att| hsh[att.to_sym] = source_col.send att; hsh  }
-
-        col source_col.name, source_col_atts
-      end
+    def custom_columns
+      self._custom_columns ||= {}
+    end
 
-      self.auto_upgrade!( :gentle => true )
+    def reset_custom_columns!
+      self._custom_columns = {}
     end
+
   end
 
 
-  DELEGATING_REGEX = /^delegate_(\w+)/
 
 
+  DELEGATING_REGEX = /^delegate_(\w+)/
+
   def method_missing(foo, *args, &block)
     if foomatch = foo.to_s.match(DELEGATING_REGEX)
       foo = foomatch[1].to_s
-      
       self.source_record.send(foo, *args, &block)
+    elsif source_record.respond_to?(foo)
+      source_record.send(foo, *args, &block)
     else
       super
     end
@@ -81,10 +148,35 @@ module CacheableDelegator
   def respond_to?(meth, x=false)
     if meth.match(DELEGATING_REGEX)
       true
+    elsif source_record.respond_to?(meth)
+      true
     else
       super
     end
   end
 
+
+  ################### Builder methods
+  module ClassMethods
+    def build_cache(source_obj)
+      att_hsh = self.value_column_names.inject({}) do |hsh, cname|
+        hsh[cname] = source_obj.send cname
+        hsh
+      end
+
+      obj = self.new(att_hsh)
+      obj.source_record = source_obj
+
+      obj
+    end
+
+    def create_cache(obj)
+      c = build_cache(obj)
+      c.save 
+
+      c
+    end
+  end
+
 end
 

data/spec/cacheable_delegator_spec.rb

@@ -1,9 +1,11 @@
 require 'spec_helper'
 
 describe CacheableDelegator do
+  before(:each) do 
+    MyCachedRecord.upgrade_schema!
+  end
 
   context 'class methods' do 
-
     describe '.cache_and_delegate' do 
       it 'should accept only a class to cache' do 
         expect{ MyCachedRecord.cache_and_delegate("X::Foo") }.to raise_error ArgumentError
@@ -17,7 +19,24 @@ describe CacheableDelegator do
   end
 
 
-  context 'delegations' do 
+  context 'delegated methods via method_missing' do 
+
+    before(:each) do 
+      @source = MyRecord.new(awesome_value: 500)
+      @source.my_covers << MyCover.new(subject: 'Funny', year: 2000) << MyCover.new(subject: 'Yes')      
+      @source.save
+
+      @cache = MyCachedRecord.create_cache(@source)
+    end
+
+    context 'ActiveRecord relations' do 
+      it 'should have the same relations as its source' do 
+        expect(@cache.my_covers.count).to eq 2
+      end
+    end
+  end
+
+  context 'explicit delegations' do 
     context 'it should delegate all the things' do 
       before(:each) do 
         @my_record = MyRecord.create
@@ -35,7 +54,7 @@ describe CacheableDelegator do
         expect(@cache_record.delegate_foo).to eq @my_record.foo
       end
 
-      it 'will use its own :foo, without :delegate_ prefix' do 
+      it 'will always use its own :foo, without :delegate_ prefix' do 
         @cache_record.foo = 'baz'
         expect(@cache_record.foo).to eq 'baz'
       end
@@ -44,4 +63,6 @@ describe CacheableDelegator do
 
 
 
+
+
 end

data/spec/mixin_active_record_inline_schema_spec.rb

@@ -32,8 +32,59 @@ describe CacheableDelegator do
         end
       end
 
-      it 'should allow addition of different columns'
-      it 'should allow exclusion of specified columns'
+      context 'customization of columns with .add_custom_column' do 
+        after(:each) do 
+          reload_records!
+        end
+
+        it 'should allow addition of different columns' do 
+          MyCachedRecord.cache_and_delegate(MyRecord) do |cache|
+            cache.add_custom_column :my_record_special_foo
+          end
+          MyCachedRecord.upgrade_schema!
+
+          expect(MyCachedRecord.column_names).to include('my_record_special_foo')
+        end
+
+        it 'by default, should raise error if source_class does not respond_to custom column name' do 
+          expect{ MyCachedRecord.add_custom_column :not_foo_of_record }.to raise_error ArgumentError
+        end
+
+
+        context ':serialize option' do 
+          before(:each) do 
+            @source = MyRecord.create
+            @the_foo_array = @source.foo_array.dup
+          end
+          after(:each) do 
+            reload_records!
+          end
+
+          it 'should accept :serialize => true' do 
+            MyCachedRecord.add_custom_column :foo_array, serialize: true
+            MyCachedRecord.upgrade_schema!
+            cache = MyCachedRecord.create_cache(@source)
+            # remove @source to make sure things are cached
+            @source.delete 
+            cache = MyCachedRecord.find(cache.id)
+
+            expect(cache.foo_array).to be_an Array
+            expect(cache.foo_array).to include(*@the_foo_array)
+          end
+
+
+          it 'respects .serialize second argument' do 
+            MyCachedRecord.add_custom_column :foo_array, serialize: Hash
+            MyCachedRecord.upgrade_schema!
+            expect{ MyCachedRecord.create_cache(@source)  }.to raise_error ActiveRecord::SerializationTypeMismatch
+          end
+
+        end
+
+        it 'should allow exclusion of specified columns'
+
+
+      end
     end
 
 
@@ -47,8 +98,7 @@ describe CacheableDelegator do
 
 
       describe '#build_cache' do 
-        
-
+      
         it 'should have same awesome_value as its source_object' do 
           expect(@cache.awesome_value).to eq 88
         end
@@ -65,22 +115,21 @@ describe CacheableDelegator do
       describe '#create_cache' do
         it 'should be a saved record' do 
           savedcache = MyCachedRecord.create_cache(@source)
+
           expect(savedcache.valid?).to be_true
           expect(savedcache.new_record?).to be_false
         end
-
-      
-        context 'duplicating associated records' do 
-          it 'should only duplicate one level down'
-        end
-
       end
-
-
-
     end
 
     context 'maintanence' do 
+
+        context 'duplicating associated records' do 
+          it 'should only duplicate one level down' do 
+            pending "dumping to yaml"
+          end
+        end
+
     end
 
   end

data/spec/spec_records.rb

@@ -10,11 +10,7 @@ ActiveRecord::Base.establish_connection(
   :adapter => "sqlite3",
   :database => ":memory:"
 )
-ActiveRecord::Schema.define do
-
-
-  drop_table :my_records if ActiveRecord::Base.connection.table_exists?(:my_records)
-   
+ActiveRecord::Schema.define do   
   create_table :my_records, force: true do |t|
     t.integer :awesome_value
     t.string  :name
@@ -29,22 +25,46 @@ ActiveRecord::Schema.define do
     t.integer :source_record_id
     t.string  :source_record_type
   end
+
+
+  create_table :my_covers, force: true do |t|
+    t.integer :my_record_id
+    t.string  :subject
+    t.integer :year, default: 1999
+  end
 end
 
 
 class MyRecord < ActiveRecord::Base
+  has_many :my_covers
   def foo
     "This is foo"
   end
 
   def foo_double_awesome_value
-    awesome_value * 2
+    awesome_value.to_i * 2
+  end
+
+  def my_record_special_foo
+    'special foo'
   end
+
+
+  def foo_array
+    [awesome_value, 'foo!', awesome_value]
+  end
+
+end
+
+class MyCover < ActiveRecord::Base
+  belongs_to :my_record
 end
-MyRecord.reset_column_information
 
 
 class MyCachedRecord < ActiveRecord::Base
+  # for testing purposes
+   self.serialized_attributes = {}
+
   include CacheableDelegator
   cache_and_delegate MyRecord
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cacheable_delegator
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Dan Nguyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-09 00:00:00.000000000 Z
+date: 2013-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry