cot 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b54755a09317578c48c93d680043d3e6bcf1caab
-  data.tar.gz: a264c498df609509981b8c5afb837a211ad84d36
+  metadata.gz: bce57021ecbcd6f8ea2c6952a36d4ea28b38bf99
+  data.tar.gz: 26f2711ae9016dda7b0c633bae9e9f3a04821e44
 SHA512:
-  metadata.gz: 5f71356f473c1de0f94513b553dd8222977744489434808c90de5fa9f130019cb710278b7df826f37b6365d532712886148a28e027cd88c8bda0c5729dfc7cf3
-  data.tar.gz: d25fc72929dd6e80b7ece0d5ccbd02854a8bb49df4376a17d188ae11b1ec8209187a2c9d2717f10fcc8602e7fdad1489b443568e86950231d33b2837fbed54de
+  metadata.gz: 9b38415ebef6aec060d976c7f235ecb20db19d823ec131a3367d600a37484e69b4525a6ebd3f0b0f37b7745893ec78e4de6cdd1095517caf664d8f08b68a550c
+  data.tar.gz: ef4bc4c2b3129929629ae8ec2ff582eba6ac915b51d83d1008cc90f5367ba8ed5d4ce5759200a3d7632ae0b255e74c02a7ad7ba0a7f886b501c94832fcc00f60

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013 Joseph Henrich
+Copyright (c) 2014 Joseph Henrich
 
 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

data/README.md

@@ -9,9 +9,22 @@ Using cot is pretty simple. There are two main classes: Collection and Frame. Co
 
 Frame provides some helpful methods:
 - Class Methods
-    - property adds the first parameter as an accessor on the object.  There are two optional arguments, from and searchable.  From indicates that the property has an alternate key in the incoming/outgoing data.  Searchable adds the property to the search mappings.
+    - 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.  
+      - From indicates that the property has an alternate key in the incoming/outgoing data.  
+      - Searchable adds the property to the search mappings.
+      - 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.
+        - The block takes one parameter, which is the value of the hash for that key (what the value would have been if there was no value block).
     - search\_property adds the parameter to the search mapping.  It takes an optional from argument which inidates the property has an alternate key in the incoming/outgoing data.
-    - enum *NOT SUPPORTED* If you'd like to see this let me know. Also let me know what you'd want it to look like.
+    - enum takes a name and a block
+      - The block expects a series of entries to be declared
+      - enum starts counting at 1 by default
+      - Each entry will have the value of 1 higher than the previous by default
+      - An optional value parameter can be passed which sets the entries value to that number. This lets you skip a numer, start higher or lower or even be non-sequential.
 - Instance Methods
     - defined\_properties returns a list of the defined properties
     - properties\_mapping returns a hash containing all of the renamed properties.  The keys are the values of the from argument and the values are the property name.
@@ -24,6 +37,10 @@ Frame provides some helpful methods:
     - errors used to store any errors associated with the object
 
 Collection provides the following methods:
+- 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
 - Instance Methods
   - The following methods collate the results from members
     - serializable\_hash
@@ -38,12 +55,23 @@ class ExampleObject < Cot::Frame
   property :id
   property :name, :searchable => true
   property :company_name, :from => :companyName
+  property :item do
+    from :place
+    value do |params|
+      MyClass.new params.merge parent_id: id
+    end
+  end
+  enum :types do
+    entry :first
+    entry :third, value: 3
+    entry :fourth
+  end
   search_property :created_at, :from => :createdOn
 end
 
 class ExampleCollection < Cot::Collection
-  def initialize(params)
-    super ExampleObject, params
+  def initialize(objects, options = {})
+    super ExampleObject, objects, options
   end
 end
 
@@ -53,8 +81,9 @@ thingy.name # awesome name
 thingy.created_at # what time it is now
 thingy.defined\_properties # [:id, :name, :created_at]
 
-collection = ExampleCollection.new [{ id: :my_id, name: 'awesome name', createdOn: Time.now }, { id: :my_id, name: 'awesome name', createdOn: Time.now }]
+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'
+collection.first.default # :attribute
 collection.exists? # Do all of the entries exist?
 collection.update_members [{ id: 1, name: 'new awesome name', createdOn: Time.now }, { id: 2, name: 'new awesome name', createdOn: Time.now }]
 collection.first.name # 'new awesome name'

data/cot.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/crimsonknave/cot'
   s.summary = 'Simplifies creating models for rest based resources'
   s.description = 'Simplifies creating models for rest based resources'
+  s.license = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/cot.rb

@@ -2,8 +2,11 @@ require 'active_model'
 require 'active_support/core_ext/hash/indifferent_access'
 
 require 'cot/version'
+require 'cot/frame_class_methods'
 require 'cot/frame'
 require 'cot/collection'
+require 'cot/property'
+require 'cot/enum'
 require 'json'
 
 module Cot

data/lib/cot/enum.rb

@@ -0,0 +1,23 @@
+module Cot
+  class Enum
+    attr_accessor :num, :used
+    def initialize
+      @used = {}
+      @num = 1
+    end
+
+    def entry(name, options = {})
+      value = options[:value] || num
+      if used.key? value
+        fail "#{name} tried to set value #{value}, which is already used by #{used[value]}. Enum values are unique."
+      end
+
+      self.class.send :define_method, name do
+        value
+      end
+
+      @num = value + 1
+      used[value] = name
+    end
+  end
+end

data/lib/cot/frame.rb

@@ -1,13 +1,22 @@
 module Cot
   class Frame
-    class << self
-      attr_accessor :mappings, :inverted_mappings, :attr_methods, :search_mappings, :inverted_search_mappings
-    end
+    attr_accessor :errors
+
+    extend FrameClassMethods
+
     include ActiveModel::Dirty
 
     def initialize(payload = {})
       @errors = {}
+
       @data = convert_keys payload
+
+      @data.each do |k, v|
+        if self.class.value_blocks[k]
+          block = self.class.value_blocks[k]
+          @data[k] = instance_exec(v, &block)
+        end
+      end
     end
 
     def exists?
@@ -35,42 +44,6 @@ module Cot
       self.class.inverted_search_mappings ||= search_mappings.invert
     end
 
-    def self.search_property(name, args = {})
-      @search_mappings ||= {}
-
-      key = args[:from] ? args[:from] : name
-      @search_mappings[name] = key
-    end
-
-    # TODO: Create an enum declaration that will automagically map a symbol to
-    # another value (such as an int) so that the user of the library doesn't need
-    # to know what number scheduled status is (for example)
-    def self.enum(_name, _args = {})
-      fail 'enum is not yet implemented'
-    end
-
-    def self.property(name, args = {})
-      @mappings ||= {}
-      @attr_methods ||= []
-      @search_mappings ||= {}
-      key = args[:from]
-      @mappings[key.to_sym] = name if key
-      @search_mappings[name] = key ? key : name if args[:searchable]
-      attr_methods << name.to_sym
-
-      define_method name do
-        self[name]
-      end
-
-      define_method "#{name}=" do |value|
-        send("#{name}_will_change!") unless value == self[name]
-        self[name] = value
-      end
-      define_attribute_method name
-    end
-
-    attr_accessor :errors
-
     def [](key)
       @data[convert_key key]
     end

data/lib/cot/frame_class_methods.rb

@@ -0,0 +1,63 @@
+module Cot
+  module FrameClassMethods
+    attr_accessor :attr_methods,
+                  :inverted_mappings,
+                  :inverted_search_mappings,
+                  :search_mappings,
+                  :value_blocks,
+                  :mappings
+
+    def search_property(name, args = {})
+      @search_mappings ||= {}
+
+      key = args[:from] ? args[:from] : name
+      @search_mappings[name] = key
+    end
+
+    def enum(name, &block)
+      obj = Enum.new
+      obj.instance_eval(&block)
+      define_method name do
+        obj
+      end
+    end
+
+    def property(name, args = {}, &block)
+      set_default_values
+      prop = Property.new args
+      prop.instance_eval(&block) if block
+
+      @value_blocks[name] = prop.value if prop.value
+
+      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
+      @mappings ||= {}
+      @attr_methods ||= []
+      @search_mappings ||= {}
+      @value_blocks ||= {}
+    end
+
+    def define_property_methods(name)
+      define_method name do
+        self[name]
+      end
+
+      define_method "#{name}=" do |value|
+        send("#{name}_will_change!") unless value == self[name]
+        self[name] = value
+      end
+      define_attribute_method name
+    end
+  end
+end

data/lib/cot/property.rb

@@ -0,0 +1,20 @@
+module Cot
+  class Property
+    attr_accessor :args
+    def initialize(params = {})
+      @args = params
+    end
+
+    def value(&block)
+      return args[:value] unless block
+      args[:value] = block
+    end
+
+    [:from, :searchable].each do |method_name|
+      define_method method_name do |value = nil|
+        return args[method_name] if value.nil?
+        args[method_name] = value
+      end
+    end
+  end
+end

data/lib/cot/version.rb

@@ -1,3 +1,3 @@
 module Cot
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/lib/cot/frame_spec.rb

@@ -118,6 +118,43 @@ describe Cot::Frame do
       expect(foo).to receive('[]').once.and_return 'this is foo'
       expect(foo.foo).to eq 'this is foo'
     end
+
+    context 'passing a block' do
+      before :each do
+        class Foo
+          attr_reader :params
+          def initialize(params)
+            @params = params
+          end
+        end
+        class TestObject < Cot::Frame
+          property :my_id, from: :id
+          property :thing do
+            from :stuff
+            searchable true
+            value do |params|
+              Foo.new params.merge passed: my_id
+            end
+          end
+        end
+        @foo = TestObject.new(stuff: { key: 'this will be in foo' }, id: 42)
+      end
+
+      it 'adds to mappings' do
+        expect(TestObject.mappings).to have_key :stuff
+        expect(TestObject.mappings[:stuff]).to be :thing
+      end
+
+      it 'stores searchable' do
+        expect(TestObject.search_mappings).to have_key :thing
+        expect(TestObject.search_mappings[:thing]).to be :stuff
+      end
+
+      it 'assigns sets the value' do
+        expect(@foo.thing).to be_kind_of Foo
+        expect(@foo.thing.params[:passed]).to eq 42
+      end
+    end
   end
 
   context 'errors' do
@@ -134,12 +171,37 @@ describe Cot::Frame do
     end
   end
   context 'enum' do
-    it 'is not implemented' do
+    before :each do
+      class TestObject < Cot::Frame
+        enum :types do
+          entry :first
+          entry :third, value: 3
+          entry :fourth
+        end
+      end
+      @foo = TestObject.new
+    end
+    it 'sets the value starting at 1' do
+      expect(@foo.types.first).to eq 1
+    end
+
+    it 'allows the value to be set' do
+      expect(@foo.types.third).to eq 3
+    end
+
+    it 'increments after the next value' do
+      expect(@foo.types.fourth).to eq 4
+    end
+
+    it 'does not allow duplicates' do
       expect do
         class TestObject < Cot::Frame
-          enum 'asdf'
+          enum :types do
+            entry :first
+            entry :first_again, value: 1
+          end
         end
-      end.to raise_exception StandardError
+      end.to raise_error StandardError
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cot
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Joseph Henrich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-15 00:00:00.000000000 Z
+date: 2014-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -129,14 +129,18 @@ files:
 - cot.gemspec
 - lib/cot.rb
 - lib/cot/collection.rb
+- lib/cot/enum.rb
 - lib/cot/frame.rb
+- lib/cot/frame_class_methods.rb
+- lib/cot/property.rb
 - lib/cot/rspec/matchers.rb
 - lib/cot/version.rb
 - spec/lib/cot/collection_spec.rb
 - spec/lib/cot/frame_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/crimsonknave/cot
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []