juno 0.3.1 → 0.4.0

data/lib/juno/expires.rb

@@ -1,47 +0,0 @@
-module Juno
-  # Adds expiration support to the underlying store
-  #
-  # #store and #load support the :expires option to set/update
-  # the expiration time.
-  #
-  # @api public
-  class Expires < Proxy
-    def key?(key, options = {})
-      load(key, options) != nil
-    end
-
-    def load(key, options = {})
-      value = check_expired(key, super(key, options))
-      if value && options.include?(:expires)
-        store(key, value, options)
-      else
-        value
-      end
-    end
-
-    def store(key, value, options = {})
-      if expires = options.delete(:expires)
-        super(key, [value, Time.now.to_i + expires].compact, options)
-      else
-        super(key, [value], options)
-      end
-      value
-    end
-
-    def delete(key, options = {})
-      check_expired(key, super, false)
-    end
-
-    protected
-
-    def check_expired(key, value, delete_expired = true)
-      value, expires = value
-      if expires && Time.now.to_i > expires
-        delete(key) if delete_expired
-        nil
-      else
-        value
-      end
-    end
-  end
-end

data/lib/juno/lock.rb

@@ -1,44 +0,0 @@
-require 'thread'
-
-module Juno
-  # Locks the underlying stores with a Mutex
-  # @api public
-  class Lock < Proxy
-    # Constructor
-    #
-    # @param [Juno store] adapter The underlying store
-    # @param [Hash] options
-    #
-    # Options:
-    # * :mutex - Mutex object (default Mutex.new)
-    def initialize(adapter, options = {})
-      super
-      @lock = options[:mutex] || Mutex.new
-    end
-
-    def key?(key, options = {})
-      @lock.synchronize { super }
-    end
-
-    def load(key, options = {})
-      @lock.synchronize { super }
-    end
-
-    def store(key, value, options = {})
-      @lock.synchronize { super }
-    end
-
-    def delete(key, options = {})
-      @lock.synchronize { super }
-    end
-
-    def clear(options = {})
-      @lock.synchronize { super }
-      self
-    end
-
-    def close
-      @lock.synchronize { super }
-    end
-  end
-end

data/lib/juno/logger.rb

@@ -1,86 +0,0 @@
-module Juno
-  # Logger proxy
-  # @api public
-  class Logger < Proxy
-    # Standard formatter used by the logger
-    # @api public
-    class Format
-      def initialize(options)
-        @prefix = options[:prefix] || 'Juno '
-        @out = options[:out] || STDOUT
-      end
-
-      def call(entry)
-        @out.write(format(entry))
-      end
-
-      protected
-
-      def format(entry)
-        args = entry[:args]
-        args.pop if Hash === args.last && args.last.empty?
-        args = args.map {|a| dump(a) }.join(', ')
-        if entry[:error]
-          "#{@prefix}#{entry[:method]}(#{args}) raised error: #{entry[:error].message}\n"
-        else
-          "#{@prefix}#{entry[:method]}(#{args}) -> #{dump entry[:return]}\n"
-        end
-      end
-
-      def dump(value)
-        value = value.inspect
-        value.size > 30 ? value[0..30] + '...' : value
-      end
-    end
-
-    # Constructor
-    #
-    # @param [Juno store] adapter The underlying store
-    # @param [Hash] options
-    #
-    # Options:
-    # * :logger - Callable logger object (default Juno::Logger::Format)
-    # * :logprefix - Prefix string (default 'Juno ')
-    # * :logout - Output (default STDOUT)
-    def initialize(adapter, options = {})
-      super
-      @logger = options[:logger] || Format.new(options)
-    end
-
-    def key?(key, options = {})
-      log(:key?, key, options) { super }
-    end
-
-    def load(key, options = {})
-      log(:load, key, options) { super }
-    end
-
-    def store(key, value, options = {})
-      log(:store, key, value, options) { super }
-    end
-
-    def delete(key, options = {})
-      log(:delete, key, options) { super }
-    end
-
-    def clear(options = {})
-      log(:clear, options) { super; nil }
-      self
-    end
-
-    def close
-      log(:close) { super }
-    end
-
-    protected
-
-    def log(method, *args)
-      ret = yield
-      @logger.call(:method => method, :args => args, :return => ret)
-      ret
-    rescue Exception => error
-      @logger.call(:method => method, :args => args, :error => error)
-      raise
-    end
-  end
-end

data/lib/juno/proxy.rb

@@ -1,72 +0,0 @@
-module Juno
-  # Proxy base class
-  # @api public
-  class Proxy < Base
-    attr_reader :adapter
-
-    # Constructor
-    #
-    # @param [Juno store] underlying adapter
-    # @param [Hash] options
-    def initialize(adapter, options = {})
-      @adapter = adapter
-    end
-
-    # Exists the value with key
-    #
-    # @param [Object] key
-    # @return [Boolean]
-    # @param [Hash] options
-    # @api public
-    def key?(key, options = {})
-      @adapter.key?(key, options)
-    end
-
-    # Fetch value with key. Return nil if the key doesn't exist
-    #
-    # @param [Object] key
-    # @param [Hash] options
-    # @return [Object] value
-    # @api public
-    def load(key, options = {})
-      @adapter.load(key, options)
-    end
-
-    # Store value with key
-    #
-    # @param [Object] key
-    # @param [Object] value
-    # @param [Hash] options
-    # @return value
-    # @api public
-    def store(key, value, options = {})
-      @adapter.store(key, value, options)
-    end
-
-    # Delete the key from the store and return the current value
-    #
-    # @param [Object] key
-    # @return [Object] current value
-    # @param [Hash] options
-    # @api public
-    def delete(key, options = {})
-      @adapter.delete(key, options)
-    end
-
-    # Clear all keys in this store
-    #
-    # @param [Hash] options
-    # @return [void]
-    # @api public
-    def clear(options = {})
-      @adapter.clear(options)
-      self
-    end
-
-    # Close this store
-    # @api public
-    def close
-      @adapter.close
-    end
-  end
-end

data/lib/juno/stack.rb

@@ -1,72 +0,0 @@
-module Juno
-  # Combines multiple stores. Reads return the result from the first store,
-  # writes go to all stores.
-  #
-  # @example Add stack to chain
-  #   Juno.build do
-  #     use(:Stack) do
-  #       add { adapter :Redis }
-  #       add { adapter :File, :dir => 'data' }
-  #       add { adapter :File, :dir => 'replicate' }
-  #     end
-  #   end
-  #
-  # @api public
-  class Stack < Base
-    # @api private
-    class DSL
-      attr_reader :stack
-
-      def initialize(options, &block)
-        @stack = options[:stack].to_a
-        instance_eval(&block)
-      end
-
-      def add(store = nil, &block)
-        raise ArgumentError, 'Only argument or block allowed' if store && block
-        @stack << (store || Juno.build(&block))
-        nil
-      end
-    end
-
-    attr_reader :stack
-
-    def initialize(options = {}, &block)
-      @stack = DSL.new(options, &block).stack
-    end
-
-    def key?(key, options = {})
-      @stack.any? {|s| s.key?(key) }
-    end
-
-    def load(key, options = {})
-      @stack.each do |s|
-        value = s.load(key, options)
-        return value if value
-      end
-      nil
-    end
-
-    def store(key, value, options = {})
-      @stack.each {|s| s.store(key, value, options) }
-      value
-    end
-
-    def delete(key, options = {})
-      @stack.inject(nil) do |value, s|
-        v = s.delete(key, options)
-        value || v
-      end
-    end
-
-    def clear(options = {})
-      @stack.each {|s| s.clear }
-      self
-    end
-
-    def close
-      @stack.each {|s| s.close }
-      nil
-    end
-  end
-end

data/lib/juno/transformer.rb

@@ -1,176 +0,0 @@
-module Juno
-  # Transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...).
-  #
-  # @example Add transformer to chain
-  #   Juno.build do
-  #     transformer :key => [:marshal, :escape], :value => [:marshal]
-  #     adapter :File, :dir => 'data'
-  #   end
-  #
-  # @api public
-  class Transformer < Proxy
-    def initialize(adapter, options = {})
-      super
-      @prefix, @secret = options[:prefix], options[:secret]
-    end
-
-    class << self
-      alias_method :original_new, :new
-
-      # Constructor
-      #
-      # @param [Juno store] adapter The underlying store
-      # @param [Hash] options
-      #
-      # Options:
-      # * :key - List of key transformers in the order in which they should be applied
-      # * :value - List of value transformers in the order in which they should be applied
-      # * :prefix - Prefix string for key namespacing (Used by the :prefix key transformer)
-      # * :secret - HMAC secret to verify values (Used by the :hmac value transformer)
-      def new(adapter, options = {})
-        keys = [options[:key]].flatten.compact
-        values = [options[:value]].flatten.compact
-        raise ArgumentError, 'Option :key or :value is required' if keys.empty? && values.empty?
-        raise ArgumentError, 'Option :prefix is required for :prefix key transformer' if keys.include?(:prefix) && !options[:prefix]
-        raise ArgumentError, 'Option :secret is required for :hmac value transformer' if values.include?(:hmac) && !options[:secret]
-        name = class_name(keys, values)
-        const_set(name, compile(keys, values)) unless const_defined?(name)
-        const_get(name).original_new(adapter, options)
-      end
-
-      private
-
-      def compile(keys, values)
-        raise ArgumentError, 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
-        raise ArgumentError, 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
-
-        key = compile_transformer(keys, 'key')
-
-        klass = Class.new(self)
-        if values.empty?
-          klass.class_eval <<-end_eval, __FILE__, __LINE__
-            def key?(key, options = {})
-              @adapter.key?(#{key}, options)
-            end
-            def load(key, options = {})
-              @adapter.load(#{key}, options)
-            end
-            def store(key, value, options = {})
-              @adapter.store(#{key}, value, options)
-            end
-            def delete(key, options = {})
-              @adapter.delete(#{key}, options)
-            end
-          end_eval
-        else
-          dump = compile_transformer(values, 'value')
-          load = compile_transformer(values.reverse, 'value', 1)
-
-          klass.class_eval <<-end_eval, __FILE__, __LINE__
-            def key?(key, options = {})
-              @adapter.key?(#{key}, options)
-            end
-            def load(key, options = {})
-              value = @adapter.load(#{key}, options)
-              value && #{load}
-            end
-            def store(key, value, options = {})
-              @adapter.store(#{key}, #{dump}, options)
-              value
-            end
-            def delete(key, options = {})
-              value = @adapter.delete(#{key}, options)
-              value && #{load}
-            end
-          end_eval
-        end
-        klass
-      end
-
-      # Compile transformer validator regular expression
-      def compile_validator(s)
-        Regexp.new(s.gsub(/\w+/) do
-                     '(' + TRANSFORMER.select {|k,v| v.first.to_s == $& }.map {|v| ":#{v.first}" }.join('|') + ')'
-                   end.gsub(/\s+/, '').sub(/\A/, '\A').sub(/\Z/, '\Z'))
-      end
-
-      # Returned compiled transformer code string
-      def compile_transformer(transformer, var, i = 2)
-        transformer.inject(var) do |value, name|
-          raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
-          require t[3] if t[3]
-          code = t[i]
-          if t[0] == :serialize && var == 'key'
-            "(tmp = #{value}; String === tmp ? tmp : #{code.gsub('value', 'tmp')})"
-          else
-            code.gsub('value', value)
-          end
-        end
-      end
-
-      def class_name(keys, values)
-        (keys.empty? ? '' : keys.map(&:to_s).map(&:capitalize).join << 'Key') <<
-          (values.empty? ? '' : values.map(&:to_s).map(&:capitalize).join << 'Value')
-      end
-    end
-
-    # 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,    'Escape.unescape(value)',          'Escape.escape(value)'                               ],
-      :hmac     => [ :hmac,      'HMAC.verify(value, @secret)',     'HMAC.sign(value, @secret)' ,        'openssl'       ],
-      :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,                               '@prefix+value'                                      ],
-      :spread   => [ :spread,    nil,                               '(tmp = value; ::File.join(tmp[0..1], tmp[2..-1]))'  ],
-    }
-
-    # 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 | (digest spread?))?')
-
-    module Escape
-      def self.escape(value)
-        value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }
-      end
-
-      def self.unescape(value)
-        value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }
-      end
-    end
-
-    module HMAC
-      def self.verify(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 self.sign(value, secret)
-        OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value) << value
-      end
-    end
-  end
-end