plyushkin 0.0.6 → 0.0.7

data/.gitignore

@@ -3,3 +3,5 @@
 *.swp
 *.swo
 plyushkin*.gem
+vendor/bundle
+tags

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    plyushkin (0.0.5)
+    plyushkin (0.0.6)
       activerecord (~> 3.2.12)
 
 GEM

data/README.md

@@ -124,7 +124,7 @@ To get the latest oil change details
     v.oil_change.last.mileage  # => 1234
     v.oil_change.last.oil_type # => '10W30'
 
-##### Specifiying a callback after a value is stored
+##### Specifying a callback after a value is stored
 
 When defining a hoards property, you can set a callback for after the value is persisted.  For example,
 if the vehicle table contains a `next_oil_change_mileage` column, we might want to update it whenever
@@ -139,6 +139,42 @@ an oil_change is saved.
       end
     end
 
+##### Filters
+
+Sometimes it is useful to filter hoarded values.  For example, we may want the ability to soft-delete
+values from the historical properties (hard deletes is against the phylosophy of plyushkin), 
+but we can obtain similar results by:
+
+    class OilChangeValue < Plyushkin::BaseValue
+      persisted_attr :mileage, :formatter => :to_i
+      persisted_attr :oil_type
+      persisted_attr :is_deleted, :formatter => :to_bool
+    end
+
+    class Vehicle < ActiveRecord::Base
+      hoards :oil_change, :type => OilChangeValue, :filter => :soft_delete_filter
+
+      def soft_delete_filter(value)
+        value.is_deleted != true
+      end
+    end
+
+Now all values for the `oil_change` property will be filtered to exclude any values where `is_deleted == true`.
+
+You can also specify a class level filter for all hoards that a class might implement by using:
+
+    class Vehicle < ActiveRecord::Base
+      filter_hoards_by :soft_delete_filter
+    end
+
+This would cause all hoards to be filtered using the `soft_delete_filter`, unless this behavior was
+overridden using a `:filter` parameter on the individual hoards.
+
+If at anytime you wish to get unfiltered data from a property, you can still do that using the
+`:unfiltered` option:
+
+    vehicle.oil_change.all(:unfiltered => true) #=> unfiltered data
+
 ##### Ignoring unchanged values
 
 There may be a case where we don't need to track history when a value is set, but is the same as the
@@ -236,7 +272,7 @@ To test Plyushkin configuration in your model:
 
     describe Vehicle do
       it { should hoard(:mechanic) }
-      it { should hoard(:mechanic).and_ignore_unchanged_values }
+      it { should hoard(:mechanic).and_ignore_unchanged_values } 
       it { should hoard(:oil_change).of_type(OilChangeValue) }
       it { should hoard(:oil_change).of_type(OilChangeValue).
         and_after_create_call(:calculate_next_oil_change_mileage) }

data/lib/plyushkin/base_value.rb

@@ -74,7 +74,7 @@ class Plyushkin::BaseValue
   end
 
   def to_i(value)
-    value =~ /\A\d+\Z/ ? value.to_i : value
+    value =~ /\A\d+(\.\d+)?\Z/ ? value.to_i : value
   end
 
   #TODO: Maybe this can be nicer.

data/lib/plyushkin/core_ext/active_record_base.rb

@@ -9,6 +9,13 @@ ActiveRecord::Base.instance_eval do
 
     plyushkin_model.register(name, opts[:type] || Plyushkin::StringValue, opts)
     plyushkin_model.register_callback(name, :after_create, opts[:after_create]) if opts[:after_create]
+    plyushkin_model.register_filter(name, opts[:filter]) if opts[:filter]
+  end
+
+  def filter_hoards_by(filter)
+    initialize_plyushkin
+
+    plyushkin_model.hoarding_filter = filter
   end
 
   def initialize_plyushkin

data/lib/plyushkin/core_ext/plyushkin_extensions.rb

@@ -17,6 +17,13 @@ module PlyushkinExtensions
       end
     end
 
+    self.class.plyushkin_model.registered_types.each do |name, type|
+      filter = self.class.plyushkin_model.filters[name] || self.class.plyushkin_model.hoarding_filter
+      plyushkin.register_filter(name) do |value|
+        (filter && filter.is_a?(Symbol)) ? send(filter, value) : filter.call(value)
+      end if filter
+    end
+
     plyushkin.load(id)
   end
 

data/lib/plyushkin/model.rb

@@ -1,5 +1,6 @@
 class Plyushkin::Model
   attr_reader :service, :name, :cache
+  attr_accessor :hoarding_filter
 
   def initialize(service, name, cache)
     raise Plyushkin::Error.new <<-ERROR unless service
@@ -10,19 +11,24 @@ class Plyushkin::Model
     @types                   = {}
     @ignore_unchanged_values = {}
     @callbacks               = {}
+    @filters                 = {}
     @name                    = name
     @cache                   = cache
   end
 
-  def register(name, type, opts={})
-    @types[name]            = type 
-    @ignore_unchanged_values[name] = opts[:ignore_unchanged_values] 
+  def register(name, type, opts = {})
+    @types[name]                   = type
+    @ignore_unchanged_values[name] = opts[:ignore_unchanged_values]
   end
 
   def register_callback(name, callback, method_sym)
     @callbacks[name] = { callback => method_sym }
   end
 
+  def register_filter(name, method_sym)
+    @filters[name] = method_sym
+  end
+
   def registered_types
     @types.dup
   end
@@ -34,4 +40,8 @@ class Plyushkin::Model
   def ignore_unchanged_values
     @ignore_unchanged_values.dup
   end
+
+  def filters
+    @filters.dup
+  end
 end

data/lib/plyushkin/persistence.rb

@@ -3,6 +3,7 @@ class Plyushkin::Persistence
   def initialize(model)
     @model = model
     @callbacks = {}
+    @filters = {}
   end
 
   def properties
@@ -26,8 +27,9 @@ class Plyushkin::Persistence
     @properties = {}
     cached(id).each do |name, values|
       property = Plyushkin::Property.load(name, model.registered_types[name.to_sym], values,
-                                           :callbacks               => @callbacks[name.to_sym],
-                                           :ignore_unchanged_values => @model.ignore_unchanged_values[name.to_sym] )
+                                          :callbacks               => @callbacks[name.to_sym],
+                                          :ignore_unchanged_values => model.ignore_unchanged_values[name.to_sym],
+                                          :filter                  => @filters[name.to_sym])
       @properties[name.to_sym] = property
     end if id
     add_missing_properties
@@ -37,6 +39,10 @@ class Plyushkin::Persistence
     @callbacks[name] = { callback => block }
   end
 
+  def register_filter(name, &block)
+    @filters[name] = block
+  end
+
   private
   def model
     @model
@@ -60,7 +66,8 @@ class Plyushkin::Persistence
       property = Plyushkin::Property.new(name, 
                                          :type                    => model.registered_types[name],
                                          :callbacks               => @callbacks[name],
-                                         :ignore_unchanged_values => @model.ignore_unchanged_values[name])
+                                         :ignore_unchanged_values => model.ignore_unchanged_values[name],
+                                         :filter                  => @filters[name])
       @properties[name] = property
     end
   end

data/lib/plyushkin/property.rb

@@ -11,12 +11,13 @@ class Plyushkin::Property
     end unless last.valid?
   end
 
-  def initialize(name, opts={})
-    @values           = []
-    @value_type       = opts[:type]
-    @callbacks        = opts[:callbacks]
+  def initialize(name, opts = {})
+    @values                  = []
+    @value_type              = opts[:type]
+    @callbacks               = opts[:callbacks]
+    @filter                  = opts[:filter]
     @ignore_unchanged_values = opts[:ignore_unchanged_values]
-    @name             = name.to_s
+    @name                    = name.to_s
   end
 
   def create(attr={})
@@ -42,8 +43,8 @@ class Plyushkin::Property
     @callbacks.fetch(sym, DEFAULT_CALLBACK).call if @callbacks
   end
 
-  def all
-    @values
+  def all(opts = {})
+    (@filter && !opts[:unfiltered]) ? @values.select(&@filter) : @values
   end
 
   def last

data/lib/plyushkin/version.rb

@@ -1,3 +1,3 @@
 module Plyushkin
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/lib/base_value_spec.rb

@@ -138,6 +138,10 @@ describe Plyushkin::BaseValue do
       it 'should return nil when arg is nil' do
         Plyushkin::BaseValue.new.to_i(nil).should be_nil
       end
+
+      it 'should return an integer when arg is a float' do
+        Plyushkin::BaseValue.new.to_i("2.0").should == 2
+      end
     end
 
     describe '#to_f' do

data/spec/lib/core_ext/active_record_base_spec.rb

@@ -104,6 +104,124 @@ describe ActiveRecord::Base do
 
     end
 
+    describe 'filter option' do
+      it 'should filter results when a filter is specified' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :test_value, :filter => Proc.new{ |v| v.value > 5 }
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+      end
+
+      it 'should filter results when a filter is specified as a symbol' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :test_value, :filter => :filter_by
+
+          def filter_by(value)
+            value.value > 5
+          end
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+      end
+    end
+
+    describe 'class level filter for plyushkin' do
+      it 'should filter all hoards if no filter is specified' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          filter_hoards_by :filter_by
+          hoards :test_value
+          hoards :bacon
+
+          def filter_by(value)
+            value.value > 5
+          end
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+
+        member.bacon.create(:value => 4)
+        member.bacon.all.should == []
+      end
+
+      it 'should filter all hoards if no filter is specified' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :test_value
+          hoards :bacon
+          filter_hoards_by :filter_by
+
+          def filter_by(value)
+            value.value > 5
+          end
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+
+        member.bacon.create(:value => 4)
+        member.bacon.all.should == []
+      end
+
+      it 'filter should override class level filter' do 
+        clazz = Class.new(Plyushkin::Test::Member) do
+          filter_hoards_by :filter_by
+          hoards :test_value
+          hoards :bacon, :filter => Proc.new {|v| v.value == 4}
+
+          def filter_by(value)
+            value.value > 5
+          end
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+
+        bacon_value = member.bacon.create(:value => 4)
+        member.bacon.all.should ==  [ bacon_value ]
+
+      end
+
+      it 'filter should override class level filter' do 
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :test_value
+          hoards :bacon, :filter => Proc.new {|v| v.value == 4}
+          filter_hoards_by :filter_by
+
+          def filter_by(value)
+            value.value > 5
+          end
+        end
+
+        member = clazz.new
+        member.test_value.create(:value => 3)
+        value = member.test_value.create(:value => 9)
+
+        member.test_value.all.should == [ value ]
+
+        bacon_value = member.bacon.create(:value => 4)
+        member.bacon.all.should ==  [ bacon_value ]
+
+      end
+    end
+
     describe '#validates' do
       it 'should not be valid if hoarding property is not valid' do
         clazz = Class.new(Plyushkin::Test::Member) do

data/spec/lib/property_spec.rb

@@ -157,6 +157,20 @@ describe Plyushkin::Property do
       value2 = property.create(:value => 7, :date => DateTime.now - 7.days)
       property.all.should == [ value2, value1 ]
     end
+
+    it 'should apply a default filter, if defined' do
+      property = Plyushkin::Property.new(:property_name, :filter => Proc.new { |v| v.value > 5 })
+      value1 = property.create(:value => 5, :date => DateTime.now - 5.days)
+      value2 = property.create(:value => 7, :date => DateTime.now - 7.days)
+      property.all.should == [ value2 ]
+    end
+
+    it 'should return all data if :unfiltered => true' do
+      property = Plyushkin::Property.new(:property_name, :filter => Proc.new { |v| v.value > 5 })
+      value1 = property.create(:value => 5, :date => DateTime.now - 5.days)
+      value2 = property.create(:value => 7, :date => DateTime.now - 7.days)
+      property.all(:unfiltered => true).should == [ value2, value1 ]
+    end
   end
 
   describe '#last' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plyushkin
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord