flattery 0.0.1 → 0.0.2

data/README.md

@@ -14,7 +14,7 @@ If you are using NoSQL, you probably wouldn't design your schema in a way for wh
 
 * Ruby 1.9 or 2
 * Rails 3.x/4.x
-* ActiveRecord (only splite and PostgreQL tested. Others _should_ work; raise an issue if you find problems)
+* ActiveRecord (only sqlite and PostgreQL tested. Others _should_ work; raise an issue if you find problems)
 
 ## Installation
 
@@ -44,7 +44,6 @@ Then just include Flattery::ValueCache in your model and define flatten_values l
 
       include Flattery::ValueCache
       flatten_value :category => :name
-
     end
 
 ### How to cache the value in a specific column name
@@ -57,10 +56,39 @@ If you want to store in another column name, use the :as option on the +flatten_
 
       include Flattery::ValueCache
       flatten_value :category => :name, :as => 'cat_name'
+    end
+
+### How to push updates to cached values from the source model
+
+Given a model with a :category assoociation, and a flattery config that caches instance.category.name to instance.category_name,
+you want the category_name cached value updated if the category.name changes.
+
+This is achieved by adding the Flattery::ValueProvider to the source model and defining push_flattened_values_for like this:
+
+    class Category < ActiveRecord::Base
+      has_many :notes
+
+      include Flattery::ValueProvider
+      push_flattened_values_for :name => :notes
+    end
+
+This will respect the flatten_value settings defined in that target mode (Note in this example).
+
+### How to push updates to cached values from the source model to a specific cache column name
+
+If the cache column name cannot be inferred correctly, an error will be raised. Inference errors can occur if the inverse association relation cannot be determined.
 
+To 'help' flattery figure out the correct column name, specify the column name with an :as option:
+
+    class Category < ActiveRecord::Base
+      has_many :notes
+
+      include Flattery::ValueProvider
+      push_flattened_values_for :name => :notes, :as => 'cat_name'
     end
 
 
+
 ## Contributing
 
 1. Fork it

data/lib/flattery.rb

@@ -1,4 +1,6 @@
 require "active_support/core_ext"
 require "active_record"
 require "flattery/version"
+require "flattery/exception"
 require "flattery/value_cache"
+require "flattery/value_provider"

data/lib/flattery/exception.rb

@@ -0,0 +1,12 @@
+module Flattery
+
+  # A general exception
+  class Error < StandardError; end
+
+  # Raised when cannot successfully infer the cache column name
+  class CacheColumnInflectionError < Error; end
+
+  # Raised when cannot successfully iget a valid association
+  class InvalidAssociationError < Error; end
+
+end

data/lib/flattery/value_cache.rb

@@ -31,8 +31,8 @@ module Flattery::ValueCache
       opt = options.symbolize_keys
       as_setting = opt.delete(:as)
       association_name = opt.keys.first
-      association_method = opt[association_name]
-      cache_attribute = as_setting || "#{association_name}_#{association_method}"
+      association_method = opt[association_name].try(:to_sym)
+      cache_attribute = (as_setting || "#{association_name}_#{association_method}").to_s
 
       assoc = reflect_on_association(association_name)
       cache_options = if assoc && assoc.belongs_to? && assoc.klass.column_names.include?("#{association_method}")
@@ -50,8 +50,14 @@ module Flattery::ValueCache
       end
     end
 
+    # Returns the cache_column name given +association_name+ and +association_method+
+    def cache_attribute_for_association(association_name,association_method)
+      value_cache_options.detect{|k,v| v[:association_name] == association_name.to_sym &&  v[:association_method] ==  association_method.to_sym }.first
+    end
+
   end
 
+  # Command: updates cached values for related changed attributes
   def resolve_value_cache
     self.class.value_cache_options.each do |key,options|
       if changed & options[:changed_on]
@@ -61,4 +67,4 @@ module Flattery::ValueCache
     true
   end
 
-end
+end

data/lib/flattery/value_provider.rb

@@ -0,0 +1,99 @@
+module Flattery::ValueProvider
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :value_provider_options
+    self.value_provider_options = {}
+
+    before_update :resolve_value_provision
+  end
+
+  module ClassMethods
+
+    # Command: adds flattery definition +options+.
+    # The +options+ define a single cache setting. To define multiple cache settings, call over again for each setting.
+    #
+    # +options+ by example:
+    #    push_flattened_values_for :name => :notes
+    #    # => will update the cached value of :name in all related Note model instances
+    #    push_flattened_values_for :name => :notes, as: 'cat_name'
+    #    # => will update the cached value of :name in the 'cat_name' column of all related Note model instances
+    #
+    # When explicitly passed nil, it clears all existing settings
+    #
+    def push_flattened_values_for(options={})
+      if options.nil?
+        self.value_provider_options = {}
+        return
+      end
+
+      self.value_provider_options ||= {}
+      opt = options.symbolize_keys
+      as_setting = opt.delete(:as)
+
+      attribute_key = opt.keys.first
+      association_name = opt[attribute_key]
+      attribute_name = "#{attribute_key}"
+
+      cached_attribute_name = (as_setting || "inflect").to_sym
+
+      assoc = reflect_on_association(association_name)
+      cache_options = if assoc && assoc.macro == :has_many
+        {
+          association_name: association_name,
+          cached_attribute_name: cached_attribute_name,
+          method: :update_all
+        }
+      end
+
+      if cache_options
+        self.value_provider_options[attribute_name] = cache_options
+      else
+        self.value_provider_options.delete(attribute_name)
+      end
+    end
+
+  end
+
+  # Command: pushes cache updates for related changed attributes
+  def resolve_value_provision
+    self.class.value_provider_options.each do |key,options|
+      if changed.include?(key)
+
+        association_name = options[:association_name]
+
+        cache_column = if options[:cached_attribute_name] == :inflect
+          name = nil
+          if assoc = self.class.reflect_on_association(association_name)
+            other_assoc_name = if assoc.inverse_of
+              assoc.inverse_of.name
+            else
+            end
+            if other_assoc_name
+              if assoc.klass.respond_to?(:cache_attribute_for_association)
+                name = assoc.klass.cache_attribute_for_association(other_assoc_name,key)
+              end
+              name ||= "#{other_assoc_name}_#{key}"
+            end
+            name = nil unless name && assoc.klass.column_names.include?(name)
+          end
+          name
+        else
+          options[:cached_attribute_name]
+        end
+
+        if cache_column
+          case options[:method]
+          when :update_all
+            new_value = self.send(key)
+            self.send(association_name).update_all({cache_column => new_value})
+          end
+        else
+          raise Flattery::CacheColumnInflectionError.new("#{self.class.name} #{key}: #{options}")
+        end
+      end
+    end
+    true
+  end
+
+end

data/lib/flattery/version.rb

@@ -1,3 +1,3 @@
 module Flattery
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/support/active_record_fixtures.rb

@@ -8,8 +8,10 @@ ActiveRecord::Migration.suppress_messages do
       t.string :name;
       t.belongs_to :category;
       t.string :category_name;
+      t.string :cat_name;
       t.string :person_name;
       t.string :person_email;
+      t.string :user_email;
     end
 
     create_table(:categories, :force => true) do |t|
@@ -35,7 +37,7 @@ class Category < ActiveRecord::Base
 end
 
 class Person < ActiveRecord::Base
-  has_many :notes, inverse_of: :person
+  has_many :notes, primary_key: "username", foreign_key: "person_name", inverse_of: :person
 end
 
 module ArHelper
@@ -51,4 +53,4 @@ end
 
 RSpec.configure do |conf|
   conf.include ArHelper
-end
+end

data/spec/unit/exception_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "Flattery Exceptions" do
+
+  [
+    Flattery::Error,
+    Flattery::CacheColumnInflectionError
+  ].each do |exception_class|
+    describe exception_class do
+      subject { raise exception_class.new("test") }
+      it "should raise correctly" do
+        expect { subject }.to raise_error(exception_class)
+      end
+    end
+  end
+
+end

data/spec/unit/value_cache_spec.rb

@@ -23,7 +23,18 @@ describe Flattery::ValueCache do
       it { should be_empty }
     end
 
-    context "with simple belongs_to associations" do
+    context "when reset with nil" do
+      let(:flatten_value_options) { {category: :name} }
+      it "should clear all settings" do
+        expect {
+          resource_class.flatten_value nil
+        }.to change {
+          resource_class.value_cache_options
+        }.to({})
+      end
+    end
+
+    context "with simple belongs_to association" do
 
       context "when set by association name and attribute value" do
         let(:flatten_value_options) { {category: :name} }
@@ -34,16 +45,28 @@ describe Flattery::ValueCache do
             changed_on: ["category_id"]
           }
         }) }
+      end
 
-        context "when force reset to nil" do
-          it "should clear all settings" do
-            expect {
-              resource_class.flatten_value nil
-            }.to change {
-              resource_class.value_cache_options
-            }.to({})
-          end
-        end
+      context "when given a cache column override" do
+        let(:flatten_value_options) { {category: :name, as: :cat_name} }
+        it { should eql({
+          "cat_name" => {
+            association_name: :category,
+            association_method: :name,
+            changed_on: ["category_id"]
+          }
+        }) }
+      end
+
+      context "when set using Strings" do
+        let(:flatten_value_options) { {'category' => 'name', 'as' => 'cat_name'} }
+        it { should eql({
+          "cat_name" => {
+            association_name: :category,
+            association_method: :name,
+            changed_on: ["category_id"]
+          }
+        }) }
       end
 
       context "when set by association name and invalid attribute value" do
@@ -130,4 +153,4 @@ describe Flattery::ValueCache do
     end
   end
 
-end
+end

data/spec/unit/value_provider_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper.rb'
+
+class FlatteryValueProviderTestHarness < Category
+  include Flattery::ValueProvider
+end
+
+class NoteTestHarness < Note
+  include Flattery::ValueCache
+end
+
+class CategoryTestHarness < Category
+  include Flattery::ValueProvider
+end
+
+class PersonTestHarness < Person
+  include Flattery::ValueProvider
+  has_many :harness_notes, class_name: 'NoteTestHarness', primary_key: "username", foreign_key: "person_name", inverse_of: :person
+end
+
+describe Flattery::ValueProvider do
+
+  let(:resource_class) { FlatteryValueProviderTestHarness }
+  after { resource_class.value_provider_options = {} }
+
+  describe "##included_modules" do
+    subject { resource_class.included_modules }
+    it { should include(Flattery::ValueProvider) }
+  end
+
+  describe "##value_provider_options" do
+    before { resource_class.push_flattened_values_for push_flattened_values_for_options }
+    subject { resource_class.value_provider_options }
+
+    context "when set to empty" do
+      let(:push_flattened_values_for_options) { {} }
+      it { should be_empty }
+    end
+
+    context "when reset with nil" do
+      let(:push_flattened_values_for_options) { {name: :notes} }
+      it "should clear all settings" do
+        expect {
+          resource_class.push_flattened_values_for nil
+        }.to change {
+          resource_class.value_provider_options
+        }.to({})
+      end
+    end
+
+    context "with simple has_many association" do
+
+      context "when set by association name and attribute value" do
+        let(:push_flattened_values_for_options) { {name: :notes} }
+        it { should eql({
+          "name" => {
+            association_name: :notes,
+            cached_attribute_name: :inflect,
+            method: :update_all
+          }
+        }) }
+      end
+
+      context "when given a cache column override" do
+        let(:push_flattened_values_for_options) { {name: :notes, as: :category_name} }
+        it { should eql({
+          "name" => {
+            association_name: :notes,
+            cached_attribute_name: :category_name,
+            method: :update_all
+          }
+        }) }
+      end
+
+      context "when set by association name and invalid attribute value" do
+        let(:push_flattened_values_for_options) { {name: :bogative} }
+        it { should be_empty }
+      end
+
+    end
+  end
+
+  describe "#resolve_value_provision" do
+    it "should not be called when record created" do
+      resource_class.any_instance.should_receive(:resolve_value_provision).never
+      resource_class.create!
+    end
+    it "should be called when record updated" do
+      instance = resource_class.create!
+      instance.should_receive(:resolve_value_provision).and_return(true)
+      instance.save
+    end
+  end
+
+  describe "#before_update" do
+
+    context "with provider having simple has_many association and explicit cache_column name" do
+      let(:provider_class) { CategoryTestHarness }
+      let(:cache_class)    { NoteTestHarness }
+      before do
+        provider_class.push_flattened_values_for name: :notes, as: :category_name
+        cache_class.flatten_value category: :name
+      end
+      after do
+        provider_class.value_provider_options = {}
+        cache_class.value_cache_options = {}
+      end
+      let!(:resource)       { provider_class.create(name: 'category_a') }
+      let!(:target_a)       { cache_class.create(category_id: resource.id) }
+      let!(:target_other_a) { cache_class.create }
+      context "when cached value is updated" do
+        it "should push the new cache value" do
+          expect {
+            resource.update_attributes(name: 'new category name')
+          }.to change {
+            target_a.reload.category_name
+          }.from('category_a').to('new category name')
+        end
+      end
+    end
+
+    context "with provider that cannot correctly infer the cache column name" do
+      let(:provider_class) { CategoryTestHarness }
+      let(:cache_class)    { NoteTestHarness }
+      before do
+        provider_class.push_flattened_values_for name: :notes
+        cache_class.flatten_value category: :name
+      end
+      after do
+        provider_class.value_provider_options = {}
+        cache_class.value_cache_options = {}
+      end
+      let!(:resource)       { provider_class.create(name: 'category_a') }
+      let!(:target_a)       { cache_class.create(category_id: resource.id) }
+      let!(:target_other_a) { cache_class.create }
+      context "when cached value is updated" do
+        it "should push the new cache value" do
+          expect {
+            resource.update_attributes(name: 'new category name')
+          }.to raise_error(Flattery::CacheColumnInflectionError)
+        end
+      end
+    end
+
+    context "with provider having has_many association with cache name inflected via inverse relation" do
+      let(:provider_class) { PersonTestHarness }
+      let(:cache_class)    { NoteTestHarness }
+      before do
+        provider_class.push_flattened_values_for email: :notes
+        cache_class.flatten_value person: :email
+      end
+      after do
+        provider_class.value_provider_options = {}
+        cache_class.value_cache_options = {}
+      end
+      let!(:resource)       { provider_class.create(username: 'user_a', email: 'email1') }
+      let!(:target_a)       { cache_class.create(person_name: resource.username) }
+      let!(:target_other_a) { cache_class.create }
+      context "when cached value is updated" do
+        it "should push the new cache value" do
+          expect {
+            resource.update_attributes(email: 'email2')
+          }.to change {
+            target_a.reload.person_email
+          }.from('email1').to('email2')
+        end
+      end
+    end
+
+    context "with provider having has_many association with cache name inflected via inverse relation with custom cache column name" do
+      let(:provider_class) { PersonTestHarness }
+      let(:cache_class)    { NoteTestHarness }
+      before do
+        provider_class.push_flattened_values_for email: :harness_notes
+        cache_class.flatten_value person: :email, as: :user_email
+      end
+      after do
+        provider_class.value_provider_options = {}
+        cache_class.value_cache_options = {}
+      end
+      let!(:resource)       { provider_class.create(username: 'user_a', email: 'email1') }
+      let!(:target_a)       { cache_class.create(person_name: resource.username) }
+      let!(:target_other_a) { cache_class.create }
+      context "when cached value is updated" do
+        it "should push the new cache value" do
+          expect {
+            resource.update_attributes(email: 'email2')
+          }.to change {
+            target_a.reload.user_email
+          }.from('email1').to('email2')
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flattery
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -172,11 +172,15 @@ files:
 - Rakefile
 - flattery.gemspec
 - lib/flattery.rb
+- lib/flattery/exception.rb
 - lib/flattery/value_cache.rb
+- lib/flattery/value_provider.rb
 - lib/flattery/version.rb
 - spec/spec_helper.rb
 - spec/support/active_record_fixtures.rb
+- spec/unit/exception_spec.rb
 - spec/unit/value_cache_spec.rb
+- spec/unit/value_provider_spec.rb
 homepage: https://github.com/evendis/flattery
 licenses:
 - MIT
@@ -205,4 +209,6 @@ summary: Flatter your nicely normalised AR models
 test_files:
 - spec/spec_helper.rb
 - spec/support/active_record_fixtures.rb
+- spec/unit/exception_spec.rb
 - spec/unit/value_cache_spec.rb
+- spec/unit/value_provider_spec.rb