kartograph 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0486e484ee7a91e233645567afcf28f2ff25d6b
-  data.tar.gz: 0b6232dbd15c7a27a90f89b00652abdc4912a789
+  metadata.gz: 8fd632485d17da22b0e4d02656914d1a150d4cbf
+  data.tar.gz: 33045537b5961949bd128b12b51d61266b9532fb
 SHA512:
-  metadata.gz: 389d7c025aad932d0f22e2d5b3fa1d03d907bd5af1cb06d916549af5caadfc10c47ee975ef3a0d5c4c9de6ea093bfc039bf2b9dccd8e34345ca5a9f5a6c0d994
-  data.tar.gz: aeff8daa983de66a69c76a7c73e995d91ce28b977c2749c7eba257ecda38294ba6d4653eb0f16c03f8bcac860003cd4b072dc44cecd1e25d1cb265d7a1f6092a
+  metadata.gz: 86471a3fc7372a2bde1038c9aeb97310a6190e66e150f6c0c27528db369fcb27cfde4e19dbe9605f9fb44c2e7459f1f33c919b2afb8265a3aa1fa4392d430ab9
+  data.tar.gz: 9b5beb0e77705f6ce61b87a6755f17cb90342c0e56c36dfabe04c733520dadbdf4526da5057081db0ca3c61cbc6f52239f4b8970d103149e40950f0319e4d13e

data/README.md

@@ -29,8 +29,8 @@ class UserMapping
   kartograph do
     mapping User # The object we're mapping
 
-    property :name, scopes: [:create, :update]
-    property :id, scopes: [:read]
+    property :name, :email, scopes: [:create, :update]
+    property :id, scopes: :read
   end
 end
 
@@ -111,6 +111,35 @@ users = UserMapping.extract_collection(response.body, :read)
 It will look for the root key before trying to deserialize the JSON response.
 The advantage of this is it will only use the root key if there is a scope defined for it.
 
+
+### Including other definitions within eachother
+
+Sometimes you might have models that are nested within eachother on responses. Or you simply want to cleanup definitions by separating concerns. Kartograph lets you do this with includes.
+
+```ruby
+class UserMapping
+  include Kartograph::DSL
+
+  kartograph do
+    mapping User
+    property :id, scopes: [:read]
+    property :comments, plural: true, include: CommentMapping
+  end
+end
+
+class CommentMapping
+  include Kartograph::DSL
+
+  kartograph do
+    mapping Comment
+    property :id, scopes: [:read]
+    property :text, scopes: [:read]
+  end
+end
+```
+
+Now when JSON includes comments for a user, it will know how to map the comments using the provided Kartograph definition.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/kartograph/fork )

data/kartograph.gemspec

@@ -7,9 +7,9 @@ Gem::Specification.new do |spec|
   spec.name          = "kartograph"
   spec.version       = Kartograph::VERSION
   spec.authors       = ["Robert Ross"]
-  spec.email         = ["rross@digitalocean.com"]
-  spec.summary       = %q{Short Summary}
-  spec.description   = %q{Short Description}
+  spec.email         = ["rross@digitalocean.com", "ivan@digitalocean.com"]
+  spec.summary       = %q{Kartograph makes it easy to generate and convert JSON. It's intention is to be used for API clients.}
+  spec.description   = %q{Kartograph makes it easy to generate and convert JSON. It's intention is to be used for API clients.}
   spec.homepage      = ""
   spec.license       = "MIT"
 

data/lib/kartograph/dsl.rb

@@ -8,7 +8,11 @@ module Kartograph
       def kartograph(&block)
         @kartograph_map ||= Map.new
 
-        block.arity > 0 ? block.call(@kartograph_map) : @kartograph_map.instance_eval(&block)
+        if block_given?
+          block.arity > 0 ? block.call(@kartograph_map) : @kartograph_map.instance_eval(&block)
+        end
+
+        @kartograph_map
       end
 
       def representation_for(scope, object, dumper = JSON)

data/lib/kartograph/map.rb

@@ -1,7 +1,10 @@
 module Kartograph
   class Map
     def property(*args, &block)
-      properties << Property.new(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each do |prop|
+        properties << Property.new(prop, options, &block)
+      end
     end
 
     def properties
@@ -28,5 +31,27 @@ module Kartograph
         root_key.send(type)
       end
     end
+
+    def dup
+      Kartograph::Map.new.tap do |map|
+        self.properties.each do |property|
+          map.properties << property.dup
+        end
+
+        map.mapping self.mapping
+
+        self.root_keys.each do |rk|
+          map.root_keys << rk
+        end
+      end
+    end
+
+    def ==(other)
+      methods = %i(properties root_keys mapping)
+      methods.inject(true) do |current_value, method|
+        break unless current_value
+        send(method) == other.send(method)
+      end
+    end
   end
 end

data/lib/kartograph/property.rb

@@ -1,11 +1,18 @@
 module Kartograph
   class Property
-    attr_reader :name, :options, :map
+    attr_reader :name, :options
+    attr_accessor :map
 
     def initialize(name, options = {}, &block)
       @name = name
       @options = options
 
+      if mapped_class = options[:include]
+        # Perform a safe duplication into our properties map
+        # This allows the user to define more attributes on the map should they need to
+        @map = mapped_class.kartograph.dup
+      end
+
       if block_given?
         @map ||= Map.new
         block.arity > 0 ? block.call(map) : map.instance_eval(&block)
@@ -18,18 +25,32 @@ module Kartograph
     end
 
     def value_from(object, scope = nil)
+      return if object.nil?
       value = object.has_key?(name) ? object[name] : object[name.to_s]
       map ? sculpt_value(value, scope) : value
     end
 
     def scopes
-      options[:scopes] || []
+      Array(options[:scopes] || [])
     end
 
     def plural?
       !!options[:plural]
     end
 
+    def dup
+      Property.new(name, options.dup).tap do |property|
+        property.map = map.dup if self.map
+      end
+    end
+
+    def ==(other)
+      %i(name options map).inject(true) do |equals, method|
+        break unless equals
+        send(method) == other.send(method)
+      end
+    end
+
     private
 
     def sculpt_value(value, scope)

data/lib/kartograph/property_collection.rb

@@ -16,5 +16,12 @@ module Kartograph
         property.scopes.include?(scope)
       end
     end
+
+    def ==(other)
+      each_with_index.inject(true) do |current_value, (property, index)|
+        break unless current_value
+        property == other[index]
+      end
+    end
   end
 end

data/lib/kartograph/version.rb

@@ -1,3 +1,4 @@
 module Kartograph
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end
+

data/spec/lib/kartograph/dsl_spec.rb

@@ -12,7 +12,11 @@ describe Kartograph::DSL do
     subject(:mapping) { Class.new { include Kartograph::DSL } }
 
     it 'yields a Kartograph::Map instance' do
-      expect {|b| mapping.kartograph(&b) }.to yield_with_args(instance_of(Kartograph::Map))
+      expect {|b| mapping.kartograph(&b) }.to yield_with_args(Kartograph::Map.new)
+    end
+
+    it 'returns the map instance' do
+      expect(mapping.kartograph).to be_kind_of(Kartograph::Map)
     end
   end
 

data/spec/lib/kartograph/map_spec.rb

@@ -9,6 +9,21 @@ describe Kartograph::Map do
       expect(map.properties.size).to be(1)
       expect(map.properties.first).to be_kind_of(Kartograph::Property)
     end
+
+    context 'defining multiple properties' do
+      it 'adds multiple properties at the same time for the scope' do
+        map.property :attribute1, :attribute2, scopes: [:read]
+
+        expect(map.properties.size).to be(2)
+        expect(map.properties).to all(be_kind_of(Kartograph::Property))
+
+        expect(map.properties[0].name).to eq(:attribute1)
+        expect(map.properties[0].scopes).to eq([:read])
+
+        expect(map.properties[1].name).to eq(:attribute2)
+        expect(map.properties[1].scopes).to eq([:read])
+      end
+    end
   end
 
   describe '#properties' do
@@ -43,4 +58,38 @@ describe Kartograph::Map do
       expect(key).to eq('test')
     end
   end
+
+  describe '#dup' do
+    it 'performs a safe duplication of the map' do
+      mapped_class = Class.new
+
+      prop1 = map.property :name, scopes: [:read, :write]
+      prop2 = map.property :id, scopes: [:read]
+      map.mapping mapped_class
+      map.root_key singular: 'woot', plural: 'woots', scopes: [:read]
+
+      new_map = map.dup
+
+      expect(new_map.properties[0]).to_not be(prop1)
+      expect(new_map.properties[1]).to_not be(prop2)
+
+      expect(new_map.properties).to all(be_kind_of(Kartograph::Property))
+      expect(new_map.properties[0].name).to eq(:name)
+      expect(new_map.properties[1].name).to eq(:id)
+
+      expect(new_map.mapping).to eq(mapped_class)
+      expect(new_map.root_keys).to eq(map.root_keys)
+    end
+  end
+
+  describe 'Equality' do
+    specify 'duplicated maps are equal to eachother' do
+      map1 = Kartograph::Map.new
+      map1.property :something, scopes: [:read]
+
+      map2 = map1.dup
+
+      expect(map1).to eq(map2)
+    end
+  end
 end

data/spec/lib/kartograph/property_spec.rb

@@ -13,7 +13,21 @@ describe Kartograph::Property do
 
     context 'with a block' do
       it 'yields a map instance for the property' do
-        expect {|b| Kartograph::Property.new(:hello, &b) }.to yield_with_args(instance_of(Kartograph::Map))
+        expect {|b| Kartograph::Property.new(:hello, &b) }.to yield_with_args(Kartograph::Map.new)
+      end
+    end
+
+    context 'with an include' do
+      it 'sets the map to the included mapped class' do
+        klass = Class.new do
+          include Kartograph::DSL
+          kartograph do
+            property :lol, scopes: [:read]
+          end
+        end
+
+        property = Kartograph::Property.new(:id, scopes: [:read], include: klass)
+        expect(property.map).to eq(klass.kartograph)
       end
     end
   end
@@ -28,6 +42,11 @@ describe Kartograph::Property do
       property = Kartograph::Property.new(:name)
       expect(property.scopes).to eq( [] )
     end
+
+    it 'always casts to an array' do
+      property = Kartograph::Property.new(:name, scopes: :read)
+      expect(property.scopes).to eq [:read]
+    end
   end
 
   describe '#plural?' do
@@ -90,6 +109,14 @@ describe Kartograph::Property do
       expect(property.value_from(hash)).to eq('world')
     end
 
+    context 'for a nil object' do
+      it 'bails and does not try to retrieve' do
+        property = Kartograph::Property.new(:hello)
+        value = property.value_from(nil)
+        expect(value).to be_nil
+      end
+    end
+
     context 'string and symbol agnostic' do
       let(:hash) { { 'hello' => 'world' } }
 
@@ -152,4 +179,16 @@ describe Kartograph::Property do
       end
     end
   end
+
+  describe '#dup' do
+    it 'copies the name, options, and map into another property' do
+      instance = Kartograph::Property.new(:id, scopes: [:read])
+      duped = instance.dup
+
+      expect(duped).to be_kind_of(Kartograph::Property)
+      expect(duped.name).to eq(:id)
+      expect(duped.options).to_not be(instance.options)
+      expect(duped.options).to eq(instance.options)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kartograph
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Robert Ross
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2014-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,9 +66,11 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Short Description
+description: Kartograph makes it easy to generate and convert JSON. It's intention
+  is to be used for API clients.
 email:
 - rross@digitalocean.com
+- ivan@digitalocean.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -125,7 +127,8 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Short Summary
+summary: Kartograph makes it easy to generate and convert JSON. It's intention is
+  to be used for API clients.
 test_files:
 - spec/lib/kartograph/artist_spec.rb
 - spec/lib/kartograph/dsl_spec.rb