cot 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60707b16fa5c3be311bec710700f84d2014b9b1e
-  data.tar.gz: aad0be8b2404c946d70f6ad35ad41fff0907e08d
+  metadata.gz: c694dae2bac88f952a49ce4b4c7b5663edbd0fb7
+  data.tar.gz: 4001ebb79a3a8da5bd4b6828a814c9f7d408d728
 SHA512:
-  metadata.gz: 308b42d5847d369aaa86a12ea6d9d7fd3f253cafe041e89479a1a0d0395b060e5336e4581f4391663003b8d1b6a9b4b87def79ae79733753493d8552d50ba918
-  data.tar.gz: 8ea6633725178c97272abb7873df54d977c5df6d618e81df211510ab5868b51fbf40d54a559fd5f8b921ae15fd96cab228297eafc5703d581ac27bc001932bcf
+  metadata.gz: c5eba0c2e611e055dd3129491d25144f303fa5f740a790afdffd7b7ae8181000c9668c71ea915005a91ce93c6f52e491cbaaa8432609b8f7a5212a32e7552439
+  data.tar.gz: 1d42ba345c4223f9dab0ae101f73e78a0829f6fda56ba4b8109bd9f8eebfe5dd498c70456c3706151b68652dea024b396a870700611ce72be0dfaa062dc662bc

data/.rubocop.yml

@@ -6,3 +6,6 @@ Documentation:
 
 MethodLength:
   Max: 15
+
+Style/TrivialAccessors:
+  AllowDSLWriters: true

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cot (0.4.2)
+    cot (0.4.3)
       activemodel
 
 GEM

data/README.md

@@ -13,7 +13,7 @@ end
 
 class ExampleObject < Cot::Frame
   property :id
-  property :name, :searchable => true
+  property :name, :searchable => true, primary: true
   property :company_name, :from => :companyName
   property :item do
     from :place
@@ -21,6 +21,11 @@ class ExampleObject < Cot::Frame
       NestedClass.new params.merge parent_id: id
     end
   end
+  property :blank do
+    missing do
+      "Item #{id}"
+    end
+  end
   enum :types do
     entry :first
     entry :third, value: 3
@@ -35,6 +40,14 @@ class ExampleCollection < Cot::Collection
   end
 end
 
+# No initialize required, just pass in the objects
+class ExampleDSLCollection < Cot::Collection
+  collected_class ExampleObject
+  sub_key :key
+  default_attributes default: :attributes
+end
+
+
 thingy = ExampleObject.new(id: :my_id, name: 'awesome name', createdOn: Time.now, place: {bar: 'this is nested.foo'})
 thingy.id # 5
 thingy.name # awesome name
@@ -45,6 +58,8 @@ thingy.item # NestedClass instance
 thingy.item.foo # 'this is nested.foo'
 thingy.created_at # what time it is now
 thingy.defined_properties # [:id, :name, :created_at]
+thingy.blank # 'Item 5'
+thingy.exists? # 'awesome name'
 
 collection = ExampleCollection.new [{ id: :my_id, name: 'awesome name', createdOn: Time.now }, { id: :my_id, name: 'awesome name', createdOn: Time.now }], { default_attributes: { default: :attribute }
 collection.first.name # 'awesome name'
@@ -64,9 +79,11 @@ Frame provides some helpful methods:
     - property
       - The first parameter is the name of the property and it is added as a method to the object.
       - You can pass additional options in two ways, first you can pass a hash of options to property and secondly you can pass a block to property.
-      - There are three optional arguments, value, from and searchable.
+      - There are five optional arguments, value, from, missing, primary and searchable.
       - From indicates that the property has an alternate key in the incoming/outgoing data.
       - Searchable adds the property to the search mappings.
+      - Primary indicates that this is the primary key. Currently this only determines what exists? looks at.
+      - Missing takes a block and will execute the block if nothing was passed to the object on initialize. This block is evaluated in the context of the object. So you can for example have a string that says "Object #{id}"
       - Value takes a block and overwrites the value of the property to be the result of the block
         - This is useful for nested objects.
         - The block is executed as part of the instance of the object, so you have access to other properties.
@@ -91,10 +108,12 @@ Frame provides some helpful methods:
     - errors used to store any errors associated with the object
 
 Collection provides the following methods:
+- DSL
+  - If you don't need any special behavior in your initialize, you can use the DSL to declare the class, sub\_key and default\_attributes
 - Initialization
   - You can pass options to the collection when you initialize
   - sub\_key: Uses the contents inside the sub\_key
-  - default_attributes: Will add the keys/values to the object
+  - default\_attributes: Will add the keys/values to the object
 - Instance Methods
   - The following methods collate the results from members
     - serializable\_hash

data/lib/cot.rb

@@ -4,6 +4,7 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'cot/version'
 require 'cot/frame_class_methods'
 require 'cot/frame'
+require 'cot/collection_class_methods'
 require 'cot/collection'
 require 'cot/property'
 require 'cot/enum'

data/lib/cot/collection.rb

@@ -1,14 +1,19 @@
 module Cot
   class Collection < SimpleDelegator
-    def initialize(klass, objects, options = {})
-      options = { sub_key: options } unless options.is_a?(Hash)
-      @options = options.with_indifferent_access
-      @options[:default_attributes] = {} unless @options[:default_attributes].is_a?(Hash)
-      @klass = klass
-      @objects = objects
+    extend CollectionClassMethods
+
+    # We take an array of params here and then parse them due to backwards compat crap
+    # Collection can take 1-3 parameters and there are two cases when it gets two
+    # 3: klass, objects, options
+    # 2: klass, objects
+    # 2: objects, options
+    # 1: objects
+    def initialize(*params)
+      parse_params(params)
 
+      puts self.class.klass.inspect
       # If you pass in different types of things here we can't be friends
-      initialize_objects(objects) unless objects.first.is_a? klass
+      initialize_objects(@objects) unless @objects.first.is_a? self.class.klass
 
       super @objects
     end
@@ -40,13 +45,36 @@ module Cot
 
     private
 
+    def parse_params(params)
+      until params.empty?
+        item = params.shift
+        if item.class == Class
+          self.class.klass = item
+        elsif item.class == Array
+          @objects = item
+        else
+          options = item
+        end
+      end
+      options ||= {}
+      parse_options(options)
+    end
+
+    def parse_options(options)
+      options = { sub_key: options } unless options.is_a?(Hash)
+      @options = options.with_indifferent_access
+      @options[:default_attributes] = {} unless @options[:default_attributes].is_a?(Hash)
+      self.class.set_default_values
+      @options.merge! self.class.options
+    end
+
     def initialize_objects(objects)
       @objects = []
       @objects = objects.map do |payload|
         if @options[:sub_key]
-          @klass.new @options[:default_attributes].merge(payload.fetch(@options[:sub_key], {}))
+          self.class.klass.new @options[:default_attributes].merge(payload.fetch(@options[:sub_key], {}))
         else
-          @klass.new @options[:default_attributes].merge(payload || {})
+          self.class.klass.new @options[:default_attributes].merge(payload || {})
         end
       end
 

data/lib/cot/collection_class_methods.rb

@@ -0,0 +1,18 @@
+module CollectionClassMethods
+  attr_accessor :klass, :options
+
+  def collected_class(klass)
+    @klass = klass
+  end
+
+  [:sub_key, :default_attributes].each do |method_name|
+    define_method method_name do |value|
+      set_default_values
+      @options[method_name] = value
+    end
+  end
+
+  def set_default_values
+    @options ||= {}
+  end
+end

data/lib/cot/frame.rb

@@ -17,15 +17,21 @@ module Cot
           @data[k] = instance_exec(v, &block)
         end
       end
+
+      defined_properties.each do |prop|
+        if @data[prop].nil? && self.class.missing_blocks[prop]
+          block = self.class.missing_blocks[prop]
+          @data[prop] = instance_exec(self, &block)
+        end
+      end
     end
 
     def exists?
-      # TODO: Have this key off a defined primary key instead of defaulting to id
-      id
+      send self.class.primary_key
     end
 
     def defined_properties
-      self.class.attr_methods
+      self.class.attr_methods || []
     end
 
     def properties_mapping

data/lib/cot/frame_class_methods.rb

@@ -5,6 +5,8 @@ module Cot
                   :inverted_search_mappings,
                   :search_mappings,
                   :value_blocks,
+                  :missing_blocks,
+                  :primary_key,
                   :mappings
 
     def search_property(name, args = {})
@@ -30,18 +32,27 @@ module Cot
       prop = Property.new args
       prop.instance_eval(&block) if block
 
+      set_blocks(name, prop)
+      set_mappings(name, prop)
+      @primary_key = name if prop.primary?
+
+      define_property_methods name
+    end
+
+    private
+
+    def set_blocks(name, prop)
       @value_blocks[name] = prop.value if prop.value
+      @missing_blocks[name] = prop.missing if prop.missing
+    end
 
+    def set_mappings(name, prop)
       key = prop.from
       @mappings[key.to_sym] = name if key
       @search_mappings[name] = key ? key : name if prop.searchable
       attr_methods << name.to_sym
-
-      define_property_methods name
     end
 
-    private
-
     # Can't seem to get an intialize in for the class, so we need to set these
     # before we do stuff for property
     def set_default_values
@@ -49,6 +60,8 @@ module Cot
       @attr_methods ||= []
       @search_mappings ||= {}
       @value_blocks ||= {}
+      @missing_blocks ||= {}
+      @primary_key ||= :id
     end
 
     def define_property_methods(name)

data/lib/cot/property.rb

@@ -5,9 +5,19 @@ module Cot
       @args = params
     end
 
-    def value(&block)
-      return args[:value] unless block
-      args[:value] = block
+    def primary
+      args[:primary] = true
+    end
+
+    def primary?
+      args[:primary]
+    end
+
+    [:missing, :value].each do |method_name|
+      define_method method_name do |&block|
+        return args[method_name] unless block
+        args[method_name] = block
+      end
     end
 
     [:from, :searchable].each do |method_name|

data/lib/cot/version.rb

@@ -1,3 +1,3 @@
 module Cot
-  VERSION = '0.4.3'
+  VERSION = '0.5.0'
 end

data/spec/lib/cot/collection_spec.rb

@@ -71,34 +71,97 @@ describe Cot::Collection do
   end
 
   context 'initialize' do
-    it 'does not process the objects if they are already the correct class' do
-      coll = Cot::Collection.new FakeDouble, [FakeDouble.new(fooy: :bar), FakeDouble.new(asdf: :fdas)]
-      expect(coll.first).to be_kind_of FakeDouble
+    context 'when passing a class' do
+      context 'with options' do
+        it 'takes an optional sub_key option to pull the object out of the payload' do
+          coll = Cot::Collection.new FakeDouble,
+                                     [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }],
+                                     sub_key: :inner
+          expect(coll.first).to be_kind_of FakeDouble
+          expect(coll.first.fooy).to eq :bar
+        end
+
+        it 'takes an optional default_attributes option to add set attributes in every object.' do
+          coll = Cot::Collection.new FakeDouble, [{ fooy: :bar }, { asdf: :fdas }], default_attributes: { foo: :baz }
+          expect(coll).to all be_kind_of FakeDouble
+          expect(coll.map(&:foo).uniq).to eq [:baz]
+        end
+
+        it 'support a legacy optional sub_key parameter to pull the object out of the payload' do
+          coll = Cot::Collection.new FakeDouble, [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }], :inner
+          expect(coll.first).to be_kind_of FakeDouble
+          expect(coll.first.fooy).to eq :bar
+        end
+      end
+
+      context 'without options' do
+        it 'does not process the objects if they are already the correct class' do
+          coll = Cot::Collection.new FakeDouble, [FakeDouble.new(fooy: :bar), FakeDouble.new(asdf: :fdas)]
+          expect(coll.first).to be_kind_of FakeDouble
+        end
+
+        it 'creates new instances of the passed klass if the objects are not already the class' do
+          coll = Cot::Collection.new FakeDouble, [{ fooy: :bar }, { asdf: :fdas }]
+          expect(coll.first).to be_kind_of FakeDouble
+        end
+      end
+    end
+
+    context 'when not passing a class' do
+      before :each do
+        class MyCollection < Cot::Collection
+          collected_class FakeDouble
+        end
+      end
+
+      context 'with options' do
+        it 'takes an optional sub_key option to pull the object out of the payload' do
+          coll = MyCollection.new [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }], sub_key: :inner
+          expect(coll.first).to be_kind_of FakeDouble
+          expect(coll.first.fooy).to eq :bar
+        end
+
+        it 'takes an optional default_attributes option to add set attributes in every object.' do
+          coll = MyCollection.new [{ fooy: :bar }, { asdf: :fdas }], default_attributes: { foo: :baz }
+          expect(coll).to all be_kind_of FakeDouble
+          expect(coll.map(&:foo).uniq).to eq [:baz]
+        end
+      end
+
+      context 'options using dsl' do
+        it 'subkey works' do
+          class MyCollection
+            sub_key :inner
+          end
+
+          coll = MyCollection.new [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }]
+          expect(coll.first).to be_kind_of FakeDouble
+          expect(coll.first.fooy).to eq :bar
+        end
+
+        it 'takes an optional default_attributes option to add set attributes in every object.' do
+          class MyCollection
+            default_attributes foo: :baz
+          end
+
+          coll = MyCollection.new [{ fooy: :bar }, { asdf: :fdas }]
+          expect(coll).to all be_kind_of FakeDouble
+          expect(coll.map(&:foo).uniq).to eq [:baz]
+        end
+      end
+
+      context 'without options' do
+        it 'does not process the objects if they are already the correct class' do
+          coll = Cot::Collection.new [FakeDouble.new(fooy: :bar), FakeDouble.new(asdf: :fdas)]
+          expect(coll.first).to be_kind_of FakeDouble
+        end
+
+        it 'creates new instances of the passed klass if the objects are not already the class' do
+          coll = Cot::Collection.new [{ fooy: :bar }, { asdf: :fdas }]
+          expect(coll.first).to be_kind_of FakeDouble
+        end
+      end
     end
-
-    it 'creates new instances of the passed klass if the objects are not already the class' do
-      coll = Cot::Collection.new FakeDouble, [{ fooy: :bar }, { asdf: :fdas }]
-      expect(coll.first).to be_kind_of FakeDouble
-    end
-
-    it 'takes an optional sub_key option to pull the object out of the payload' do
-      coll = Cot::Collection.new FakeDouble, [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }], sub_key: :inner
-      expect(coll.first).to be_kind_of FakeDouble
-      expect(coll.first.fooy).to eq :bar
-    end
-
-    it 'takes an optional default_attributes option to add set attributes in every object.' do
-      coll = Cot::Collection.new FakeDouble, [{ fooy: :bar }, { asdf: :fdas }], default_attributes: { foo: :baz }
-      expect(coll).to all be_kind_of FakeDouble
-      expect(coll.map(&:foo).uniq).to eq [:baz]
-    end
-
-    it 'support a legacy optional sub_key parameter to pull the object out of the payload' do
-      coll = Cot::Collection.new FakeDouble, [{ inner: { fooy: :bar } }, { inner: { asdf: :fdas } }], :inner
-      expect(coll.first).to be_kind_of FakeDouble
-      expect(coll.first.fooy).to eq :bar
-    end
-
   end
 
   context 'update members' do

data/spec/lib/cot/frame_spec.rb

@@ -14,6 +14,10 @@ describe Cot::Frame do
   its(:id) { should eq 5 }
   its(:foo) { should eq 'this will be foo' }
 
+  it 'primary key defaults to id' do
+    expect(@foo.exists?).to be 5
+  end
+
   context 'serializable_hash' do
     its(:serializable_hash) { should be_kind_of Hash }
     it 'has two keys' do
@@ -128,7 +132,12 @@ describe Cot::Frame do
           end
         end
         class TestObject < Cot::Frame
-          property :my_id, from: :id
+          property :my_id, from: :key, primary: true
+          property :blank do
+            missing do
+              "this was blank #{my_id}"
+            end
+          end
           property :thing do
             from :stuff
             searchable true
@@ -137,7 +146,7 @@ describe Cot::Frame do
             end
           end
         end
-        @foo = TestObject.new(stuff: { key: 'this will be in foo' }, id: 42)
+        @foo = TestObject.new(stuff: { key: 'this will be in foo' }, key: 42)
       end
 
       it 'adds to mappings' do
@@ -150,13 +159,21 @@ describe Cot::Frame do
         expect(TestObject.search_mappings[:thing]).to be :stuff
       end
 
-      it 'assigns sets the value' do
+      it 'stores missing' do
+        expect(@foo.blank).to eq 'this was blank 42'
+      end
+
+      it 'sets the primary key' do
+        expect(@foo.exists?).to be 42
+      end
+
+      it 'sets the value' do
         expect(@foo.thing).to be_kind_of Foo
         expect(@foo.thing.params[:passed]).to eq 42
       end
 
       it 'sets the value on []=' do
-        bar = TestObject.new(id: 42)
+        bar = TestObject.new(key: 42)
         bar.thing = { key: 'this will be in foo' }
         expect(bar.thing).to be_kind_of Foo
         expect(bar.thing.params[:passed]).to eq 42

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cot
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Joseph Henrich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-03 00:00:00.000000000 Z
+date: 2014-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -129,6 +129,7 @@ files:
 - cot.gemspec
 - lib/cot.rb
 - lib/cot/collection.rb
+- lib/cot/collection_class_methods.rb
 - lib/cot/enum.rb
 - lib/cot/frame.rb
 - lib/cot/frame_class_methods.rb