plyushkin 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle
+.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in plyushkin.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'timecop'
+  gem 'pry-nav'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    plyushkin (0.0.1)
+      activerecord (~> 3.2.12)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (3.2.16)
+      activesupport (= 3.2.16)
+      builder (~> 3.0.0)
+    activerecord (3.2.16)
+      activemodel (= 3.2.16)
+      activesupport (= 3.2.16)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.16)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    method_source (0.8.2)
+    multi_json (1.8.4)
+    pry (0.9.12.4)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-nav (0.2.3)
+      pry (~> 0.9.10)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    slop (3.4.7)
+    sqlite3 (1.3.8)
+    timecop (0.7.1)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  plyushkin!
+  pry-nav
+  rake
+  rspec
+  sqlite3
+  timecop

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Craig Israel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Plyushkin
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'plyushkin'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install plyushkin
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/plyushkin.rb

@@ -0,0 +1,15 @@
+require "plyushkin/version"
+require "active_record"
+
+module Plyushkin; end
+path = File.dirname(File.expand_path(__FILE__)) 
+require path + "/plyushkin/base_value"
+require path + "/plyushkin/string_value"
+require path + "/plyushkin/nil_value"
+require path + "/plyushkin/property"
+require path + "/plyushkin/model"
+require path + "/plyushkin/service"
+require path + "/plyushkin/persistence"
+require path + "/plyushkin/validators/presence"
+require path + "/plyushkin/core_ext/plyushkin_extensions"
+require path + "/plyushkin/core_ext/active_record_base"

data/lib/plyushkin/base_value.rb

@@ -0,0 +1,59 @@
+class Plyushkin::BaseValue
+  include ActiveModel::Validations
+
+  def initialize(attr={})
+    attr   = attr.dup
+    @date  = attr.delete(:date) || DateTime.current
+    attr.each do |k,v|
+      send("#{k}=", v) if respond_to?("#{k}=")
+    end
+  end
+
+  def self.persisted_attr(*attributes)
+    opts = attributes.last.is_a?(Hash) ? attributes.pop : {}
+    names = attributes
+    formatter = opts[:formatter]
+
+    persisted_attributes.concat(names)
+    attr_writer *names
+    names.each do |name|
+      define_method(name) do
+        value = instance_variable_get("@#{name}")
+        if formatter
+          send(formatter, value)
+        else
+          value
+        end
+      end
+    end
+  end
+
+  def self.persisted_attributes
+    if self.superclass == Object
+      @persisted_attributes ||= []
+    else
+      @persisted_attributes ||= superclass.persisted_attributes.dup
+    end
+  end
+
+ persisted_attr :date
+  validates_each :date do |record, attr_name, value|
+    record.errors.add(attr_name, "cannot be in the future") unless value < DateTime.now
+  end
+
+  def equal_value?(other)
+    self.class.persisted_attributes.each do |attribute|
+      return false if attribute != :date && send(attribute) != other.send(attribute)
+    end
+    true
+  end
+
+  def to_i(value)
+    value.to_i
+  end
+
+  def to_date(value)
+    value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+end

data/lib/plyushkin/core_ext/active_record_base.rb

@@ -0,0 +1,27 @@
+ActiveRecord::Base.instance_eval do
+  def hoards(name, opts = {})
+    initialize_plyushkin
+
+    define_method(name) do
+      plyushkin.properties[name]
+    end
+    validates name, :plyushkin => true
+
+    plyushkin_model.register(name, opts[:type], opts)
+    plyushkin_model.register_callback(name, :after_create, opts[:after_create]) if opts[:after_create]
+  end
+
+  def initialize_plyushkin
+    class << self 
+      def plyushkin_model
+        @plyushkin_model ||= Plyushkin::Model.new(Plyushkin::Service::Stub.new)
+      end
+    end
+
+    include PlyushkinExtensions
+
+    after_initialize :load_plyushkin
+    after_save :save_plyushkin
+  end
+end
+

data/lib/plyushkin/core_ext/plyushkin_extensions.rb

@@ -0,0 +1,26 @@
+module PlyushkinExtensions
+  def reload(options=nil)
+    plyushkin.load(id)
+    super
+  end
+
+  def plyushkin
+    @plyushkin ||= Plyushkin::Persistence.new(self.class.plyushkin_model)
+  end
+
+  def load_plyushkin
+    self.class.plyushkin_model.callbacks.each do |name,callbacks|
+      callbacks.each do |callback, handler|
+        plyushkin.register_callback(name, callback) do
+          (handler && handler.is_a?(Symbol)) ? send(handler) : handler.call
+        end
+      end
+    end
+
+    plyushkin.load(id)
+  end
+
+  def save_plyushkin
+    plyushkin.save(id)
+  end
+end

data/lib/plyushkin/model.rb

@@ -0,0 +1,35 @@
+class Plyushkin::Model
+
+  def initialize(service)
+    @service          = service
+    @types            = {}
+    @ignore_unchanged_values = {}
+    @callbacks        = {}
+  end
+
+  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 registered_types
+    @types.dup
+  end
+
+  def callbacks
+    @callbacks.dup
+  end
+
+  def ignore_unchanged_values
+    @ignore_unchanged_values.dup
+  end
+
+  def service
+    @service
+  end
+
+end

data/lib/plyushkin/nil_value.rb

@@ -0,0 +1,9 @@
+class Plyushkin::NilValue
+  def method_missing(sym, *args)
+    return nil
+  end
+
+  def valid?
+    true
+  end
+end

data/lib/plyushkin/persistence.rb

@@ -0,0 +1,50 @@
+class Plyushkin::Persistence
+
+  def initialize(model)
+    @model = model
+    @callbacks = {}
+  end
+
+  def properties
+    @properties
+  end
+
+  def save(id)
+    hash = {}
+    (@properties || {}).each do |name, property|
+      hash[name] = [property.value_hashes]
+    end
+    model.service.put(id, hash.to_json)
+  end
+
+  def load(id)
+    @properties = {}
+    model.service.get(id).each do |name, values| 
+      property = Plyushkin::Property.build(name, model.registered_types[name.to_sym], values,
+                                         :callbacks               => @callbacks[name.to_sym],
+                                         :ignore_unchanged_values => @model.ignore_unchanged_values[name.to_sym] )
+      @properties[name.to_sym] = property
+    end
+    add_missing_properties
+  end
+
+  def register_callback(name, callback, &block)
+    @callbacks[name] = { callback => block }
+  end
+
+  private 
+  def model
+    @model
+  end
+
+  def add_missing_properties
+    (model.registered_types.keys - @properties.keys).each do |name|
+      property = Plyushkin::Property.new(name, 
+                                        :type                    => model.registered_types[name],
+                                        :callbacks               => @callbacks[name],
+                                        :ignore_unchanged_values => @model.ignore_unchanged_values[name])
+      @properties[name] = property
+    end
+  end
+
+end

data/lib/plyushkin/property.rb

@@ -0,0 +1,76 @@
+class Plyushkin::Property
+  include ActiveModel::Validations
+
+  DEFAULT_CALLBACK = lambda{}
+
+  attr_reader :name
+
+  validate do |property|
+    last.errors.full_messages.each do |message|
+      errors[:base] << "#{name.camelize}: #{message}"
+    end unless last.valid?
+  end
+
+  def initialize(name, opts={})
+    @values           = []
+    @value_type       = opts[:type]
+    @callbacks        = opts[:callbacks]
+    @ignore_unchanged_values = opts[:ignore_unchanged_values]
+    @name             = name.to_s
+  end
+
+  def create(attr={})
+    value = value_type.new(attr)
+    if @ignore_unchanged_values
+      last = @values.last
+      return last if last && last.equal_value?(value)
+    end
+
+    @values.insert(insert_position(value.date), value)
+    trigger_callback(:after_create)
+    value
+  end
+
+  def trigger_callback(sym)
+    @callbacks.fetch(sym, DEFAULT_CALLBACK).call if @callbacks
+  end
+
+  def all
+    @values
+  end
+
+  def last
+    @values.last || Plyushkin::NilValue.new
+  end
+
+  def empty?
+    @values.empty?
+  end
+
+  def insert_position(datetime)
+    index = @values.rindex{|v| v.date < datetime}
+    index.nil? ? 0 : index + 1
+  end
+
+  def value_type
+    @value_type ||= Plyushkin::StringValue
+  end
+
+  def self.build(name, type, values, opts={})
+    opts[:type] = type
+    Plyushkin::Property.new(name, opts).tap do |p|
+      values.each { |value| p.create(value) }
+    end
+  end
+
+  def value_hashes
+    value_hashes = {}
+    all.each do |value|
+      value_type.persisted_attributes.each do |attr|
+        value_hashes[attr] = value.send(attr) 
+      end
+    end
+
+    value_hashes
+  end
+end

data/lib/plyushkin/service.rb

@@ -0,0 +1,3 @@
+module Plyushkin::Service; end
+
+require File.dirname(File.expand_path(__FILE__)) + "/service/stub"

data/lib/plyushkin/service/stub.rb

@@ -0,0 +1,15 @@
+class Plyushkin::Service::Stub
+
+  def initialize
+    @store = {}
+  end
+
+  def get(id)
+    JSON.parse(@store[id] || "{}")
+  end
+
+  def put(id, json)
+    @store[id] = json
+  end
+
+end

data/lib/plyushkin/string_value.rb

@@ -0,0 +1,3 @@
+class Plyushkin::StringValue < Plyushkin::BaseValue
+  persisted_attr :value
+end

data/lib/plyushkin/test.rb

@@ -0,0 +1 @@
+require File.dirname(File.expand_path(__FILE__)) + "/test/value_types.rb"

data/lib/plyushkin/test/value_types.rb

@@ -0,0 +1,17 @@
+module Plyushkin::Test
+  class Plyushkin::Test::PresenceTestValue < Plyushkin::BaseValue
+    persisted_attr :value
+    validates :value, :presence => true
+  end
+
+  class Plyushkin::Test::CoordinateValue < Plyushkin::BaseValue
+    persisted_attr :x, :y
+    validates :x, :y, :presence => true
+  end
+
+  class Plyushkin::Test::Member < ActiveRecord::Base; end
+
+  class Plyushkin::Test::DateValue < Plyushkin::BaseValue
+    persisted_attr :value, :formatter => :to_date
+  end
+end

data/lib/plyushkin/validators/presence.rb

@@ -0,0 +1,5 @@
+class PlyushkinValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, property)
+    record.errors.add(attr_name, :valid, options) unless property.valid?
+  end
+end

data/lib/plyushkin/version.rb

@@ -0,0 +1,3 @@
+module Plyushkin
+  VERSION = "0.0.1"
+end

data/plyushkin.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'plyushkin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "plyushkin"
+  spec.version       = Plyushkin::VERSION
+  spec.authors       = ["Craig Israel", "Jeremy Hinkle"]
+  spec.email         = ["craig@theisraels.net", "jchinkle@gmail.com"]
+  spec.description   = %q{Provides active record extension to capture historical property data}
+  spec.summary       = %q{Plyushkin - the attribute hoarder}
+  spec.homepage      = "http://github.com/OnlifeHealth/plyushkin"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 3.2.12"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/lib/base_value_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Plyushkin::BaseValue do
+  describe '#valid?' do
+    it 'should not be valid user-defined value if validations fail' do
+      value = Plyushkin::Test::CoordinateValue.new
+      value.valid?
+      value.errors.count.should == 2
+    end
+
+    it 'should be valid user-defined value if validations pass' do
+      value = Plyushkin::Test::CoordinateValue.new(:x => 5, :y => 10)
+      value.valid?
+      value.errors.count.should == 0
+    end
+
+    it 'should not be valid if date is in the future' do
+      value = Plyushkin::StringValue.new(:date => 2.days.from_now)
+      value.should_not be_valid
+      value.errors.full_messages.should == ["Date cannot be in the future"]
+    end
+  end
+
+  describe '##persisted_attr' do
+    it 'should add attribute to persisted_attributes' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr
+      end
+
+      clazz.persisted_attributes.should == [ :date, :my_attr ]
+    end
+
+    it 'should add attributes to persisted_attributes when called multiple times' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr
+        persisted_attr :my_other_attr
+      end
+
+      clazz.persisted_attributes.should == [ :date, :my_attr, :my_other_attr ]
+    end
+
+    it 'should add attributes to persisted_attributes when called with multiple attributes' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr, :my_other_attr
+      end
+
+      clazz.persisted_attributes.should == [ :date, :my_attr, :my_other_attr ]
+    end
+
+    it 'should add reader and writer for attribute' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr
+      end
+
+      value = clazz.new
+      value.my_attr = 5
+      value.my_attr.should == 5
+    end
+
+    it "should format value readers using format methods when specified" do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr, :formatter => :to_i
+      end
+
+      value = clazz.new
+      value.my_attr = "5"
+      value.my_attr.should == 5
+    end
+    
+    it "should format multiple value readers using format methods when specified" do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr, :my_attr2, :formatter => :to_i
+      end
+
+      value = clazz.new
+      value.my_attr = "5"
+      value.my_attr2 = "9999"
+      value.my_attr.should == 5
+      value.my_attr2.should == 9999
+    end
+
+    describe '#to_date' do
+      it 'format a json string to a date' do
+        value = Plyushkin::BaseValue.new
+        now = DateTime.now
+        value.to_date(now.to_json).should === now
+      end
+    end
+
+  end
+
+  describe '#equal_value' do
+    it 'should test equality of persisted_attributes' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr, :my_attr2
+      end
+
+      value1 = clazz.new
+      value1.my_attr = 5
+      value1.my_attr2 = "test"
+
+      value2 = clazz.new
+      value2.my_attr = 5
+      value2.my_attr2 = "test"
+
+      value1.equal_value?(value2).should  be_true
+    end
+
+    it 'should be true if dates are different' do
+      clazz = Class.new(Plyushkin::BaseValue) do
+        persisted_attr :my_attr, :my_attr2
+      end
+
+      value1 = clazz.new
+      value1.my_attr = 5
+      value1.my_attr2 = "test"
+      value1.date = DateTime.now - 3.days
+
+      value2 = clazz.new
+      value2.my_attr = 5
+      value2.my_attr2 = "test"
+      value2.date = DateTime.now - 5.days
+
+      value1.equal_value?(value2).should  be_true
+
+    end
+  end
+end

data/spec/lib/core_ext/active_record_base_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe ActiveRecord::Base do
+  describe '##hoards' do
+    describe 'read' do
+      it 'should return the same property instance when called multiple times' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :login_date
+        end
+
+        member   = clazz.new
+        property = member.login_date
+        property.class.should == Plyushkin::Property
+        property.should       == member.login_date
+      end
+
+      it 'should register a type for a hoarding property with persistence class' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :login_date
+          hoards :geolocation, :type => Plyushkin::Test::CoordinateValue
+        end
+
+        clazz.plyushkin_model.registered_types[:login_date].should be_nil
+        clazz.plyushkin_model.registered_types[:geolocation].should == Plyushkin::Test::CoordinateValue
+      end
+
+      it 'should allow specifying value type' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :geolocation, :type => Plyushkin::Test::CoordinateValue
+        end
+
+        member = clazz.new
+        property = member.geolocation
+        property.value_type.should == Plyushkin::Test::CoordinateValue
+      end
+    end
+
+    describe 'after_create option' do
+      it 'should call method specified by option after property create is called' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          attr_accessor :login_date_created_called
+          hoards :login_date, :after_create => :login_date_created
+
+          def login_date_created
+            self.login_date_created_called = true
+          end
+        end
+
+        member = clazz.new
+        member.login_date.create :value => DateTime.now
+        member.login_date_created_called.should be_true
+      end
+
+      it 'should call method specified by option after property create is called for the property named' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          attr_accessor :login_date_created_called, :other_prop_created_called
+
+          hoards :login_date, :after_create => :login_date_created
+          hoards :other_prop, :after_create => :other_prop_created
+
+          def login_date_created
+            self.login_date_created_called = true
+          end
+
+          def other_prop_created
+            self.other_prop_created_called = true
+          end
+        end
+
+        member = clazz.new
+        member.other_prop.create :value => DateTime.now
+        member.other_prop_created_called.should be_true
+        member.login_date_created_called.should be_false
+      end
+    end
+
+    describe 'ignore_unchanged_value option' do
+      it 'should not add a value when ignore_unchanged_value is true and value is the same as the last value' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :login_date, :ignore_unchanged_values => true
+        end
+
+        member = clazz.new
+        now = DateTime.now
+        member.login_date.create(:value => now)
+        member.login_date.create(:value => now)
+
+        member.login_date.all.length.should == 1
+      end
+
+    end
+
+    describe '#validates' do
+      it 'should not be valid if hoarding property is not valid' do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :geolocation, :type => Plyushkin::Test::CoordinateValue
+        end
+        clazz.stub(:model_name).and_return(ActiveModel::Name.new(clazz, nil, "test"))
+
+        member = clazz.new
+        member.geolocation.create(:x => 5)
+        member.should_not be_valid
+        member.errors.messages[:geolocation].count.should == 1
+      end
+    end
+
+    describe '#save' do
+      let(:clazz) do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :login_date, :type => Plyushkin::Test::DateValue
+        end
+      end
+
+      it 'should load plyushkin persistence after find is called' do
+        member1 = clazz.new
+        now = DateTime.now
+        member1.login_date.create(:value => now)
+        member1.save!
+
+        member2 = clazz.find(member1.id)
+        member2.login_date.last.value.should === now
+      end
+
+      it 'should save hoarding property by id' do
+        member1 = clazz.new
+        now = DateTime.now
+        later = DateTime.now + 5
+        member1.login_date.create(:value => now)
+        member1.save!
+
+        member2 = clazz.new
+        member2.login_date.create(:value => later)
+        member2.save!
+        
+        member1.reload.login_date.last.value.should === now
+        member2.reload.login_date.last.value.should === later
+      end
+    end
+
+    describe '#reload' do
+      let(:clazz) do
+        clazz = Class.new(Plyushkin::Test::Member) do
+          hoards :login_date, :type => Plyushkin::Test::DateValue
+        end
+      end
+
+      it 'should reload new data from persisted store' do
+        member = clazz.new
+        now = DateTime.now
+        member.login_date.create(:value => now)
+        member.save!
+        member.login_date.create(:value => now + 5)
+
+        member.reload
+        member.login_date.last.value.should === now
+      end
+    end
+
+  end
+end

data/spec/lib/nil_value_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Plyushkin::NilValue do
+  it "should return nil for everything" do
+    n = Plyushkin::NilValue.new
+    n.steve_sucks.should be_nil
+    n.apple.should be_nil
+    n.value.should be_nil
+    n.date.should be_nil
+  end
+end

data/spec/lib/persistence_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Plyushkin::Persistence do
+  let(:service) do
+    service = Plyushkin::Service::Stub.new
+    service.put(1,
+      { :name   => [{ :value => "Steve" }] ,
+        :weight => [{ :value => 150 }],
+        :udt    => [{ :x => 10, :y => 20 }]
+      }.to_json)
+    service
+  end
+
+  let(:model) do
+    m = Plyushkin::Model.new(service)
+    m.register(:name,   Plyushkin::StringValue)
+    m.register(:weight, Plyushkin::StringValue)
+    m.register(:udt,    Plyushkin::Test::CoordinateValue)
+    m
+  end
+
+  let(:persistence) do
+    p = Plyushkin::Persistence.new(model)
+    p.load(1)
+    p
+  end
+
+  describe '#properties' do
+
+    it 'should allow access to properties' do
+      persistence.properties.length.should == 3
+    end
+  end
+
+  describe '#save' do
+    it 'should save to source that load uses' do
+      persistence.properties[:name].create(:value => "Mike")
+      persistence.save(1)
+      persistence.load(1)
+      persistence.properties[:name].last.value.should == "Mike"
+    end
+  end
+
+  describe '#load' do
+    it 'should parse json into an hash of properties' do
+      persistence.load(1)
+      property = persistence.properties[:name]
+      property.class.should == Plyushkin::Property
+      property.last.value.should == "Steve"
+    end
+
+    it 'should parse json for a user-defined type' do
+      persistence.load(1)
+      property = persistence.properties[:udt]
+      property.last.x.should == 10
+      property.last.y.should == 20
+    end
+
+    it 'should parse all history for a property' do
+      service.put(1,
+        {
+          :name => [
+            { :value => "Ms. Julie Jones",  :date => DateTime.now - 2.days },
+            { :value => "Mrs. Julie Smith", :date => DateTime.now - 3.days }
+          ]
+      }.to_json)
+
+      property = persistence.properties[:name]
+      property.all.length.should == 2
+      property.all[0].value.should == "Mrs. Julie Smith"
+      property.all[1].value.should == "Ms. Julie Jones"
+    end
+
+    it "should add an empty array for a property that isn't returned from service" do
+      model.register(:missing_property, Plyushkin::StringValue)
+      persistence.properties[:missing_property].all.should == []
+    end
+  end
+end

data/spec/lib/property_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Plyushkin::Property do
+  describe '#create' do
+    it 'should add a StringValue' do
+      property = Plyushkin::Property.new(:property_name)
+      value = property.create(:value => 5)
+      value.class.should == Plyushkin::StringValue
+    end
+
+    it 'should pass the attributes to the simple value' do
+      property = Plyushkin::Property.new(:property_name)
+      date     = DateTime.now - 3.days
+      value    = property.create(:value => 5, :date => date)
+      value.value.should == 5
+      value.date.should  == date
+    end
+
+    it 'should add a user-defined value' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::CoordinateValue)
+      value    = property.create(:x => 5, :y => 10)
+      value.class.should == Plyushkin::Test::CoordinateValue
+      value.x.should     == 5
+      value.y.should     == 10
+    end
+
+    describe 'callbacks' do
+      it 'should call after_create callback after create' do
+        called = 0
+        callbacks = { :after_create => lambda{ called += 1 } }
+        property = Plyushkin::Property.new(:property_name, :callbacks => callbacks)
+        property.create(:value => 5)
+        called.should == 1
+        property.last.value.should == 5
+      end
+
+      it 'should not require an after_create callback' do
+        called = 0
+        callbacks = { :before_create => lambda{ called += 1 } }
+        property = Plyushkin::Property.new(:property_name, :callbacks => callbacks)
+        property.create(:value => 5)
+        called.should == 0
+      end
+    end
+
+    describe 'ignore_unchanged_value' do
+      it 'should not add a value when ignore_unchanged_value is true and value does not change' do
+        property = Plyushkin::Property.new(:property_name, :ignore_unchanged_values => true)
+        property.create(:value => 5)
+        property.create(:value => 5)
+        property.all.length.should == 1
+      end
+    end
+  end
+
+  describe '#all' do
+    it 'should return an array of all created values' do
+      property = Plyushkin::Property.new(:property_name)
+      value1 = property.create(:value => 5)
+      value2 = property.create(:value => 7)
+      property.all.should == [ value1, value2 ]
+    end
+
+    it 'should be sorted by value class date' do
+      property = Plyushkin::Property.new(:property_name)
+      value1 = property.create(:value => 5, :date => DateTime.now - 5.days)
+      value2 = property.create(:value => 7, :date => DateTime.now - 7.days)
+      property.all.should == [ value2, value1 ]
+    end
+  end
+
+  describe '#last' do
+    it 'should return the most-recently added value' do
+      property = Plyushkin::Property.new(:property_name)
+      value1 = property.create(:value => 5)
+      value2 = property.create(:value => 7)
+      property.last.should == value2
+    end
+
+    it 'should return a new value if there are no values' do
+      property = Plyushkin::Property.new(:property_name)
+      property.last.should be_a(Plyushkin::NilValue)
+    end
+  end
+
+  describe '#valid?' do
+    it 'should be valid if no values exist' do
+      property = Plyushkin::Property.new(:property_name)
+      property.should be_valid
+    end
+
+    it 'should be valid if last is valid and other values in array are not valid' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::PresenceTestValue)
+      value1 = property.create
+      value2 = property.create(:value => 5)
+      property.should be_valid
+    end
+
+    it 'should not be valid if last is not valid' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::PresenceTestValue)
+      value1 = property.create(:value => 5)
+      value2 = property.create
+      property.should_not be_valid
+    end
+
+    it 'should populate errors from values when not valid' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::PresenceTestValue)
+      property.create
+      property.valid?
+      property.errors.full_messages.should == [ "PropertyName: Value can't be blank" ]
+    end
+  end
+
+  describe '#empty?' do
+    it 'should return true if no values were created' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::PresenceTestValue)
+      property.should be_empty
+    end
+
+    it 'should return false if values were not created' do
+      property = Plyushkin::Property.new(:property_name, :type => Plyushkin::Test::PresenceTestValue)
+      property.create
+      property.should_not be_empty
+    end
+  end
+
+  it '#insert_position' do
+    property = Plyushkin::Property.new(:property_name)
+    value1 = property.create(:value => 7, :date => DateTime.now - 7.days)
+    value2 = property.create(:value => 5, :date => DateTime.now - 5.days)
+    property.insert_position(DateTime.now).should == 2
+    property.insert_position(DateTime.now - 6.days).should == 1
+    property.insert_position(DateTime.now - 8.days).should == 0
+  end
+
+end

data/spec/lib/value_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Plyushkin::StringValue do
+  describe '#new' do
+    it 'should allow storing an integer' do
+      val = Plyushkin::StringValue.new(:value => 5)
+      val.value.should == 5
+    end
+
+    it 'should allow storing a string' do
+      val = Plyushkin::StringValue.new(:value => 'test')
+      val.value.should == 'test'
+    end
+
+    it 'should use current if not specified' do
+      Timecop.freeze do
+        val = Plyushkin::StringValue.new(:value => 5)
+        val.date.should == DateTime.current
+      end
+    end
+
+    it 'should use provided date if specified' do
+      date = DateTime.new(2013, 12, 20)
+      val  = Plyushkin::StringValue.new(:value => 5, :date => date)
+      val.date.should == date
+    end
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+path = File.dirname(File.expand_path(__FILE__))
+require path + '/../lib/plyushkin'
+require path + '/../lib/plyushkin/test'
+Dir[path + "/support/**/*.rb"].each{ |f| require f }
+
+require 'timecop'
+require 'pry'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+

data/spec/support/sqlite.rb

@@ -0,0 +1,12 @@
+# Add sqlite
+I18n.enforce_available_locales = false
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+class CreateMembers < ActiveRecord::Migration
+  def self.up
+    create_table :members do |t|
+      t.timestamps
+    end
+  end
+end
+CreateMembers.up

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: plyushkin
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Craig Israel
+- Jeremy Hinkle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides active record extension to capture historical property data
+email:
+- craig@theisraels.net
+- jchinkle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/plyushkin.rb
+- lib/plyushkin/base_value.rb
+- lib/plyushkin/core_ext/active_record_base.rb
+- lib/plyushkin/core_ext/plyushkin_extensions.rb
+- lib/plyushkin/model.rb
+- lib/plyushkin/nil_value.rb
+- lib/plyushkin/persistence.rb
+- lib/plyushkin/property.rb
+- lib/plyushkin/service.rb
+- lib/plyushkin/service/stub.rb
+- lib/plyushkin/string_value.rb
+- lib/plyushkin/test.rb
+- lib/plyushkin/test/value_types.rb
+- lib/plyushkin/validators/presence.rb
+- lib/plyushkin/version.rb
+- plyushkin.gemspec
+- spec/lib/base_value_spec.rb
+- spec/lib/core_ext/active_record_base_spec.rb
+- spec/lib/nil_value_spec.rb
+- spec/lib/persistence_spec.rb
+- spec/lib/property_spec.rb
+- spec/lib/value_spec.rb
+- spec/spec_helper.rb
+- spec/support/sqlite.rb
+homepage: http://github.com/OnlifeHealth/plyushkin
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Plyushkin - the attribute hoarder
+test_files:
+- spec/lib/base_value_spec.rb
+- spec/lib/core_ext/active_record_base_spec.rb
+- spec/lib/nil_value_spec.rb
+- spec/lib/persistence_spec.rb
+- spec/lib/property_spec.rb
+- spec/lib/value_spec.rb
+- spec/spec_helper.rb
+- spec/support/sqlite.rb