model_attribute 0.0.1 → 2.0.0

data/lib/model_attribute/errors.rb

@@ -0,0 +1,14 @@
+module ModelAttribute
+  class InvalidAttributeNameError < StandardError
+    def initialize(attribute_name)
+      super "Invalid attribute name #{attribute_name.inspect}"
+    end
+  end
+
+  class UnsupportedTypeError < StandardError
+    def initialize(type)
+      types_list = ModelAttribute::SUPPORTED_TYPES.map(&:inspect).join(', ')
+      super "Unsupported type #{type.inspect}. Must be one of #{types_list}."
+    end
+  end
+end

data/lib/model_attribute/json.rb

@@ -0,0 +1,27 @@
+module ModelAttribute
+  module Json
+    class << self
+      def valid?(value)
+        (value == nil         ||
+         value == true        ||
+         value == false       ||
+         value.is_a?(Numeric) ||
+         value.is_a?(String)  ||
+         (value.is_a?(Array) && valid_array?(value)) ||
+         (value.is_a?(Hash)  && valid_hash?(value) ))
+      end
+
+      private
+
+      def valid_array?(array)
+        array.all? { |value| valid?(value) }
+      end
+
+      def valid_hash?(hash)
+        hash.all? do |key, value|
+          key.is_a?(String) && valid?(value)
+        end
+      end
+    end
+  end
+end

data/lib/model_attribute/version.rb

@@ -1,3 +1,3 @@
 module ModelAttribute
-  VERSION = "0.0.1"
+  VERSION = "2.0.0"
 end

data/model_attribute.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = ModelAttribute::VERSION
   spec.authors       = ["David Waller"]
   spec.email         = ["dwaller@yammer-inc.com"]
-  spec.summary       = %q{Placeholder while clearing gem release with legal}
+  spec.summary       = %q{Attributes for non-ActiveRecord models}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -17,6 +17,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler",         "~> 1.7"
+  spec.add_development_dependency "rake",            "~> 10.0"
+  spec.add_development_dependency "rspec",           "~> 3.1"
+  spec.add_development_dependency "rspec-nc",        "~> 0.2"
+  spec.add_development_dependency "guard",           "~> 2.8"
+  spec.add_development_dependency "guard-rspec",     "~> 4.3"
+  spec.add_development_dependency "pry-debugger"
 end

data/performance_comparison.rb

@@ -0,0 +1,66 @@
+require 'benchmark'
+$LOAD_PATH << "lib"
+
+Benchmark.bm(41) do |bm|
+  bm.report("Virtus load") do
+    require 'virtus'
+
+    class VirtusUser
+      include Virtus.model
+      attribute :id,         Integer
+      attribute :name,       String
+      attribute :paid,       Boolean
+      attribute :updated_at, DateTime
+    end
+  end
+
+  bm.report("ModelAttribute load") do
+    require_relative 'lib/model_attribute'
+
+    class ModelAttributeUser
+      extend ModelAttribute
+      attribute :id,         :integer
+      attribute :name,       :string
+      attribute :paid,       :boolean
+      attribute :updated_at, :time
+    end
+  end
+end
+
+Benchmark.bm(41) do |bm|
+  vu  = VirtusUser.new
+  mau = ModelAttributeUser.new
+  bm.report("Virtus         assign integer")             { 10_000.times {  vu.id = rand(100_000) } }
+  bm.report("ModelAttribute assign integer")             { 10_000.times { mau.id = rand(100_000) } }
+  bm.report("Virtus         assign integer from string") { 10_000.times {  vu.id = rand(100_000).to_s } }
+  bm.report("ModelAttribute assign integer from string") { 10_000.times { mau.id = rand(100_000).to_s } }
+  bm.report("Virtus         assign time")                { 10_000.times {  vu.updated_at = Time.now } }
+  bm.report("ModelAttribute assign time")                { 10_000.times { mau.updated_at = Time.now } }
+  bm.report("Virtus         assign DateTime")            { 10_000.times {  vu.updated_at = DateTime.now } }
+  bm.report("ModelAttribute assign DateTime")            { 10_000.times { mau.updated_at = DateTime.now } }
+  bm.report("Virtus         assign time from epoch")     { 10_000.times {  vu.updated_at = Time.now.to_f } }
+  bm.report("ModelAttribute assign time from epoch")     { 10_000.times { mau.updated_at = Time.now.to_f } }
+  bm.report("Virtus         assign time from string")    { 10_000.times {  vu.updated_at = "2014-12-25 06:00:00" } }
+  bm.report("ModelAttribute assign time from string")    { 10_000.times { mau.updated_at = "2014-12-25 06:00:00" } }
+end
+
+__END__
+$ ruby -v
+ruby 1.9.3p545 (2014-02-24 revision 45159) [x86_64-darwin13.3.0]
+$ ruby performance_comparison.rb
+                                                user     system      total        real
+Virtus load                                0.120000   0.040000   0.160000 (  0.207931)
+ModelAttribute load                        0.020000   0.010000   0.030000 (  0.027237)
+                                                user     system      total        real
+Virtus         assign integer              0.010000   0.000000   0.010000 (  0.013906)
+ModelAttribute assign integer              0.030000   0.000000   0.030000 (  0.033674)
+Virtus         assign integer from string  0.170000   0.000000   0.170000 (  0.171892)
+ModelAttribute assign integer from string  0.050000   0.000000   0.050000 (  0.042726)
+Virtus         assign time                 0.080000   0.000000   0.080000 (  0.089792)
+ModelAttribute assign time                 0.060000   0.000000   0.060000 (  0.057887)
+Virtus         assign DateTime             0.030000   0.000000   0.030000 (  0.026447)
+ModelAttribute assign DateTime             0.200000   0.000000   0.200000 (  0.204524)
+Virtus         assign time from epoch      0.230000   0.010000   0.240000 (  0.225557)
+ModelAttribute assign time from epoch      0.110000   0.000000   0.110000 (  0.113315)
+Virtus         assign time from string     0.260000   0.000000   0.260000 (  0.264467)
+ModelAttribute assign time from string     0.450000   0.000000   0.450000 (  0.444686)

data/spec/model_attributes_spec.rb

@@ -0,0 +1,611 @@
+class User
+  extend ModelAttribute
+  attribute :id,         :integer
+  attribute :paid,       :boolean
+  attribute :name,       :string
+  attribute :created_at, :time
+  attribute :profile,    :json
+
+  def initialize(attributes = {})
+    set_attributes(attributes)
+  end
+end
+
+class UserWithoutId
+  extend ModelAttribute
+  attribute :paid,       :boolean
+  attribute :name,       :string
+  attribute :created_at, :time
+
+  def initialize(attributes = {})
+    set_attributes(attributes)
+  end
+end
+
+RSpec.describe "a class using ModelAttribute" do
+  describe ".attributes" do
+    it "returns an array of attribute names as symbols" do
+      expect(User.attributes).to eq([:id, :paid, :name, :created_at, :profile])
+    end
+  end
+
+  describe "defining an attribute with an invalid type" do
+    it "raises an error" do
+      expect do
+        User.attribute :address, :custom_type
+      end.to raise_error(ModelAttribute::UnsupportedTypeError,
+                         "Unsupported type :custom_type. " +
+                         "Must be one of :integer, :boolean, :string, :time, :json.")
+    end
+  end
+
+  describe "an instance of the class" do
+    let(:user) { User.new }
+
+    describe "an integer attribute (id)" do
+      it "is nil when unset" do
+        expect(user.id).to be_nil
+      end
+
+      it "stores an integer" do
+        user.id = 3
+        expect(user.id).to eq(3)
+      end
+
+      it "stores an integer passed as a float" do
+        user.id = 3.0
+        expect(user.id).to eq(3)
+      end
+
+      it "raises when passed a float with non-zero decimal part" do
+        expect { user.id = 3.3 }.to raise_error
+      end
+
+      it "parses an integer string" do
+        user.id = '3'
+        expect(user.id).to eq(3)
+      end
+
+      it "raises if passed a string it can't parse" do
+        expect { user.id = '3a' }.to raise_error
+      end
+
+      it "stores nil" do
+        user.id = 3
+        user.id = nil
+        expect(user.id).to be_nil
+      end
+
+      it "does not provide an id? method" do
+        expect(user).to_not respond_to(:id?)
+        expect { user.id? }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "a boolean attribute (paid)" do
+      it "is nil when unset" do
+        expect(user.paid).to be_nil
+      end
+
+      it "stores true" do
+        user.paid = true
+        expect(user.paid).to eq(true)
+      end
+
+      it "stores false" do
+        user.paid = false
+        expect(user.paid).to eq(false)
+      end
+
+      it "parses 't' as true" do
+        user.paid = 't'
+        expect(user.paid).to eq(true)
+      end
+
+      it "parses 'f' as false" do
+        user.paid = 'f'
+        expect(user.paid).to eq(false)
+      end
+
+      it "raises if passed a string it can't parse" do
+        expect { user.paid = '3a' }.to raise_error
+      end
+
+      it "stores nil" do
+        user.paid = true
+        user.paid = nil
+        expect(user.paid).to be_nil
+      end
+
+      describe "#paid?" do
+        it "returns false when unset" do
+          expect(user.paid?).to eq(false)
+        end
+
+        it "returns false for false attributes" do
+          user.paid = false
+          expect(user.paid?).to eq(false)
+        end
+
+        it "returns true for true attributes" do
+          user.paid = true
+          expect(user.paid?).to eq(true)
+        end
+      end
+    end
+
+    describe "a string attribute (name)" do
+      it "is nil when unset" do
+        expect(user.name).to be_nil
+      end
+
+      it "stores a string" do
+        user.name = 'Fred'
+        expect(user.name).to eq('Fred')
+      end
+
+      it "casts an integer to a string" do
+        user.name = 3
+        expect(user.name).to eq('3')
+      end
+
+      it "stores nil" do
+        user.name = 'Fred'
+        user.name = nil
+        expect(user.name).to be_nil
+      end
+
+      it "does not provide a name? method" do
+        expect(user).to_not respond_to(:name?)
+        expect { user.name? }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "a time attribute (created_at)" do
+      let(:now_time) { Time.now }
+
+      it "is nil when unset" do
+        expect(user.created_at).to be_nil
+      end
+
+      it "stores a Time object" do
+        user.created_at = now_time
+        expect(user.created_at).to eq(now_time)
+      end
+
+      it "parses floats as seconds past the epoch" do
+        user.created_at = now_time.to_f
+        # Going via float loses precision, so use be_within
+        expect(user.created_at).to be_within(0.0001).of(now_time)
+        expect(user.created_at).to be_a_kind_of(Time)
+      end
+
+      it "parses integers as milliseconds past the epoch" do
+        user.created_at = (now_time.to_f * 1000).to_i
+        # Truncating to milliseconds loses precision, so use be_within
+        expect(user.created_at).to be_within(0.001).of(now_time)
+        expect(user.created_at).to be_a_kind_of(Time)
+      end
+
+      it "parses strings to date/times" do
+        user.created_at = "2014-12-25 14:00:00 +0100"
+        expect(user.created_at).to eq(Time.new(2014, 12, 25, 13, 00, 00))
+      end
+
+      it "raises for unparseable strings" do
+        expect { user.created_at = "Today, innit?" }.to raise_error
+      end
+
+      it "converts Dates to Time" do
+        user.created_at = Date.parse("2014-12-25")
+        expect(user.created_at).to eq(Time.new(2014, 12, 25, 00, 00, 00))
+      end
+
+      it "converts DateTime to Time" do
+        user.created_at = DateTime.parse("2014-12-25 13:00:45")
+        expect(user.created_at).to eq(Time.new(2014, 12, 25, 13, 00, 45))
+      end
+
+      it "stores nil" do
+        user.created_at = now_time
+        user.created_at = nil
+        expect(user.created_at).to be_nil
+      end
+
+      it "does not provide a created_at? method" do
+        expect(user).to_not respond_to(:created_at?)
+        expect { user.created_at? }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "a json attribute (profile)" do
+      it "is nil when unset" do
+        expect(user.profile).to be_nil
+      end
+
+      it "stores a string" do
+        user.profile = 'Incomplete'
+        expect(user.profile).to eq('Incomplete')
+      end
+
+      it "stores an integer" do
+        user.profile = 3
+        expect(user.profile).to eq(3)
+      end
+
+      it "stores true" do
+        user.profile = true
+        expect(user.profile).to eq(true)
+      end
+
+      it "stores false" do
+        user.profile = false
+        expect(user.profile).to eq(false)
+      end
+
+      it "stores an array" do
+        user.profile = [1, 2, 3]
+        expect(user.profile).to eq([1, 2, 3])
+      end
+
+      it "stores a hash" do
+        user.profile = {'skill' => 8}
+        expect(user.profile).to eq({'skill' => 8})
+      end
+
+      it "stores nested hashes and arrays" do
+        json = {'array' => [1,
+                            2,
+                            true,
+                            {'inner' => true},
+                            ['inside', {}]
+                           ],
+                'hash'  => {'getting' => {'nested' => 'yes'}},
+                'boolean' => true
+               }
+        user.profile = json
+        expect(user.profile).to eq(json)
+      end
+
+      it "raises when passed an object not supported by JSON" do
+        expect { user.profile = Object.new }.to raise_error
+      end
+
+      it "raises when passed a hash with a non-string key" do
+        expect { user.profile = {1 => 'first'} }.to raise_error
+      end
+
+      it "raises when passed a hash with an unsupported value" do
+        expect { user.profile = {'first' => :symbol} }.to raise_error
+      end
+
+      it "raises when passed an array with an unsupported value" do
+        expect { user.profile = [1, 2, nil, :symbol] }.to raise_error
+      end
+
+      it "stores nil" do
+        user.profile = {'foo' => 'bar'}
+        user.profile = nil
+        expect(user.profile).to be_nil
+      end
+
+      it "does not provide a profile? method" do
+        expect(user).to_not respond_to(:profile?)
+        expect { user.profile? }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "#write_attribute" do
+      it "does the same casting as using the writer method" do
+        user.write_attribute(:id, '3')
+        expect(user.id).to eq(3)
+      end
+
+      it "raises an error if passed an invalid attribute name" do
+        expect do
+          user.write_attribute(:spelling_mistake, '3')
+        end.to raise_error(ModelAttribute::InvalidAttributeNameError,
+                           "Invalid attribute name :spelling_mistake")
+      end
+    end
+
+    describe "#read_attribute" do
+      it "returns the value of an attribute that has been set" do
+        user.write_attribute(:id, 3)
+        expect(user.read_attribute(:id)).to eq(user.id)
+      end
+
+      it "returns nil for an attribute that has not been set" do
+        expect(user.read_attribute(:id)).to be_nil
+      end
+
+      it "raises an error if passed an invalid attribute name" do
+        expect do
+          user.read_attribute(:spelling_mistake)
+        end.to raise_error(ModelAttribute::InvalidAttributeNameError,
+                           "Invalid attribute name :spelling_mistake")
+      end
+    end
+
+    describe "#changes" do
+      let(:changes) { user.changes }
+
+      context "for a model instance created with no attributes" do
+        it "is empty" do
+          expect(changes).to be_empty
+        end
+      end
+
+      context "when an attribute is set via a writer method" do
+        before(:each) { user.id = 3 }
+
+        it "has an entry from attribute name to [old, new] pair" do
+          expect(changes).to include(:id => [nil, 3])
+        end
+
+        context "when an attribute is set again" do
+          before(:each) { user.id = 5 }
+
+          it "shows the latest value for the attribute" do
+            expect(changes).to include(:id => [nil, 5])
+          end
+        end
+
+        context "when an attribute is set back to its original value" do
+          before(:each) { user.id = nil }
+
+          it "does not have an entry for the attribute" do
+            expect(changes).to_not include(:id)
+          end
+        end
+      end
+    end
+
+    describe "#changes_for_json" do
+      let(:changes_for_json) { user.changes_for_json }
+
+      context "for a model instance created with no attributes" do
+        it "is empty" do
+          expect(changes_for_json).to be_empty
+        end
+      end
+
+      context "when an attribute is set via a writer method" do
+        before(:each) { user.id = 3 }
+
+        it "has an entry from attribute name (as a string) to the new value" do
+          expect(changes_for_json).to include('id' => 3)
+        end
+
+        context "when an attribute is set again" do
+          before(:each) { user.id = 5 }
+
+          it "shows the latest value for the attribute" do
+            expect(changes_for_json).to include('id' => 5)
+          end
+        end
+
+        context "when an attribute is set back to its original value" do
+          before(:each) { user.id = nil }
+
+          it "does not have an entry for the attribute" do
+            expect(changes_for_json).to_not include('id')
+          end
+        end
+
+        context "if the returned hash is modified" do
+          before(:each) { user.changes_for_json.clear }
+
+          it "does not affect subsequent results from changes_for_json" do
+            expect(changes_for_json).to include('id' => 3)
+          end
+        end
+      end
+
+      it "serializes time attributes as JSON integer" do
+        user.created_at = Time.now
+        expect(changes_for_json).to include("created_at" => instance_of(Fixnum))
+      end
+    end
+
+    describe "id_changed?" do
+      context "with no changes" do
+        it "returns false" do
+          expect(user.id_changed?).to eq(false)
+        end
+      end
+
+      context "with changes" do
+        before(:each) { user.id = 3 }
+
+        it "returns true" do
+          expect(user.id_changed?).to eq(true)
+        end
+      end
+    end
+
+    describe "#attributes" do
+      let(:time_now) { Time.now }
+
+      before(:each) do
+        user.id = 1
+        user.paid = true
+        user.created_at = time_now
+      end
+
+      it "returns a hash including each set attribute" do
+        expect(user.attributes).to include(id: 1, paid: true, created_at: time_now)
+      end
+
+      it "returns a hash with a nil value for each unset attribute" do
+        expect(user.attributes).to include(name: nil)
+      end
+    end
+
+    describe "#attributes_for_json" do
+      let(:time_now) { Time.now }
+
+      before(:each) do
+        user.id = 1
+        user.paid = true
+        user.created_at = time_now
+      end
+
+      it "serializes integer attributes as JSON integer" do
+        expect(user.attributes_for_json).to include("id" => 1)
+      end
+
+      it "serializes time attributes as JSON integer" do
+        expect(user.attributes_for_json).to include("created_at" => instance_of(Fixnum))
+      end
+
+      it "serializes string attributes as JSON string" do
+        user.name = 'Fred'
+        expect(user.attributes_for_json).to include("name" => "Fred")
+      end
+
+      it "leaves JSON attributes unchanged" do
+        json = {'interests' => ['coding', 'social networks'], 'rank' => 15}
+        user.profile = json
+        expect(user.attributes_for_json).to include("profile" => json)
+      end
+
+      it "omits attributes with a nil value" do
+        expect(user.attributes_for_json).to_not include("name")
+      end
+    end
+
+    describe "#set_attributes" do
+      it "allows mass assignment of attributes" do
+        user.set_attributes(id: 5, name: "Sally")
+        expect(user.attributes).to include(id: 5, name: "Sally")
+      end
+
+      it "ignores keys that have no writer method" do
+        user.set_attributes(id: 5, species: "Human")
+        expect(user.attributes).to_not include(species: "Human")
+      end
+
+      context "for an attribute with a private writer method" do
+        before(:all) { User.send(:private, :name=) }
+        after(:all)  { User.send(:public,  :name=) }
+
+        it "does not set the attribute" do
+          user.set_attributes(id: 5, name: "Sally")
+          expect(user.attributes).to_not include(name: "Sally")
+        end
+
+        it "sets the attribute if the flag is passed" do
+          user.set_attributes({id: 5, name: "Sally"}, true)
+          expect(user.attributes).to include(name: "Sally")
+        end
+      end
+    end
+
+    describe "#inspect" do
+      let(:user) do
+        User.new(id: 1,
+                 name: "Fred",
+                 created_at: "2014-12-25 08:00",
+                 paid: true,
+                 profile: {'interests' => ['coding', 'social networks'], 'rank' => 15})
+      end
+
+      it "includes integer attributes as 'name: value'" do
+        expect(user.inspect).to include("id: 1")
+      end
+
+      it "includes boolean attributes as 'name: true/false'" do
+        expect(user.inspect).to include("paid: true")
+      end
+
+      it "includes string attributes as 'name: \"string\"'" do
+        expect(user.inspect).to include('name: "Fred"')
+      end
+
+      it "includes time attributes as 'name: <ISO 8601>'" do
+        expect(user.inspect).to include("created_at: 2014-12-25 08:00:00 +0000")
+      end
+
+      it "includes json attributes as 'name: inspected_json'" do
+        expect(user.inspect).to include('profile: {"interests"=>["coding", "social networks"], "rank"=>15}')
+      end
+
+      it "includes the class name" do
+        expect(user.inspect).to include("User")
+      end
+
+      it "looks like '#<User id: 1, paid: true, name: ..., created_at: ...>'" do
+        expect(user.inspect).to eq("#<User id: 1, paid: true, name: \"Fred\", created_at: 2014-12-25 08:00:00 +0000, profile: {\"interests\"=>[\"coding\", \"social networks\"], \"rank\"=>15}>")
+      end
+    end
+
+    describe 'equality with :id field' do
+      let(:u1) { User.new(id: 1, name: 'David') }
+
+      context '#==' do
+        it 'returns true when ids match, regardless of other attributes' do
+          u2 = User.new(id: 1, name: 'Dave')
+          expect(u1).to eq(u2)
+        end
+
+        it 'returns false when ids do not match' do
+          u2 = User.new(id: 2, name: 'David')
+          expect(u1).to_not eq(u2)
+        end
+      end
+
+      context '#eql?' do
+        it 'returns true when ids match, regardless of other attributes' do
+          u2 = User.new(id: 1, name: 'Dave')
+          expect(u1).to eql(u2)
+        end
+
+        it 'returns false when ids do not match' do
+          u2 = User.new(id: 2, name: 'David')
+          expect(u1).to_not eql(u2)
+        end
+      end
+    end
+
+    describe 'equality without :id field' do
+      let(:u1) { UserWithoutId.new(name: 'David') }
+
+      context "for models with different attribute values" do
+        let(:u2) { UserWithoutId.new(name: 'Dave') }
+
+        it "#== returns false" do
+          expect(u1).to_not eq(u2)
+        end
+
+        it "#eql? returns false" do
+          expect(u1).to_not eql(u2)
+        end
+      end
+
+      context "for models with different attributes set" do
+        let(:u2) { UserWithoutId.new }
+
+        it "#== returns false" do
+          expect(u1).to_not eq(u2)
+        end
+
+        it "#eql? returns false" do
+          expect(u1).to_not eql(u2)
+        end
+      end
+
+      context "for models with the same attributes set to the same values" do
+        let(:u2) { UserWithoutId.new(name: 'David') }
+
+        it "#== returns true" do
+          expect(u1).to eq(u2)
+        end
+
+        it "#eql? returns true" do
+          expect(u1).to eql(u2)
+        end
+      end
+    end
+  end
+end