perforated 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 683803eb90edeac727bca419d2f5ab5e4f4db280
+  data.tar.gz: 2d465ab7a114dd20db77d731003fba5933fb5428
+SHA512:
+  metadata.gz: d3df769d45345f7d02d3653703c8da995954ea6686b51a7bc055b085861a554ab5a512d3cead7be248754c7b98f8403c8cb2da96ca654d934da93c6021a3182f
+  data.tar.gz: d5266599fb68f53c1d95e38f06cf7b4b000d3e98990c59de7326fca99a024a636d993246d0339f9febc224d2f46155d506776dbc1abc15face89652a53a3ab6b

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor
+bin

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+-I spec/spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+services:
+script: bundle exec rspec spec

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## Version 0.5.0
+
+* Initial release!

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in perforated-cache.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Parker Selbert
+
+MIT License
+
+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 the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+[![Build Status](https://travis-ci.org/sorentwo/perforated.png?branch=master)](https://travis-ci.org/sorentwo/perforated)
+[![Code Climate](https://codeclimate.com/github/sorentwo/perforated.png)](https://codeclimate.com/github/sorentwo/perforated)
+
+# Perforated
+
+The most expensive part of serving a JSON request is converting the serialized
+records into JSON. Perforated cache handles the messy task of storing and
+retrieving all JSON for a particular set of models as effeciently as possible.
+It achieves this several ways:
+
+1. Storing final json output, not marshalled objects
+2. Retrieving the json for as many objects at once as is possible, and then
+   filling in the remaining json as if it was always there. This is where the
+   term 'perforated' comes from.
+
+## Configuration
+
+Perforated is mildly configurable, mostly to allow for easy testing. However,
+if you are so inclined you can customize the backing cache. The default cache
+store is `ActiveSupport::Cache::MemoryStore`, which is fast but has no
+persistence.
+
+Within a Rails project the simplest option is to lock with the Rails cache.
+
+```ruby
+Perforated.configure do |config|
+  config.cache = Rails.cache
+end
+```
+
+Outside of a rails project you may wish to use something like Dalli by itself:
+
+```ruby
+Perforated.configure do |config|
+  config.cache = ActiveSupport::Cache::DalliStore.new('localhost')
+end
+```
+
+## Usage
+
+Wrap any collection that you want to serialize in an a cache instance and then
+call `as_json` or `to_json` on it. Not much to it!
+
+```ruby
+perforated = Perforated::Cache.new(my_collection)
+perforated.to_json
+perforated.as_json
+```
+
+Any objects that have been cached will be retrieved unaltered. Any missing
+objects (cache misses) will be serialized, inserted back into the collection,
+and written into the cache.
+
+### Custom Key Strategy
+
+The default cache key strategy is to delegate back to each object to construct
+its own cache key. This is useful for an object like a serializer that can
+implement it's own `cache_key` method.
+
+```ruby
+class MySerializer
+  attr_reader :object
+
+  def initialize(object)
+    @object = object
+  end
+
+  def cache_key
+    [object, scope]
+  end
+end
+```
+
+However, if you are just serializing models or objects that don't have a custom
+cache method you can provide a custom key caching strategy.
+
+```ruby
+module CustomStrategy
+  def self.expand_cache_key(object, suffix)
+    [object.id, object.updated_at, suffix].join('/')
+  end
+end
+
+perforated = Perforated::Cache.new(array, CustomStrategy)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'perforated-cache'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install perforated-cache
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/perforated/cache.rb

@@ -0,0 +1,51 @@
+module Perforated
+  class Cache
+    attr_reader :enumerable, :key_strategy
+
+    def initialize(enumerable, key_strategy = Perforated::Strategy::Default)
+      @enumerable   = enumerable
+      @key_strategy = key_strategy
+    end
+
+    def as_json(*)
+      keyed = keyed_enumerable('as-json')
+
+      fetch_multi(*keyed.keys) do |key|
+        keyed[key].as_json
+      end
+    end
+
+    def to_json(*)
+      keyed = keyed_enumerable('to-json')
+
+      json_objects = fetch_multi(*keyed.keys) do |key|
+        keyed[key].to_json
+      end
+
+      "[#{json_objects.join(',')}]"
+    end
+
+    private
+
+    # Backward compatible implementation of fetch multi.
+    def fetch_multi(*names)
+      options = {}
+      results = Perforated.cache.read_multi(*names, options)
+
+      names.map do |name|
+        results.fetch(name) do
+          value = yield name
+          Perforated.cache.write(name, value, options)
+          value
+        end
+      end
+    end
+
+    def keyed_enumerable(suffix = '')
+      enumerable.inject({}) do |memo, object|
+        memo[key_strategy.expand_cache_key(object, suffix)] = object
+        memo
+      end
+    end
+  end
+end

data/lib/perforated/strategy/default.rb

@@ -0,0 +1,11 @@
+module Perforated
+  module Strategy
+    class Default
+      def self.expand_cache_key(object, suffix = '')
+        args = object.cache_key + [suffix]
+
+        ActiveSupport::Cache.expand_cache_key(args)
+      end
+    end
+  end
+end

data/lib/perforated/version.rb

@@ -0,0 +1,3 @@
+module Perforated
+  VERSION = '0.5.0'
+end

data/lib/perforated.rb

@@ -0,0 +1,19 @@
+require 'active_support/cache'
+require 'json'
+require 'perforated/cache'
+require 'perforated/strategy/default'
+require 'perforated/version'
+
+module Perforated
+  def self.cache=(new_cache)
+    @cache = new_cache
+  end
+
+  def self.cache
+    @cache ||= ActiveSupport::Cache::MemoryStore.new
+  end
+
+  def self.configure
+    yield self
+  end
+end

data/perforated.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'perforated/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'perforated'
+  spec.version       = Perforated::VERSION
+  spec.authors       = ['Parker Selbert']
+  spec.email         = ['parker@sorentwo.com']
+  spec.homepage      = 'https://github.com/sorentwo/perforated'
+  spec.license       = 'MIT'
+  spec.description   = %(Intellgent json collection caching)
+  spec.summary       = <<-SUMMARY
+    The most expensive part of serving a JSON request is converting the
+    serialized records into JSON. Perforated cache handles the messy task of
+    storing and retrieving all JSON for a particular set of models as
+    effeciently as possible. It achieves this several ways:
+  SUMMARY
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '> 3.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake',    '~> 10.1.0'
+  spec.add_development_dependency 'rspec',   '~> 2.14.0'
+end

data/spec/perforated/cache_spec.rb

@@ -0,0 +1,53 @@
+require 'perforated'
+
+describe Perforated::Cache do
+  after { Perforated.cache.clear }
+
+  Language = Struct.new(:name) do
+    def as_json
+      { name: name }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+
+    def cache_key
+      ['Language', name]
+    end
+  end
+
+  describe '#as_json' do
+    it 'constructs an automatically cached serialized' do
+      ruby   = Language.new('Ruby')
+      elixir = Language.new('Elixir')
+      array  = [ruby, elixir]
+      cache  = Perforated::Cache.new(array)
+
+      cache.as_json.should == [{ name: 'Ruby' }, { name: 'Elixir' }]
+
+      Perforated.cache.read('Language/Ruby/as-json').should   == ruby.as_json
+      Perforated.cache.read('Language/Elixir/as-json').should == elixir.as_json
+    end
+
+    it 'does not overwrite existing key values' do
+      erlang = Language.new('Erlang')
+      Perforated.cache.write('Language/Erlang/as-json', { name: 'Elixir' })
+
+      Perforated::Cache.new([erlang]).as_json
+
+      Perforated.cache.read('Language/Erlang/as-json').should == { name: 'Elixir' }
+    end
+  end
+
+  describe '#to_json' do
+    it 'constructs a stringified json array of underlying values' do
+      cache = Perforated::Cache.new([Language.new('Ruby'), Language.new('Elixir')])
+
+      cache.to_json.should == %([{"name":"Ruby"},{"name":"Elixir"}])
+
+      Perforated.cache.exist?('Language/Ruby/to-json').should   be_true
+      Perforated.cache.exist?('Language/Elixir/to-json').should be_true
+    end
+  end
+end

data/spec/perforated_spec.rb

@@ -0,0 +1,23 @@
+require 'perforated'
+
+describe Perforated do
+  after { Perforated.cache = nil }
+
+  describe '#configuration' do
+    it 'stores an injected cache object' do
+      custom_cache = Object.new
+
+      Perforated.configure do |config|
+        config.cache = custom_cache
+      end
+
+      Perforated.cache.should be(custom_cache)
+    end
+  end
+
+  describe '#cache' do
+    it 'falls back to ActiveSupport::Cache::MemoryStore' do
+      Perforated.cache.should be_instance_of(ActiveSupport::Cache::MemoryStore)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered                = true
+  config.order                                           = 'random'
+
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: perforated
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Parker Selbert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: Intellgent json collection caching
+email:
+- parker@sorentwo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/perforated.rb
+- lib/perforated/cache.rb
+- lib/perforated/strategy/default.rb
+- lib/perforated/version.rb
+- perforated.gemspec
+- spec/perforated/cache_spec.rb
+- spec/perforated_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sorentwo/perforated
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: 'The most expensive part of serving a JSON request is converting the serialized
+  records into JSON. Perforated cache handles the messy task of storing and retrieving
+  all JSON for a particular set of models as effeciently as possible. It achieves
+  this several ways:'
+test_files:
+- spec/perforated/cache_spec.rb
+- spec/perforated_spec.rb
+- spec/spec_helper.rb