id 0.0.6 → 0.0.7

data/Gemfile.lock

@@ -1,18 +1,23 @@
 PATH
   remote: .
   specs:
-    id (0.0.5)
+    id (0.0.6)
       activesupport
+      money
+      optional
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (3.2.11)
+    activesupport (3.2.12)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     diff-lcs (1.2.1)
-    i18n (0.6.1)
+    i18n (0.6.4)
+    money (5.1.1)
+      i18n (~> 0.6.0)
     multi_json (1.7.2)
+    optional (0.0.3)
     rspec (2.13.0)
       rspec-core (~> 2.13.0)
       rspec-expectations (~> 2.13.0)

data/README.md

@@ -3,4 +3,58 @@
 
 JSON is a great way to transfer data between systems, and it's easy to parse into a Ruby hash. But sometimes it's nice to have actual methods to call when you want to get attributes from your data, rather than coupling your entire codebase to the hash representation by littering it with calls to `fetch` or `[]`. The same goes for BSON documents stored in Mongo.
 
-That's where `id` (as in Freud) comes in. You define your model classes using syntax that should look pretty familiar if you've used any popular Ruby ORMs - but `id` is not an ORM. Model objects defined with `id` have a constructor that accepts a hash, and you define the values of this hash that are made readable as fields - but that hash can come from any source.
+That's where `id` (as in Freud) comes in. You define your model classes using syntax that should look pretty familiar if you've used any popular Ruby ORMs - but `id` is not an ORM. Model objects defined with `id` have a constructor that accepts a hash, and you define the values of this hash that are made readable as fields - but that hash can come from any source.
+
+#### Defining a model
+
+Defining a model looks like this:
+
+    class MyModel
+      include Id::Model
+
+      field :foo
+      field :bar, default: 42
+      field :baz, key: 'barry'
+
+    end
+
+    my_model = MyModel.new(foo: 7, barry: 'hello')
+    my_model.foo # => 7
+    my_model.bar # => 42
+    my_model.baz # => 'hello'
+
+As you can see, you can specify default values as well as key aliases.
+
+#### Associations
+
+You can also specify has_one or has_many "associations" - what would be nested subdocuments in MongoDB for example - like this:
+
+    class Zoo
+      include Id::Model
+
+      has_many :lions
+      has_many :zebras
+      has_one :zookeeper, type: Person
+    end
+
+    zoo = Zoo.new(lions: [{name: 'Hetty'}],
+                  zebras: [{name: 'Lisa'}],
+                  zookeeper: {name: 'Russell' d})
+
+    zoo.lions.first.class # => Lion
+    zoo.lions.first.name  # => "Hetty"
+    zoo.zookeeper.class   # => Person
+    zoo.zookeeper.name    # => "Russell"
+
+Types are inferred from the association name unless one is specified.
+
+#### Designed for immutability
+
+`id` models provide accessor methods, but no mutator methods, because they are designed for immutability. How do immutable models work? When you need to change some field of a model object, a new copy of the object is created with the field changed as required. This is handled for you by `id`'s `set` method:
+
+    person = Person.new(name: 'Russell', job: 'programmer')
+    person.set(name: 'Radek') # => returns a new Person whose name is Radek and whose job is 'programmer'
+
+You can even set fields on nested models in this way:
+
+    person.hat.set(color: 'red') # => returns a new person object with a new hat object with its color set to red

data/id.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = 'id'
-  s.version       = '0.0.6'
+  s.version       = '0.0.7'
   s.date          = '2013-03-28'
   s.summary       = "Simple models based on hashes"
   s.description   = "Developed at On The Beach Ltd. Contact russell.dunphy@onthebeach.co.uk"
@@ -11,6 +11,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.homepage      = 'http://github.com/onthebeach/id'
 
+  s.add_dependency "optional"
+  s.add_dependency "money"
   s.add_dependency "activesupport"
 
   s.add_development_dependency "rspec"

data/lib/id.rb

@@ -1,3 +1,6 @@
 require 'active_support/inflector'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/except'
+require 'optional'
+require 'money'
 require_relative 'id/all'

data/lib/id/hashifier.rb

@@ -1,6 +1,10 @@
 module Id
   class Hashifier
 
+    def self.hashify(data)
+      new(data).hashify
+    end
+
     def initialize(data)
       @data = data
     end
@@ -15,6 +19,7 @@ module Id
       case v
       when Id::Model then v.data
       when Array then v.first.is_a?(Id::Model) ? v.map(&:data) : v
+      when Hash then Hashifier.hashify(v)
       else v end
     end
 

data/lib/id/model.rb

@@ -3,11 +3,15 @@ module Id
     attr_reader :data
 
     def initialize(data)
-      @data = Hashifier.new(data).hashify
+      @data = Hashifier.hashify(data)
     end
 
     def set(values)
-      self.class.new(data.merge(values))
+      self.class.new(data.merge(Hashifier.hashify(values)))
+    end
+
+    def unset(*keys)
+      self.class.new(data.except(*keys.map(&:to_s)))
     end
 
     private
@@ -21,19 +25,21 @@ module Id
     end
 
     module Descriptor
+
       def field(f, options={})
-        Field.new(self, f, options).define
-        builder_class.field f
+        (options[:optional] ? FieldOption : Field).new(self, f, options).define
       end
 
       def has_one(f, options={})
-        HasOne.new(self, f, options).define
-        builder_class.field f
+        (options[:optional] ? HasOneOption : HasOne).new(self, f, options).define
       end
 
       def has_many(f, options={})
         HasMany.new(self, f, options).define
-        builder_class.field f
+      end
+
+      def compound_field(f, fields, options={})
+        CompoundField.new(self, f, fields, options).define
       end
 
       def builder

data/lib/id/model/all.rb

@@ -1,5 +1,7 @@
+require_relative 'type_casts'
 require_relative 'field'
 require_relative 'association'
 require_relative 'has_one'
 require_relative 'has_many'
 require_relative 'builder'
+require_relative 'compound_field'

data/lib/id/model/builder.rb

@@ -32,7 +32,7 @@ module Id
 
       module FieldBuilder
 
-        def field(f)
+        def define_setter(f)
           define_method f do |value|
             set(f, value)
           end

data/lib/id/model/compound_field.rb

@@ -0,0 +1,23 @@
+module Id
+  module Model
+    class CompoundField < Association
+
+      def initialize(model, name, fields, options)
+        @fields = fields
+        super(model, name, options)
+      end
+
+      def define_getter
+        field = self
+        model.send :define_method, name do
+          memoize field.name do
+            compound = Hash[field.fields.map { |k,v| [k.to_s, send(v) { raise MissingAttributeError, k.to_s }]}]
+            field.type.new(compound)
+          end
+        end
+      end
+
+      attr_accessor :fields
+    end
+  end
+end

data/lib/id/model/field.rb

@@ -8,23 +8,75 @@ module Id
         @options = options
       end
 
-      def define
+      def define_getter
         field = self
         model.send :define_method, name do
-          data.fetch(field.key) { field.default or raise MissingAttributeError }
+          memoize field.name do
+            field.cast data.fetch(field.key, &field.default_value)
+          end
+        end
+      end
+
+      def define_setter
+        model.send(:builder_class).define_setter name
+      end
+
+      def define_is_present
+        field = self
+        model.send :define_method, "#{name}?" do
+          data.has_key?(field.key) && !data.fetch(field.key).nil?
         end
       end
 
+      def define
+        define_getter
+        define_setter
+        define_is_present
+      end
+
+      def cast(value)
+        TypeCasts.cast(options.fetch(:type, false), value)
+      end
+
       def key
         options.fetch(:key, name).to_s
       end
 
+      def default_value
+        proc do
+          if default? then default
+          elsif !optional? then raise MissingAttributeError, key end
+        end
+      end
+
+      def default?
+        options.has_key?(:default)
+      end
+
       def default
-        options.fetch(:default, nil)
+        options.fetch(:default)
+      end
+
+      def optional?
+        options.fetch(:optional, false)
       end
 
       attr_reader :model, :name, :options
     end
 
+    class FieldOption < Field
+      def define_getter
+        field = self
+        model.send :define_method, name do
+          memoize field.name do
+            if d = data.fetch(field.key, &field.default_value)
+              Some[field.cast d]
+            else
+              None
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/id/model/has_many.rb

@@ -2,7 +2,7 @@ module Id
   module Model
     class HasMany < Association
 
-      def define
+      def define_getter
         field = self
         model.send :define_method, name do
           memoize field.name do

data/lib/id/model/has_one.rb

@@ -2,11 +2,26 @@ module Id
   module Model
     class HasOne < Association
 
-      def define
+      def define_getter
         field = self
         model.send :define_method, name do
           memoize field.name do
-            field.type.new(data.fetch(field.key) { raise MissingAttributeError })
+            child = data.fetch(field.key) { raise MissingAttributeError, field.key }
+            field.type.new(child) unless child.nil?
+          end
+        end
+      end
+
+    end
+
+    class HasOneOption < Association
+
+      def define_getter
+        field = self
+        model.send :define_method, name do
+          memoize field.name do
+            child = data.fetch(field.key, nil)
+            child.nil? ? None : Some[field.type.new(child)]
           end
         end
       end

data/lib/id/model/type_casts.rb

@@ -0,0 +1,96 @@
+module Id
+  module Model
+    module TypeCasts
+
+      def self.cast(type, value)
+        casts.fetch(type, Identity).new(value).cast
+      end
+
+      protected
+
+      def self.register(cast)
+        casts[cast.type] = cast
+      end
+
+      private
+
+      def self.casts
+        @casts ||= {}
+      end
+
+      class Cast
+
+        def initialize(value)
+          @value = value
+        end
+
+        def cast
+          value.is_a?(type) ? value : conversion
+        end
+
+        def type
+          self.class.type
+        end
+
+        def conversion
+          raise NotImplementedError
+        end
+
+        private
+
+        def self.type
+          raise NotImplementedError
+        end
+
+        attr_reader :value
+
+      end
+
+      class Identity < Cast
+        def cast
+          value
+        end
+      end
+
+      class Date < Cast
+
+        def self.type
+          ::Date
+        end
+
+        def conversion
+          ::Date.parse value
+        end
+
+        TypeCasts.register(self)
+      end
+
+      class Time < Cast
+
+        def self.type
+          ::Time
+        end
+
+        def conversion
+          ::Time.parse value
+        end
+
+        TypeCasts.register(self)
+      end
+
+      class Money < Cast
+
+        def self.type
+          ::Money
+        end
+
+        def conversion
+          ::Money.new value.to_i
+        end
+
+        TypeCasts.register(self)
+      end
+
+    end
+  end
+end

data/spec/lib/id/model/has_one_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class Cat
+  include Id::Model
+end
+
+class OptionalModel
+  include Id::Model
+
+  has_one :cat, optional: true
+end
+
+module Id
+  module Model
+
+    describe HasOneOption do
+
+      it 'returns a none if the key is missing' do
+        OptionalModel.new({}).cat.should be_none
+      end
+
+      it 'returns a some if the key is there' do
+        OptionalModel.new(cat: {}).cat.should be_some(Cat)
+      end
+
+    end
+
+  end
+end

data/spec/lib/id/model/type_casts_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Id
+  module Model
+    module TypeCasts
+
+      describe Cast do
+        it 'requires a type' do
+          expect { Cast.new(1).type }.to raise_error NotImplementedError
+        end
+
+        it 'requires a conversion' do
+          expect { Cast.new(1).conversion }.to raise_error NotImplementedError
+        end
+
+      end
+
+      describe Date do
+        it 'casts strings to dates' do
+          Date.new("06-06-1983").cast.should eq ::Date.new(1983, 6, 6)
+        end
+      end
+
+      describe Time do
+        it 'casts strings to Times' do
+          Time.new("06-06-1983").cast.should eq ::Time.parse("06-06-1983")
+        end
+
+        it 'does nothing if the value is already of the correct type' do
+          time = ::Time.now
+          Time.new(time).cast.should eq time
+        end
+      end
+
+      describe Money do
+        it 'ints or strings to Money' do
+          Money.new("500").cast.should eq ::Money.new(5_00)
+          Money.new(500).cast.should eq ::Money.new(5_00)
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/id/model_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+class NestedModel
+  include Id::Model
+  field :yak
+end
+
+class CompboundElementModel
+  include Id::Model
+  field :plugh
+  field :thud
+end
+
+class TestModel
+  include Id::Model
+
+  field :foo
+  field :bar, key: 'baz'
+  field :qux, optional: true
+  field :quux, default: false
+  field :date_of_birth, optional: true, type: Date
+  field :empty_date, optional: true, type: Date
+  field :christmas, default: Date.new(2014,12,25), type: Date
+  field :quxx, optional: true
+
+  compound_field :corge, {plugh: 'foo', thud: 'quux'}, type: CompboundElementModel
+
+  has_one :aliased_model, type: NestedModel
+  has_one :nested_model, key: 'aliased_model'
+  has_one :extra_nested_model
+  has_one :test_model
+  has_many :nested_models
+
+  class ExtraNestedModel
+    include Id::Model
+    field :cats
+  end
+end
+
+describe Id::Model do
+  let (:model) { TestModel.new(foo: 3,
+                               baz: 6,
+                               quxx: 8,
+                               test_model: {},
+                               date_of_birth: '06-06-1983',
+                               aliased_model: { 'yak' => 11},
+                               nested_models: [{ 'yak' => 11}, { yak: 14 }],
+                               extra_nested_model: { cats: "MIAOW" }) }
+
+
+  describe ".new" do
+    it 'converts any passed id models to their hash representations' do
+      new_model = TestModel.new(test_model: model)
+      new_model.test_model.data.should eq model.data
+    end
+  end
+
+  describe ".field" do
+    it 'defines an accessor on the model' do
+      model.foo.should eq 3
+    end
+
+    it 'allows key aliases' do
+      model.bar.should eq 6
+    end
+
+    it 'allows default values' do
+      model.quux.should be_false
+    end
+
+    describe "optional flag" do
+      context 'when field is not in hash' do
+        it 'is None' do
+          expect(model.qux).to eq None
+        end
+
+      end
+      context 'when field is in hash' do
+        it 'is Some' do
+          expect(model.quxx).to eq Some[8]
+        end
+
+      end
+    end
+
+    describe "typecast option" do
+      it 'typecasts to the provided type if a cast exists' do
+        model.date_of_birth.should be_some Date
+        model.christmas.should be_a Date
+      end
+
+      it 'should work for empty optional fields' do
+        model.empty_date.should be_none
+      end
+    end
+
+  end
+
+  describe ".compound_field" do
+    it 'defines an accessor on the model' do
+      model.corge.should be_a CompboundElementModel
+    end
+
+    it 'deals with default values' do
+      model.corge.thud.should be_false
+    end
+  end
+
+  describe ".has_one" do
+    it "allows nested models" do
+      model.aliased_model.should be_a NestedModel
+    end
+    it "allows nested models" do
+      model.nested_model.should be_a NestedModel
+      model.nested_model.yak.should eq 11
+    end
+    it "allows associations to be nested within the class" do
+      model.extra_nested_model.should be_a TestModel::ExtraNestedModel
+      model.extra_nested_model.cats.should eq 'MIAOW'
+    end
+    it "allows recursively defined models" do
+      model.test_model.should be_a TestModel
+    end
+  end
+
+  describe ".has_many" do
+    it 'creates an array of nested models' do
+      model.nested_models.should be_a Array
+      model.nested_models.first.should be_a NestedModel
+      model.nested_models.first.yak.should eq 11
+      model.nested_models.last.yak.should eq 14
+    end
+  end
+
+  describe "#set" do
+    it "creates a new model with the provided values changed" do
+      model.set(foo: 999).should be_a TestModel
+      model.set(foo: 999).foo.should eq 999
+    end
+  end
+
+  describe "#unset" do
+    it 'returns a new basket minus the passed key' do
+      expect { model.set(foo: 999, bar: 555).unset(:foo, :bar).foo }.to raise_error Id::MissingAttributeError, "foo"
+    end
+
+    it 'does not error if the key to be removed does not exist' do
+      expect { model.unset(:not_in_hash) }.to_not raise_error
+    end
+  end
+
+  describe "#fields are present methods" do
+    it 'allows you to check if fields are present' do
+      model = TestModel.new(foo: 1)
+      model.foo?.should be_true
+      model.bar?.should be_false
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: id
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -12,6 +12,38 @@ bindir: bin
 cert_chain: []
 date: 2013-03-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: optional
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -82,13 +114,16 @@ files:
 - lib/id/model/all.rb
 - lib/id/model/association.rb
 - lib/id/model/builder.rb
+- lib/id/model/compound_field.rb
 - lib/id/model/field.rb
 - lib/id/model/has_many.rb
 - lib/id/model/has_one.rb
+- lib/id/model/type_casts.rb
 - spec/lib/id/model/association_spec.rb
 - spec/lib/id/model/builder_spec.rb
+- spec/lib/id/model/has_one_spec.rb
+- spec/lib/id/model/type_casts_spec.rb
 - spec/lib/id/model_spec.rb
-- spec/lib/id_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/onthebeach/id
 licenses: []
@@ -117,7 +152,8 @@ summary: Simple models based on hashes
 test_files:
 - spec/lib/id/model/association_spec.rb
 - spec/lib/id/model/builder_spec.rb
+- spec/lib/id/model/has_one_spec.rb
+- spec/lib/id/model/type_casts_spec.rb
 - spec/lib/id/model_spec.rb
-- spec/lib/id_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/lib/id_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-class NestedModel
-  include Id::Model
-  field :yak
-end
-
-class TestModel
-  include Id::Model
-
-  field :foo
-  field :bar, key: 'baz'
-  field :quux, default: 'kwak'
-
-  has_one :aliased_model, type: NestedModel
-  has_one :nested_model, key: 'aliased_model'
-  has_one :extra_nested_model
-  has_one :test_model
-  has_many :nested_models
-
-  class ExtraNestedModel
-    include Id::Model
-    field :cats!
-  end
-end
-
-describe Id::Model do
-  let (:model) { TestModel.new(foo: 3,
-                               baz: 6,
-                               test_model: {},
-                               aliased_model: { 'yak' => 11},
-                               nested_models: [{ 'yak' => 11}, { yak: 14 }],
-                               extra_nested_model: { cats!: "MIAOW" }) }
-
-
-  describe ".new" do
-    it 'converts any passed id models to their hash representations' do
-      new_model = TestModel.new(test_model: model)
-      new_model.test_model.data.should eq model.data
-    end
-  end
-
-  describe ".field" do
-    it 'defines an accessor on the model' do
-      model.foo.should eq 3
-    end
-
-    it 'allows key aliases' do
-      model.bar.should eq 6
-    end
-
-    it 'allows default values' do
-      model.quux.should eq 'kwak'
-    end
-
-  end
-
-  describe ".has_one" do
-    it "allows nested models" do
-      model.aliased_model.should be_a NestedModel
-    end
-    it "allows nested models" do
-      model.nested_model.should be_a NestedModel
-      model.nested_model.yak.should eq 11
-    end
-    it "allows associations to be nested within the class" do
-      model.extra_nested_model.should be_a TestModel::ExtraNestedModel
-      model.extra_nested_model.cats!.should eq 'MIAOW'
-    end
-    it "allows recursively defined models" do
-      model.test_model.should be_a TestModel
-    end
-  end
-
-  describe ".has_many" do
-    it 'creates an array of nested models' do
-      model.nested_models.should be_a Array
-      model.nested_models.first.should be_a NestedModel
-      model.nested_models.first.yak.should eq 11
-      model.nested_models.last.yak.should eq 14
-    end
-  end
-
-  describe "#set" do
-    it "creates a new model with the provided values changed" do
-      model.set(foo: 999).should be_a TestModel
-      model.set(foo: 999).foo.should eq 999
-    end
-  end
-
-end
-