moneta 0.6.0 → 0.7.0

data/lib/moneta/transformer/config.rb

@@ -0,0 +1,42 @@
+module Moneta
+  class Transformer
+    # Available key/value transformers
+    TRANSFORMER = {
+      # Name    => [ Type,       Load,                               Dump,                                Library         ],
+      :bencode  => [ :serialize, '::BEncode.load(value)',             '::BEncode.dump(value)',             'bencode'       ],
+      :bert     => [ :serialize, '::BERT.decode(value)',              '::BERT.encode(value)',              'bert'          ],
+      :bson     => [ :serialize, "::BSON.deserialize(value)['v']",    "::BSON.serialize('v'=>value).to_s", 'bson'          ],
+      :json     => [ :serialize, '::MultiJson.load(value).first',     '::MultiJson.dump([value])',         'multi_json'    ],
+      :marshal  => [ :serialize, '::Marshal.load(value)',             '::Marshal.dump(value)'                              ],
+      :msgpack  => [ :serialize, '::MessagePack.unpack(value)',       '::MessagePack.pack(value)',         'msgpack'       ],
+      :ox       => [ :serialize, '::Ox.parse_obj(value)',             '::Ox.dump(value)',                  'ox'            ],
+      :tnet     => [ :serialize, '::TNetstring.parse(value).first',   '::TNetstring.dump(value)',          'tnetstring'    ],
+      :yaml     => [ :serialize, '::YAML.load(value)',                '::YAML.dump(value)',                'yaml'          ],
+      :bzip2    => [ :compress,  '::Bzip2.uncompress(value)',         '::Bzip2.compress(value)',           'bzip2'         ],
+      :lzma     => [ :compress,  '::LZMA.decompress(value)',          '::LZMA.compress(value)',            'lzma'          ],
+      :lzo      => [ :compress,  '::LZO.decompress(value)',           '::LZO.compress(value)',             'lzoruby'       ],
+      :snappy   => [ :compress,  '::Snappy.inflate(value)',           '::Snappy.deflate(value)',           'snappy'        ],
+      :quicklz  => [ :compress,  '::QuickLZ.decompress(value)',       '::QuickLZ.compress(value)',         'qlzruby'       ],
+      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(value)',    '::Zlib::Deflate.deflate(value)',    'zlib'          ],
+      :base64   => [ :encode,    "value.unpack('m').first",           "[value].pack('m').strip"                            ],
+      :uuencode => [ :encode,    "value.unpack('u').first",           "[value].pack('u').strip"                            ],
+      :escape   => [ :encode,    'Helper.unescape(value)',            'Helper.escape(value)'                               ],
+      :hmac     => [ :hmac,      'Helper.hmacverify(value, @secret)', 'Helper.hmacsign(value, @secret)',   'openssl'       ],
+      :truncate => [ :truncate,  nil,                                 'Helper.truncate(value, @maxlen)',   'digest/md5'    ],
+      :md5      => [ :digest,    nil,                                 '::Digest::MD5.hexdigest(value)',    'digest/md5'    ],
+      :rmd160   => [ :digest,    nil,                                 '::Digest::RMD160.hexdigest(value)', 'digest/rmd160' ],
+      :sha1     => [ :digest,    nil,                                 '::Digest::SHA1.hexdigest(value)',   'digest/sha1'   ],
+      :sha256   => [ :digest,    nil,                                 '::Digest::SHA256.hexdigest(value)', 'digest/sha2'   ],
+      :sha384   => [ :digest,    nil,                                 '::Digest::SHA384.hexdigest(value)', 'digest/sha2'   ],
+      :sha512   => [ :digest,    nil,                                 '::Digest::SHA512.hexdigest(value)', 'digest/sha2'   ],
+      :prefix   => [ :prefix,    nil,                                 '(options[:prefix]||@prefix)+value'                  ],
+      :spread   => [ :spread,    nil,                                 'Helper.spread(value)'                               ],
+    }
+
+    # Allowed value transformers (Read it like a regular expression!)
+    VALUE_TRANSFORMER = compile_validator('serialize? compress? hmac? encode?')
+
+    # Allowed key transformers (Read it like a regular expression!)
+    KEY_TRANSFORMER = compile_validator('serialize? prefix? ((encode? truncate?) | (digest spread?))?')
+  end
+end

data/lib/moneta/transformer/helper.rb

@@ -0,0 +1,37 @@
+module Moneta
+  class Transformer
+    # @api private
+    module Helper
+      extend self
+
+      def escape(value)
+        value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }
+      end
+
+      def unescape(value)
+        value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }
+      end
+
+      def hmacverify(value, secret)
+        hash, value = value[0..31], value[32..-1]
+        value if hash == OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value)
+      end
+
+      def hmacsign(value, secret)
+        OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value) << value
+      end
+
+      def truncate(value, maxlen)
+        if value.size >= maxlen
+          digest = Digest::MD5.hexdigest(value)
+          value = value[0, value.size-digest.size] << digest
+        end
+        value
+      end
+
+      def spread(value)
+        ::File.join(value[0..1], value[2..-1])
+      end
+    end
+  end
+end

data/lib/moneta/version.rb

@@ -0,0 +1,5 @@
+module Moneta
+  # Moneta version number
+  # @api public
+  VERSION = '0.7.0'
+end

data/lib/moneta/wrapper.rb

@@ -0,0 +1,33 @@
+module Moneta
+  # Wraps the calls to the adapter
+  # @api public
+  class Wrapper < Proxy
+    def key?(key, options = {})
+      wrap(:key?, key, options) { super }
+    end
+
+    def load(key, options = {})
+      wrap(:load, key, options) { super }
+    end
+
+    def store(key, value, options = {})
+      wrap(:store, key, value, options) { super }
+    end
+
+    def delete(key, options = {})
+      wrap(:delete, key, options) { super }
+    end
+
+    def increment(key, amount = 1, options = {})
+      wrap(:increment, key, amount, options) { super }
+    end
+
+    def clear(options = {})
+      wrap(:clear, options) { super }
+    end
+
+    def close
+      wrap(:close) { super }
+    end
+  end
+end

data/lib/rack/cache/moneta.rb

@@ -0,0 +1,93 @@
+require 'moneta'
+require 'rack/cache/key'
+require 'rack/cache/metastore'
+require 'rack/cache/entitystore'
+
+module Rack
+  module Cache
+    Moneta = {}
+
+    module MonetaResolver
+      include Rack::Utils
+
+      def resolve(uri)
+        cache = Rack::Cache::Moneta[uri.to_s.sub(%r{^moneta://}, '')] ||=
+          begin
+            options = parse_query(uri.query)
+            options.keys.each do |key|
+            options[key.to_sym] =
+              case value = options.delete(key)
+              when 'true'; true
+              when 'false'; false
+              else value
+              end
+          end
+            ::Moneta.new(uri.host.to_sym, options)
+          end
+        new(cache)
+      end
+    end
+
+    class MetaStore
+      class Moneta < MetaStore
+        extend MonetaResolver
+
+        def initialize(cache)
+          @cache = cache
+        end
+
+        def read(key)
+          @cache[key] || []
+        end
+
+        def write(key, entries)
+          @cache[key] = entries
+        end
+
+        def purge(key)
+          @cache.delete(key)
+          nil
+        end
+      end
+
+      MONETA = Moneta
+    end
+
+    class EntityStore
+      class Moneta < EntityStore
+        extend MonetaResolver
+
+        def initialize(cache)
+          @cache = cache
+        end
+
+        def open(key)
+          data = read(key)
+          data && [data]
+        end
+
+        def exist?(key)
+          @cache.key?(key)
+        end
+
+        def read(key)
+          @cache[key]
+        end
+
+        def write(body, ttl = 0)
+          buf = StringIO.new
+          key, size = slurp(body) { |part| buf.write(part) }
+          @cache.store(key, buf.string, ttl == 0 ? {} : {:expires => ttl})
+          [key, size]
+        end
+
+        def purge(key)
+          @cache.delete(key)
+          nil
+        end
+      end
+
+      MONETA = Moneta
+    end
+  end
+end

data/lib/rack/moneta_cookies.rb

@@ -0,0 +1,64 @@
+require 'moneta'
+require 'rack/utils'
+
+module Rack
+  # A Rack middleware that was made to reuse all moneta transformers
+  # on the cookie hash.
+  #
+  # @example config.ru
+  #   # Add Rack::MonetaCookies somewhere in your rack stack
+  #   use Rack::MonetaCookies
+  #
+  #   run lambda { |env| [200, {}, []] }
+  #   # But this doesn't do much
+  #
+  # @example config.ru
+  #   # Give it some options
+  #   use Rack::MonetaCookies, :domain => 'example.com', :path => '/path'
+  #
+  # @example config.ru
+  #   # Pass it a block like the one passed to Moneta.build
+  #   use Rack::MonetaCookies do
+  #     use :Transformer, :key => :prefix, :prefix => 'moneta.'
+  #     adapter :Cookie
+  #   end
+  #
+  #   run lambda do |env|
+  #     req = Rack::Request.new(env)
+  #     req.cookies #=> is now a Moneta store!
+  #     env['rack.request.cookie_hash'] #=> is now a Moneta store!
+  #     req.cookies['key'] #=> retrieves 'moneta.key'
+  #     req.cookies['key'] = 'value' #=> sets 'moneta.key'
+  #     req.cookies.delete('key') #=> removes 'moneta.key'
+  #     [200, {}, []]
+  #   end
+  #
+  class MonetaCookies
+    def initialize(app, options = {}, &block)
+      @app, @pool = app, []
+      if block
+        raise ArgumentError, 'Use either block or options' unless options.empty?
+        @builder = Moneta::Builder.new(&block)
+      else
+        @builder = Moneta::Builder.new { adapter :Cookie, options }
+      end
+    end
+
+    def call(env)
+      stores = @pool.pop || @builder.build
+      env['rack.request.cookie_hash'] = stores.last
+      env['rack.request.cookie_string'] = env['HTTP_COOKIE']
+      stores.first.reset(Rack::Utils.parse_query(env['HTTP_COOKIE']))
+      status, headers, body = @app.call(env)
+      stores.first.cookies.each do |key, cookie|
+        if cookie == nil
+          Rack::Utils.delete_cookie_header!(headers, key)
+        else
+          Rack::Utils.set_cookie_header!(headers, key, cookie)
+        end
+      end
+      @pool << stores
+      [status, headers, body]
+    end
+  end
+end

data/lib/rack/session/moneta.rb

@@ -0,0 +1,63 @@
+require 'moneta'
+require 'rack/session/abstract/id'
+require 'thread'
+
+module Rack
+  module Session
+    class Moneta < Abstract::ID
+      attr_reader :mutex, :pool
+
+      def initialize(app, options = {}, &block)
+        super
+        if block
+          raise ArgumentError, 'Use either block or option :store' if options[:store]
+          @pool = ::Moneta.build(&block)
+        else
+          raise ArgumentError, 'Option :store is required' unless @pool = options[:store]
+          @pool = ::Moneta.new(@pool, :expires => true) if Symbol === @pool
+        end
+        @mutex = Mutex.new
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.key?(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        with_lock(env) do
+          unless sid && session = @pool[sid]
+            sid, session = generate_sid, {}
+            @pool[sid] = session
+          end
+          [sid, session]
+        end
+      end
+
+      def set_session(env, session_id, new_session, options)
+        with_lock(env) do
+          @pool.store(session_id, new_session,
+                       options[:expire_after] ? {:expires => options[:expire_after]} : {})
+          session_id
+        end
+      end
+
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          @pool.delete(session_id)
+          generate_sid unless options[:drop]
+        end
+      end
+
+      def with_lock(env)
+        @mutex.lock if env['rack.multithread']
+        yield
+      ensure
+        @mutex.unlock if @mutex.locked?
+      end
+    end
+  end
+end
+

data/moneta.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/moneta/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name             = 'moneta'
+  s.version          = Moneta::VERSION
+  s.date             = Date.today.to_s
+  s.authors          = ['Daniel Mendler', 'Yehuda Katz' 'Hannes Georg']
+  s.email            = %w{mail@daniel-mendler.de wycats@gmail.com hannes.georg@googlemail.com}
+  s.description      = 'A unified interface to key/value stores'
+  s.extra_rdoc_files = %w{README.md SPEC.md LICENSE}
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage         = 'http://github.com/minad/moneta'
+  s.require_paths    = ['lib']
+  s.summary          = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
+end

data/spec/action_dispatch/fixtures/session_autoload_test/foo.rb

@@ -0,0 +1,10 @@
+module SessionAutoloadTest
+  class Foo
+    def initialize(bar='baz')
+      @bar = bar
+    end
+    def inspect
+      "#<#{self.class} bar:#{@bar.inspect}>"
+    end
+  end
+end

data/spec/action_dispatch/session_moneta_store_spec.rb

@@ -0,0 +1,196 @@
+require 'action_dispatch'
+require 'action_controller'
+require 'action_dispatch/middleware/session/moneta_store'
+require 'minitest/autorun'
+
+class MonetaStoreTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def no_session_access
+      head :ok
+    end
+
+    def set_session_value
+      session[:foo] = "bar"
+      head :ok
+    end
+
+    def set_serialized_session_value
+      session[:foo] = SessionAutoloadTest::Foo.new
+      head :ok
+    end
+
+    def get_session_value
+      render :text => "foo: #{session[:foo].inspect}"
+    end
+
+    def get_session_id
+      render :text => "#{request.session_options[:id]}"
+    end
+
+    def call_reset_session
+      session[:bar]
+      reset_session
+      session[:bar] = "baz"
+      head :ok
+    end
+  end
+
+  def test_setting_and_getting_session_value
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: "bar"', response.body
+    end
+  end
+
+  def test_getting_nil_session_value
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+    end
+  end
+
+  def test_getting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_cookie = cookies.send(:hash_for)['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      cookies << session_cookie # replace our new session_id with our old, pre-reset session_id
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from cache"
+    end
+  end
+
+  def test_getting_from_nonexistent_session
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      assert_nil cookies['_session_id'], "should only create session on write, not read"
+    end
+  end
+
+  def test_setting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+
+      get '/get_session_id'
+      assert_response :success
+      assert_not_equal session_id, response.body
+    end
+  end
+
+  def test_getting_session_id
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/get_session_id'
+      assert_response :success
+      assert_equal session_id, response.body, "should be able to read session id without accessing the session hash"
+    end
+  end
+
+  def test_deserializes_unloaded_class
+    with_test_route_set do
+      with_autoload_path do
+        get '/set_serialized_session_value'
+        assert_response :success
+        assert cookies['_session_id']
+      end
+      with_autoload_path do
+        get '/get_session_id'
+        assert_response :success
+      end
+      with_autoload_path do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: #<SessionAutoloadTest::Foo bar:"baz">', response.body, "should auto-load unloaded class"
+      end
+    end
+  end
+
+  def test_doesnt_write_session_cookie_if_session_id_is_already_exists
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal nil, headers['Set-Cookie'], "should not resend the cookie again if session_id cookie is already exists"
+    end
+  end
+
+  def test_prevents_session_fixation
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      session_id = cookies['_session_id']
+
+      reset!
+
+      get '/set_session_value', :_session_id => session_id
+      assert_response :success
+      assert_not_equal session_id, cookies['_session_id']
+    end
+  end
+
+  private
+
+  def with_autoload_path
+    path = File.join(File.dirname(__FILE__), 'fixtures')
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end
+    end
+  end
+
+  def with_test_route_set
+    with_routing do |set|
+      set.draw do
+        get ':action', :to => ::MonetaStoreTest::TestController
+      end
+
+      @app = ActionDispatch::MiddlewareStack.new do |middleware|
+        middleware.use ActionDispatch::Session::MonetaStore, :key => '_session_id', :store => :Memory
+      end.build(set)
+
+      yield
+    end
+  end
+end