kartograph 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0295131c24571bb5b97074b8c6ddb293d6e6e5c5
-  data.tar.gz: c54a19d0f60e9671b01f46dc7c3e22e9336f4a1d
+  metadata.gz: cd413914c014eb3f1127307accfe7415bd9cf5e0
+  data.tar.gz: 6f9f614581f8542da63cf5ed48253058608e37aa
 SHA512:
-  metadata.gz: 1f9810e797d94884d70753280442945dd1c8a05fc956d0e545e81fed318fdf087468ad315b60ecc98a8bbd3967f8ad82a0234ace82b75ace8b1e9146f5e3c1d7
-  data.tar.gz: 31cd1b4efc22648129ee836936bd90e42ee428ae351526784ae3e307d7148e473558a3982768b8d9137e530d08a50622525410a3d40b5912cc4f1615b587276f
+  metadata.gz: 0df0e80384d6964490b4bd1102dbccc597e21c2bfc0c60bad4d2326541845f86cc1ed15200db6f79a831f904dcb062366993cc441581718114ac79577e43fb93
+  data.tar.gz: 62da5885c11e5f6445e4d8132e91f70256b6a16966de26cbe35b2d38bb037b6e29a94fe7ab6bbe90d95e72fa1229de8d6a253a5b107279feff6432f30a2c327d

data/README.md

@@ -173,6 +173,25 @@ end
 
 Now when JSON includes comments for a user, it will know how to map the comments using the provided Kartograph definition.
 
+---
+
+### Caching
+
+Kartograph has the option to cache certain serializations, determined by the way you setup the key.
+
+```ruby
+class UserMapping
+  include Kartograph::DSL
+
+  kartograph do
+    cache { Rails.cache } # As long as this respond to #fetch(key_name, options = {}, &block) it will work
+    cache_key { |object| object.cache_key }
+
+    end
+  end
+end
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/digitaloceancloud/kartograph/fork )

data/lib/kartograph.rb

@@ -11,4 +11,14 @@ module Kartograph
 
   autoload :Artist, 'kartograph/artist'
   autoload :Sculptor, 'kartograph/sculptor'
+
+  class << self
+    attr_accessor :default_dumper
+    attr_accessor :default_loader
+    attr_accessor :default_cache
+    attr_accessor :default_cache_key
+  end
+
+  self.default_dumper = JSON
+  self.default_loader = JSON
 end

data/lib/kartograph/artist.rb

@@ -12,9 +12,19 @@ module Kartograph
     end
 
     def draw(scope = nil)
+      if map.cache
+        cache_key = map.cache_key.call(object, scope)
+        map.cache.fetch(cache_key) { build_properties(scope) }
+      else
+        build_properties(scope)
+      end
+    end
+
+    def build_properties(scope)
       scoped_properties = scope ? properties.filter_by_scope(scope) : properties
       scoped_properties.each_with_object({}) do |property, mapped|
         raise ArgumentError, "#{object} does not respond to #{property.name}, so we can't map it" unless object.respond_to?(property.name)
+
         mapped[property.key] = property.value_for(object, scope)
       end
     end

data/lib/kartograph/dsl.rb

@@ -15,13 +15,13 @@ module Kartograph
         @kartograph_map
       end
 
-      def representation_for(scope, object, dumper = JSON)
+      def representation_for(scope, object, dumper = Kartograph.default_dumper)
         drawed = Artist.new(object, @kartograph_map).draw(scope)
 
         dumper.dump(prepend_root_key(scope, :singular, drawed))
       end
 
-      def represent_collection_for(scope, objects, dumper = JSON)
+      def represent_collection_for(scope, objects, dumper = Kartograph.default_dumper)
         drawed_objects = objects.map do |object|
           Artist.new(object, @kartograph_map).draw(scope)
         end
@@ -29,7 +29,7 @@ module Kartograph
         dumper.dump(prepend_root_key(scope, :plural, drawed_objects))
       end
 
-      def extract_single(content, scope, loader = JSON)
+      def extract_single(content, scope, loader = Kartograph.default_loader)
         loaded = loader.load(content)
 
         retrieve_root_key(scope, :singular) do |root_key|
@@ -40,7 +40,7 @@ module Kartograph
         Sculptor.new(loaded, @kartograph_map).sculpt(scope)
       end
 
-      def extract_collection(content, scope, loader = JSON)
+      def extract_collection(content, scope, loader = Kartograph.default_loader)
         loaded = loader.load(content)
 
         retrieve_root_key(scope, :plural) do |root_key|

data/lib/kartograph/map.rb

@@ -29,6 +29,16 @@ module Kartograph
       root_keys << RootKey.new(options)
     end
 
+    def cache(object = nil)
+      @cache = object unless object.nil?
+      @cache.nil? ? Kartograph.default_cache : @cache
+    end
+
+    def cache_key(&calculator)
+      @cache_calculator = calculator if block_given?
+      @cache_calculator.nil? ? Kartograph.default_cache_key : @cache_calculator
+    end
+
     def root_key_for(scope, type)
       return unless %i(singular plural).include?(type)
 
@@ -48,6 +58,9 @@ module Kartograph
         self.root_keys.each do |rk|
           map.root_keys << rk
         end
+
+        map.cache self.cache
+        map.cache_key &self.cache_key if self.cache_key
       end
     end
 

data/lib/kartograph/version.rb

@@ -1,4 +1,4 @@
 module Kartograph
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end
 

data/spec/lib/kartograph/artist_spec.rb

@@ -78,5 +78,37 @@ describe Kartograph::Artist do
         end
       end
     end
+
+    context "with caching enabled" do
+      let(:cacher) { double('cacher', fetch: { foo: 'cached-value' }) }
+      let(:object) { double('object', foo: 'bar', cache_key: 'test-cache-key') }
+
+      it "uses the cache fetch for values" do
+        map.cache(cacher)
+        map.cache_key { |obj, scope| obj.cache_key }
+        map.property :foo
+
+        artist = Kartograph::Artist.new(object, map)
+        masterpiece = artist.draw
+
+        expect(masterpiece).to eq(cacher.fetch)
+
+        expect(cacher).to have_received(:fetch).with('test-cache-key')
+      end
+
+      it "uses the cache key for the object and scope" do
+        called = double(call: 'my-cache')
+
+        map.cache(cacher)
+        map.cache_key { |obj, scope| called.call(obj, scope) }
+
+        map.property :foo, scopes: [:read]
+
+        artist = Kartograph::Artist.new(object, map)
+        masterpiece = artist.draw(:read)
+
+        expect(called).to have_received(:call).with(object, :read)
+      end
+    end
   end
 end

data/spec/lib/kartograph/map_spec.rb

@@ -68,6 +68,10 @@ describe Kartograph::Map do
       map.mapping mapped_class
       map.root_key singular: 'woot', plural: 'woots', scopes: [:read]
 
+      cache_key = Proc.new {}
+      map.cache 'hello'
+      map.cache_key &cache_key
+
       new_map = map.dup
 
       expect(new_map.properties[0]).to_not be(prop1)
@@ -79,6 +83,54 @@ describe Kartograph::Map do
 
       expect(new_map.mapping).to eq(mapped_class)
       expect(new_map.root_keys).to eq(map.root_keys)
+
+      expect(new_map.cache).to eq(map.cache)
+      expect(new_map.cache_key).to eq(cache_key)
+    end
+  end
+
+  describe '#cache' do
+    it "stores the caching method" do
+      cacher = double
+      map.cache cacher
+
+      expect(map.cache).to be(cacher)
+    end
+
+    it 'returns the kartograph cache if set' do
+      cacher = double('cache')
+      Kartograph.default_cache = cacher
+
+      expect(map.cache).to be(cacher)
+    end
+
+    it 'goes straight to the object if cache is overridden with false' do
+      cacher = double('cache')
+      Kartograph.default_cache = cacher
+
+      property = Kartograph::Property.new(:bunk) do
+        cache false
+      end
+
+      map.properties << property
+
+      expect(property.map.cache).to be(false)
+    end
+  end
+
+  describe '#cache_key' do
+    it 'stores the cache key block' do
+      cache_key = Proc.new {}
+      map.cache_key(&cache_key)
+
+      expect(map.cache_key).to be(cache_key)
+    end
+
+    it 'returns the kartograph cache_key if set' do
+      cache_key = double('cache key')
+      Kartograph.default_cache_key = cache_key
+
+      expect(map.cache_key).to be(cache_key)
     end
   end
 

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ Dir['./spec/support/**/*.rb'].each {|f| load f }
 RSpec.configure do |config|
 # The settings below are suggested to provide a good initial experience
 # with RSpec, but feel free to customize to your heart's content.
-=begin
+
   # These two settings work together to allow you to limit a spec run
   # to individual examples or groups you care about by tagging them with
   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
@@ -13,6 +13,15 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 
+  config.after(:each) do
+    Kartograph.default_dumper = JSON
+    Kartograph.default_loader = JSON
+    Kartograph.default_cache = nil
+    Kartograph.default_cache_key = nil
+  end
+
+=begin
+
   # Many RSpec users commonly either run the entire suite or an individual
   # file, and it's useful to allow more verbose output when running an
   # individual spec file.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kartograph
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Ross
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-14 00:00:00.000000000 Z
+date: 2014-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler