flattery 0.0.2 → 0.0.3

data/README.md

@@ -32,20 +32,26 @@ Or install it yourself as:
 
 ## Usage
 
-### How to define a model that has cached values from a :belongs_to association
+### How to cache values from a :belongs_to association
 
-Given a model with a :category assoociation, and you want to cache instance.category.name as instance.category_name.
+Given a model with a :belongs_to association, you want to store a (copy/cached) value from the associated record.
 
-First, add a migration to add :category_name column to your table with the same type as category.name.
-Then just include Flattery::ValueCache in your model and define flatten_values like this:
+    class Category < ActiveRecord::Base
+      has_many :notes, :inverse_of => :category
+    end
 
     class Note < ActiveRecord::Base
-      belongs_to :category
+      belongs_to :category, :inverse_of => :notes
 
       include Flattery::ValueCache
       flatten_value :category => :name
     end
 
+In this case, when you save an instance of Note, it will store the instance.category.name value as instance.category_name.
+The :category_name attribute is inferred from the relationship, and is assumed to be present in the schema.
+So before you can use this, you must add a migration to add the :category_name column to the notes table (with the same type as the :name column on the Category table).
+
+
 ### How to cache the value in a specific column name
 
 In the usual case, the cache column name is inferred from the association (e.g. category_name in the example above).
@@ -58,12 +64,12 @@ If you want to store in another column name, use the :as option on the +flatten_
       flatten_value :category => :name, :as => 'cat_name'
     end
 
-### How to push updates to cached values from the source model
+Again, you must make sure the column is correctly defined in your schema.
 
-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.
+### How to push updates to cached values from the source model
 
-This is achieved by adding the Flattery::ValueProvider to the source model and defining push_flattened_values_for like this:
+Given the example above, we have a problem if Category records are updated - the :category_name value stored in Notes gets out of sync.
+The Flattery::ValueProvider module fixes this by propagating changes accordingly.
 
     class Category < ActiveRecord::Base
       has_many :notes
@@ -72,7 +78,7 @@ This is achieved by adding the Flattery::ValueProvider to the source model and d
       push_flattened_values_for :name => :notes
     end
 
-This will respect the flatten_value settings defined in that target mode (Note in this example).
+This will push changes to Category :name to Notes records (by inference, updating the :category_name value in Notes).
 
 ### How to push updates to cached values from the source model to a specific cache column name
 
@@ -88,7 +94,6 @@ To 'help' flattery figure out the correct column name, specify the column name w
     end
 
 
-
 ## Contributing
 
 1. Fork it

data/lib/flattery.rb

@@ -2,5 +2,6 @@ require "active_support/core_ext"
 require "active_record"
 require "flattery/version"
 require "flattery/exception"
+require "flattery/settings"
 require "flattery/value_cache"
 require "flattery/value_provider"

data/lib/flattery/settings.rb

@@ -0,0 +1,71 @@
+class Flattery::Settings
+
+  attr_accessor :klass
+  attr_accessor :raw_settings
+  attr_accessor :resolved_settings
+  attr_accessor :resolved
+
+  def initialize(klass=nil)
+    self.klass = klass
+    reset!
+  end
+
+  def add_setting(options={})
+    if options.nil?
+      reset!
+      return
+    end
+    return if options.empty?
+    unresolved!
+    self.raw_settings << parse_option_setting(options)
+  end
+
+  # Process +options+ and return a standardised raw_setting hash
+  def parse_option_setting(options)
+    cache_options = setting_template
+
+    opt = options.symbolize_keys
+    as_setting = opt.delete(:as).try(:to_s)
+    method_setting = opt.delete(:method).try(:to_sym)
+
+    if from_entity = opt.keys.first
+      cache_options[:from_entity] = from_entity
+      cache_options[:to_entity] = opt[from_entity].try(:to_sym)
+    end
+    cache_options[:as] = as_setting
+    cache_options[:method] = method_setting if method_setting
+
+    cache_options
+  end
+
+  # Returns the basic settings template
+  def setting_template
+    {}
+  end
+
+  # Command: mark settings as unresolved
+  def unresolved!
+    self.resolved = false
+  end
+
+  # Command: clear/reset all settings
+  def reset!
+    self.raw_settings = []
+    self.resolved_settings = {}
+    self.resolved = false
+  end
+
+  # Returns resolved settings
+  def settings
+    unless resolved
+      self.resolved = resolve_settings!
+    end
+    self.resolved_settings
+  end
+
+  # Command: sets resolved_settings. Returns true if resolution was success (which will set the resolution status)
+  def resolve_settings!
+    true
+  end
+
+end

data/lib/flattery/value_cache.rb

@@ -3,9 +3,8 @@ module Flattery::ValueCache
 
   included do
     class_attribute :value_cache_options
-    self.value_cache_options = {}
-
-    before_save :resolve_value_cache
+    self.value_cache_options = Settings.new(self)
+    before_save Processor.new
   end
 
   module ClassMethods
@@ -22,49 +21,12 @@ module Flattery::ValueCache
     # When explicitly passed nil, it clears all existing settings
     #
     def flatten_value(options={})
-      if options.nil?
-        self.value_cache_options = {}
-        return
-      end
-
-      self.value_cache_options ||= {}
-      opt = options.symbolize_keys
-      as_setting = opt.delete(:as)
-      association_name = opt.keys.first
-      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}")
-        {
-          association_name: association_name,
-          association_method: association_method,
-          changed_on: [assoc.foreign_key]
-        }
-      end
-
-      if cache_options
-        self.value_cache_options[cache_attribute] = cache_options
-      else
-        self.value_cache_options.delete(cache_attribute)
-      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
+      self.value_cache_options.add_setting(options)
     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]
-        self.send("#{key}=", self.send(options[:association_name]).try(:send,options[:association_method]))
-      end
-    end
-    true
-  end
-
 end
+
+require "flattery/value_cache/settings"
+require "flattery/value_cache/processor"

data/lib/flattery/value_cache/processor.rb

@@ -0,0 +1,18 @@
+class Flattery::ValueCache::Processor
+
+  # Command: updates cached values for related changed attributes
+  def before_save(record)
+    resolved_options!(record.class).each do |key,options|
+      if record.changed & options[:changed_on]
+        record.send("#{key}=", record.send(options[:from_entity]).try(:send,options[:to_entity]))
+      end
+    end
+    true
+  end
+
+  # Command: resolves value cache options for +klass+ if required, and returns resolved options
+  def resolved_options!(klass)
+    klass.value_cache_options.settings
+  end
+
+end

data/lib/flattery/value_cache/settings.rb

@@ -0,0 +1,44 @@
+class Flattery::ValueCache::Settings < Flattery::Settings
+
+  # Command: sets resolved_settings. Returns true if resolution was success (which will set the resolution status)
+  #
+  # Given raw settings: [{ from_entity: :category, to_entity: :name, as: 'cat_name' }]
+  # Resolved settings: { 'cat_name' => { from_entity: :category, to_entity: :name, changed_on: ['category_id'] } }
+  #
+  # In the ValueCache context:
+  # * +from_entity+ is the association from which the cache value is obtained
+  # * +to_entity+ is the column that the cache value will be stored in
+  # * +as+ is the column name on +from_entity+ from which the cache value is to be read
+  #
+  # Validations/transformations performed:
+  # * from_entity is a valid association
+  # * cache attribute name derived from :as or inferred from association/attribute names
+  # * cache attribute is a valid column
+  #
+  # If any of these fail, the setting is excluded from the resolved options.
+  #
+  def resolve_settings!
+    self.resolved_settings = raw_settings.each_with_object({}) do |setting,memo|
+      from_entity = setting[:from_entity]
+      to_entity = setting[:to_entity]
+      cache_attribute = (setting[:as] || "#{from_entity}_#{to_entity}").to_s
+
+      assoc = klass.reflect_on_association(from_entity)
+      cache_options = if assoc && assoc.belongs_to? && klass.column_names.include?("#{cache_attribute}")
+        {
+          from_entity: from_entity,
+          to_entity: to_entity,
+          changed_on: [assoc.foreign_key]
+        }
+      end
+
+      if cache_options
+        memo[cache_attribute] = cache_options
+      else
+        memo.delete(cache_attribute)
+      end
+    end
+    true
+  end
+
+end

data/lib/flattery/value_provider.rb

@@ -3,9 +3,8 @@ module Flattery::ValueProvider
 
   included do
     class_attribute :value_provider_options
-    self.value_provider_options = {}
-
-    before_update :resolve_value_provision
+    self.value_provider_options = Settings.new(self)
+    before_update Processor.new
   end
 
   module ClassMethods
@@ -22,78 +21,12 @@ module Flattery::ValueProvider
     # 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
+      self.value_provider_options.add_setting(options)
     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
+
+require "flattery/value_provider/settings"
+require "flattery/value_provider/processor"

data/lib/flattery/value_provider/processor.rb

@@ -0,0 +1,26 @@
+class Flattery::ValueProvider::Processor
+
+  # Command: pushes cache updates for related changed attributes
+  def before_update(record)
+    resolved_options!(record.class).each do |key,options|
+      if record.changed.include?(key)
+        if cache_column = options[:as]
+          case options[:method]
+          when :update_all
+            new_value = record.send(key)
+            record.send(options[:to_entity]).update_all({cache_column => new_value})
+          end
+        else
+          raise Flattery::CacheColumnInflectionError.new("#{record.class.name} #{key}: #{options}")
+        end
+      end
+    end
+    true
+  end
+
+  # Command: resolves value provider options for +klass+ if required, and returns resolved options
+  def resolved_options!(klass)
+    klass.value_provider_options.settings
+  end
+
+end

data/lib/flattery/value_provider/settings.rb

@@ -0,0 +1,74 @@
+class Flattery::ValueProvider::Settings < Flattery::Settings
+
+  # Returns the basic settings template
+  def setting_template
+    {method: :update_all}
+  end
+
+  # Command: sets resolved_settings. Returns true if resolution was success (which will set the resolution status)
+  #
+  # Given raw settings: [{ from_entity: :name, to_entity: :notes, as: 'cat_name', method: :update_all }]
+  # Resolved settings: { 'name' => { to_entity: :notes, as: 'cat_name', method: :update_all } }
+  #
+  # In the ValueProvider context:
+  # * +from_entity+ is the column that provides the cache value
+  # * +to_entity+ is the association to which the cache value is pushed
+  # * +as+ is the column name on +to_entity+ from which the cache value is to be stored
+  #
+  # Validations/transformations performed:
+  # * to_entity is a valid association
+  #
+  # If any of these fail, the setting is excluded from the resolved options.
+  #
+  def resolve_settings!
+    self.resolved_settings = raw_settings.each_with_object({}) do |setting,memo|
+      from_entity = setting[:from_entity]
+      to_entity = setting[:to_entity]
+
+      push_method = setting[:method]
+      attribute_name = "#{from_entity}"
+
+      assoc = klass.reflect_on_association(to_entity)
+      cache_options = if assoc && assoc.macro == :has_many
+
+        cached_attribute_name = if setting[:as].present?
+          setting[:as].to_sym
+        else
+          name = nil
+          other_assoc_name = if assoc.inverse_of
+            assoc.inverse_of.name
+          else
+          end
+          if other_assoc_name
+            name = cache_attribute_for_association(assoc.klass,other_assoc_name,attribute_name)
+            name ||= "#{other_assoc_name}_#{attribute_name}"
+          end
+          name = nil unless name && assoc.klass.column_names.include?(name)
+          name
+        end
+
+        {
+          to_entity: to_entity,
+          as: cached_attribute_name,
+          method: push_method
+        }
+      end
+
+      if cache_options
+        memo[attribute_name] = cache_options
+      else
+        memo.delete(attribute_name)
+      end
+
+    end
+    true
+  end
+
+  # Returns the cache_column name given +association_name+ and +association_method+
+  def cache_attribute_for_association(klass,association_name,association_method)
+    if klass.respond_to?(:value_cache_options)
+      klass.value_cache_options.settings.detect{|k,v| v[:from_entity] == association_name.to_sym &&  v[:to_entity] ==  association_method.to_sym }.first
+    end
+  end
+
+end

data/lib/flattery/version.rb

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

data/spec/spec_helper.rb

@@ -25,4 +25,8 @@ RSpec.configure do |config|
   config.before do
     truncate_records
   end
+
+  config.after do
+    clear_harness_classes
+  end
 end

data/spec/support/active_record_fixtures.rb

@@ -49,6 +49,11 @@ module ArHelper
     Person.delete_all
   end
 
+  def clear_harness_classes
+    Object.send(:remove_const, :ValueProviderHarness) if Object.constants.include?(:ValueProviderHarness)
+    Object.send(:remove_const, :ValueCacheHarness) if Object.constants.include?(:ValueCacheHarness)
+  end
+
 end
 
 RSpec.configure do |conf|

data/spec/unit/settings_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper.rb'
+
+describe Flattery::Settings do
+  let(:settings_class) { Flattery::Settings }
+  let(:settings) { settings_class.new }
+  subject { settings }
+
+  describe "#initialize" do
+    its(:klass) { should be_nil }
+    its(:raw_settings) { should eql([]) }
+    its(:resolved_settings) { should eql({}) }
+    its(:resolved) { should be_false}
+    context "when given class parameter" do
+      let(:klass) { String }
+      let(:settings) { settings_class.new(klass) }
+      its(:klass) { should eql(klass) }
+    end
+  end
+
+  def add_dummy_settings_values
+    settings.raw_settings = [1,2,3,4]
+    settings.resolved_settings = {a: :b}
+    settings.resolved = true
+    settings
+  end
+
+  describe "#reset!" do
+    before do
+      add_dummy_settings_values
+      settings.reset!
+    end
+    its(:raw_settings) { should eql([]) }
+    its(:resolved_settings) { should eql({}) }
+    its(:resolved) { should be_false}
+  end
+
+  describe "#add_setting" do
+
+    context "when given empty hash" do
+      before { add_dummy_settings_values }
+      it "should not do anything" do
+        expect { settings.add_setting({}) }.to_not change { settings.raw_settings }.from([1,2,3,4])
+      end
+    end
+
+    context "when given nil" do
+      it "should cause a reset!" do
+        settings.should_receive(:reset!)
+        settings.add_setting(nil)
+      end
+    end
+
+    context "when given options as Symbols" do
+      before { settings.add_setting({category: :name}) }
+      its(:raw_settings) { should eql([
+        { from_entity: :category, to_entity: :name, as: nil }
+      ]) }
+      context "and then given another definition" do
+        before { settings.add_setting({person: :email}) }
+        its(:raw_settings) { should eql([
+          { from_entity: :category, to_entity: :name, as: nil },
+          { from_entity: :person, to_entity: :email, as: nil }
+        ]) }
+        context "and then reset with nil" do
+          before { settings.add_setting nil }
+          its(:raw_settings) { should eql([]) }
+        end
+      end
+    end
+
+    context "when optional :as specified as Symbols" do
+      before { settings.add_setting({category: :name, as: :cat_name}) }
+      its(:raw_settings) { should eql([
+        { from_entity: :category, to_entity: :name, as: 'cat_name' }
+      ]) }
+    end
+
+    context "when optional :method specified as Symbols" do
+      before { settings.add_setting({category: :name, method: :update_all}) }
+      its(:raw_settings) { should eql([
+        { from_entity: :category, to_entity: :name, as: nil, method: :update_all }
+      ]) }
+    end
+
+    context "when given options as String" do
+      before { settings.add_setting({'category' => 'name'}) }
+      its(:raw_settings) { should eql([
+        { from_entity: :category, to_entity: :name, as: nil }
+      ]) }
+    end
+
+    context "when optional :as specified as String" do
+      before { settings.add_setting({'category' => 'name', 'as' => 'cat_name'}) }
+      its(:raw_settings) { should eql([
+        { from_entity: :category, to_entity: :name, as: 'cat_name' }
+      ]) }
+    end
+
+  end
+
+  describe "#settings" do
+    context "when initialially not resolved" do
+      it "should invoke resolve_settings!" do
+        settings.should_receive(:resolve_settings!)
+        settings.settings
+      end
+      it "should mark as resolved" do
+        expect { settings.settings }.to change { settings.resolved }.from(false).to(true)
+      end
+    end
+    context "when initialially resolved" do
+      before { add_dummy_settings_values }
+      it "should not invoke resolve_settings!" do
+        settings.should_receive(:resolve_settings!).never
+        settings.settings
+      end
+      it "should not change resolved status" do
+        expect { settings.settings }.to_not change { settings.resolved }.from(true)
+      end
+    end
+  end
+
+end

data/spec/unit/value_cache/processor_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper.rb'
+
+# Now test caching in a range of actual scenarios...
+describe Flattery::ValueCache::Processor do
+
+  context "with simple belongs_to associations with cached values" do
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value category: :name
+      end
+      ValueCacheHarness
+    end
+    let!(:resource) { cache_class.create }
+
+    let!(:category) { Category.create(name: 'category_a') }
+
+    context "when association is changed by id" do
+      it "should cache the new value" do
+        expect {
+          resource.update_attributes(category_id: category.id)
+        }.to change {
+          resource.category_name
+        }.from(nil).to(category.name)
+      end
+    end
+    context "when already set" do
+      before { resource.update_attributes(category_id: category.id) }
+      context "then set to nil" do
+        it "should cache the new value" do
+          expect {
+            resource.update_attributes(category_id: nil)
+          }.to change {
+            resource.category_name
+          }.from(category.name).to(nil)
+        end
+      end
+      context "and associated record is destroyed" do
+        before { category.destroy }
+        it "should not recache the value when other values updated" do
+          expect {
+            resource.update_attributes(name: 'a new name')
+          }.to_not change {
+            resource.category_name
+          }.from(category.name)
+        end
+      end
+    end
+
+  end
+
+end

data/spec/unit/value_cache/settings_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper.rb'
+
+describe Flattery::ValueCache::Settings do
+  let(:settings_class) { Flattery::ValueCache::Settings }
+  let(:settings) { cache_class.value_cache_options }
+  subject { settings }
+
+  context "with a standard belongs_to association" do
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value category: :name
+      end
+      ValueCacheHarness
+    end
+    context "before resolution" do
+      it { should be_a(settings_class) }
+      its(:raw_settings) { should eql([
+        {from_entity: :category, to_entity: :name, as: nil}
+      ]) }
+      its(:resolved) { should be_false }
+    end
+    context "after resolution" do
+      before { settings.settings }
+      its(:resolved) { should be_true }
+      its(:settings) { should eql({
+        "category_name"=>{from_entity: :category, to_entity: :name, changed_on: ["category_id"]}
+      }) }
+    end
+  end
+
+end

data/spec/unit/value_cache_spec.rb

@@ -1,156 +1,30 @@
 require 'spec_helper.rb'
 
-class FlatteryValueCacheTestHarness < Note
-  include Flattery::ValueCache
-end
-
 describe Flattery::ValueCache do
 
-  let(:resource_class) { FlatteryValueCacheTestHarness }
-  after { resource_class.value_cache_options = {} }
-
-  describe "##included_modules" do
-    subject { resource_class.included_modules }
-    it { should include(Flattery::ValueCache) }
-  end
-
-  describe "##value_cache_options" do
-    before { resource_class.flatten_value flatten_value_options }
-    subject { resource_class.value_cache_options }
-
-    context "when set to empty" do
-      let(:flatten_value_options) { {} }
-      it { should be_empty }
-    end
-
-    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} }
-        it { should eql({
-          "category_name" => {
-            association_name: :category,
-            association_method: :name,
-            changed_on: ["category_id"]
-          }
-        }) }
-      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
-        let(:flatten_value_options) { {category: :bogative} }
-        it { should be_empty }
-      end
-
-    end
-
-    context "with a belongs_to association having non-standard primary and foreign keys" do
-
-      context "when set by association name and attribute value" do
-        let(:flatten_value_options) { {person: :email} }
-        it { should eql({
-          "person_email" => {
-            association_name: :person,
-            association_method: :email,
-            changed_on: ["person_name"]
-          }
-        }) }
-      end
-
-      context "when set by association name and invalid attribute value" do
-        let(:flatten_value_options) { {person: :bogative} }
-        it { should be_empty }
-      end
-
+  let(:cache_class) do
+    class ::ValueCacheHarness < Note
+      include Flattery::ValueCache
     end
+    ValueCacheHarness
+  end
 
+  subject { cache_class }
 
-  end
+  its(:included_modules) { should include(Flattery::ValueCache) }
+  its(:value_cache_options) { should be_a(Flattery::ValueCache::Settings) }
 
-  describe "#resolve_value_cache" do
+  describe "#before_save" do
+    let(:processor_class) { Flattery::ValueCache::Processor }
     it "should be called when record created" do
-      resource_class.any_instance.should_receive(:resolve_value_cache).and_return(true)
-      resource_class.create!
+      processor_class.any_instance.should_receive(:before_save).and_return(true)
+      subject.create!
     end
     it "should be called when record updated" do
-      instance = resource_class.create!
-      instance.should_receive(:resolve_value_cache).and_return(true)
+      instance = subject.create!
+      processor_class.any_instance.should_receive(:before_save).and_return(true)
       instance.save
     end
   end
 
-  describe "#before_save" do
-    let!(:resource) { resource_class.create }
-
-    context "with simple belongs_to associations with cached values" do
-      before { resource_class.flatten_value category: :name }
-      let!(:category) { Category.create(name: 'category_a') }
-
-      context "when association is changed by id" do
-        it "should cache the new value" do
-          expect {
-            resource.update_attributes(category_id: category.id)
-          }.to change {
-            resource.category_name
-          }.from(nil).to(category.name)
-        end
-      end
-      context "when already set" do
-        before { resource.update_attributes(category_id: category.id) }
-        context "then set to nil" do
-          it "should cache the new value" do
-            expect {
-              resource.update_attributes(category_id: nil)
-            }.to change {
-              resource.category_name
-            }.from(category.name).to(nil)
-          end
-        end
-        context "and associated record is destroyed" do
-          before { category.destroy }
-          it "should not recache the value when other values updated" do
-            expect {
-              resource.update_attributes(name: 'a new name')
-            }.to_not change {
-              resource.category_name
-            }.from(category.name)
-          end
-        end
-      end
-
-    end
-  end
-
 end

data/spec/unit/value_provider/processor_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper.rb'
+
+# Test caching in a range of actual scenarios
+describe Flattery::ValueProvider::Processor do
+
+  context "with provider having simple has_many association and explicit cache_column name" do
+    let(:provider_class) do
+      class ::ValueProviderHarness < Category
+        include Flattery::ValueProvider
+        push_flattened_values_for name: :notes, as: :category_name
+      end
+      ValueProviderHarness
+    end
+
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value category: :name
+      end
+      ValueCacheHarness
+    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) do
+      class ::ValueProviderHarness < Category
+        include Flattery::ValueProvider
+        push_flattened_values_for name: :notes
+      end
+      ValueProviderHarness
+    end
+
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value category: :name
+      end
+      ValueCacheHarness
+    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) do
+      class ::ValueProviderHarness < Person
+        include Flattery::ValueProvider
+        has_many :harness_notes, class_name: 'NoteTestHarness', primary_key: "username", foreign_key: "person_name", inverse_of: :person
+        push_flattened_values_for email: :notes
+      end
+      ValueProviderHarness
+    end
+
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value person: :email
+      end
+      ValueCacheHarness
+    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) do
+      class ::ValueProviderHarness < Person
+        include Flattery::ValueProvider
+        has_many :harness_notes, class_name: 'ValueCacheHarness', primary_key: "username", foreign_key: "person_name", inverse_of: :person
+        push_flattened_values_for email: :harness_notes
+      end
+      ValueProviderHarness
+    end
+
+    let(:cache_class) do
+      class ::ValueCacheHarness < Note
+        include Flattery::ValueCache
+        flatten_value person: :email, as: :user_email
+      end
+      ValueCacheHarness
+    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

data/spec/unit/value_provider/settings_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper.rb'
+
+describe Flattery::ValueProvider::Settings do
+  let(:settings_class) { Flattery::ValueProvider::Settings }
+  let(:settings) { provider_class.value_provider_options }
+
+  subject { settings }
+
+  context "with a standard has_many association" do
+    let(:provider_class) do
+      class ::ValueProviderHarness < Category
+        include Flattery::ValueProvider
+        push_flattened_values_for name: :notes, as: :category_name
+      end
+      ValueProviderHarness
+    end
+    context "before resolution" do
+      it { should be_a(settings_class) }
+      its(:raw_settings) { should eql([
+        {from_entity: :name, to_entity: :notes, as: 'category_name', method: :update_all}
+      ]) }
+      its(:resolved) { should be_false }
+    end
+    context "after resolution" do
+      before { settings.settings }
+      its(:resolved) { should be_true }
+      its(:settings) { should eql({
+        "name"=>{to_entity: :notes, as: :category_name, method: :update_all}
+      }) }
+    end
+  end
+
+
+end

data/spec/unit/value_provider_spec.rb

@@ -1,195 +1,30 @@
 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 }
+  let(:provider_class) do
+    class ::ValueProviderHarness < Category
+      include Flattery::ValueProvider
     end
+    ValueProviderHarness
+  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
+  subject { provider_class }
 
-    end
-  end
+  its(:included_modules) { should include(Flattery::ValueProvider) }
+  its(:value_provider_options) { should be_a(Flattery::ValueProvider::Settings) }
 
-  describe "#resolve_value_provision" do
+  describe "#before_update" do
+    let(:processor_class) { Flattery::ValueProvider::Processor }
     it "should not be called when record created" do
-      resource_class.any_instance.should_receive(:resolve_value_provision).never
-      resource_class.create!
+      processor_class.any_instance.should_receive(:before_update).never
+      provider_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 = provider_class.create!
+      processor_class.any_instance.should_receive(:before_update).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.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-09 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -173,13 +173,23 @@ files:
 - flattery.gemspec
 - lib/flattery.rb
 - lib/flattery/exception.rb
+- lib/flattery/settings.rb
 - lib/flattery/value_cache.rb
+- lib/flattery/value_cache/processor.rb
+- lib/flattery/value_cache/settings.rb
 - lib/flattery/value_provider.rb
+- lib/flattery/value_provider/processor.rb
+- lib/flattery/value_provider/settings.rb
 - lib/flattery/version.rb
 - spec/spec_helper.rb
 - spec/support/active_record_fixtures.rb
 - spec/unit/exception_spec.rb
+- spec/unit/settings_spec.rb
+- spec/unit/value_cache/processor_spec.rb
+- spec/unit/value_cache/settings_spec.rb
 - spec/unit/value_cache_spec.rb
+- spec/unit/value_provider/processor_spec.rb
+- spec/unit/value_provider/settings_spec.rb
 - spec/unit/value_provider_spec.rb
 homepage: https://github.com/evendis/flattery
 licenses:
@@ -210,5 +220,10 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/active_record_fixtures.rb
 - spec/unit/exception_spec.rb
+- spec/unit/settings_spec.rb
+- spec/unit/value_cache/processor_spec.rb
+- spec/unit/value_cache/settings_spec.rb
 - spec/unit/value_cache_spec.rb
+- spec/unit/value_provider/processor_spec.rb
+- spec/unit/value_provider/settings_spec.rb
 - spec/unit/value_provider_spec.rb