juno 0.3.1 → 0.4.0

data/lib/juno/adapters/riak.rb

@@ -1,57 +0,0 @@
-# Copyright: 2011 TMX Credit
-# Author: Potapov Sergey (aka Blake)
-
-require 'riak'
-
-module Juno
-  module Adapters
-    # Riak backend
-    # @api public
-    class Riak < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :bucket - Bucket name (default juno)
-      # * :content_type - Default content type (default application/octet-stream)
-      # * All other options passed to Riak::Client#new
-      def initialize(options = {})
-        bucket = options.delete(:bucket) || 'juno'
-        @content_type = options.delete(:content_type) || 'application/octet-stream'
-        @bucket = ::Riak::Client.new(options).bucket(bucket)
-      end
-
-      def key?(key, options = {})
-        @bucket.exists?(key, options)
-      end
-
-      def load(key, options = {})
-        @bucket.get(key, options).raw_data
-      rescue ::Riak::FailedRequest => ex
-        nil
-      end
-
-      def delete(key, options = {})
-        value = load(key, options)
-        @bucket.delete(key, options)
-        value
-      end
-
-      def store(key, value, options = {})
-        obj = ::Riak::RObject.new(@bucket, key)
-        obj.content_type = options[:content_type] || @content_type
-        obj.raw_data = value
-        obj.store(options)
-        value
-      end
-
-      def clear(options = {})
-        @bucket.keys do |keys|
-          keys.each{ |key| @bucket.delete(key) }
-        end
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/sdbm.rb

@@ -1,35 +0,0 @@
-require 'sdbm'
-
-module Juno
-  module Adapters
-    # SDBM backend
-    # @api public
-    class SDBM < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @memory = ::SDBM.new(options[:file])
-      end
-
-      def close
-        @memory.close
-        nil
-      end
-
-      def store(key, value, options = {})
-        super
-        value
-      rescue SDBMError
-        # SDBM is not very robust!
-        # You shouldn't put to much data into it, otherwise
-        # it might raise a SDBMError.
-        value
-      end
-    end
-  end
-end

data/lib/juno/adapters/sequel.rb

@@ -1,67 +0,0 @@
-require 'sequel'
-
-module Juno
-  module Adapters
-    # Sequel backend
-    # @api public
-    class Sequel < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :db - Sequel database
-      # * :table - Table name (default :juno)
-      # * All other options passed to Sequel#connect
-      def initialize(options = {})
-        raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
-        @table = options.delete(:table) || :juno
-        @db = ::Sequel.connect(db, options)
-        @db.create_table?(@table) do
-          String :k, :null => false, :primary_key => true
-          String :v
-        end
-      end
-
-      def key?(key, options = {})
-        sequel_table[:k => key] != nil
-      end
-
-      def load(key, options = {})
-        result = sequel_table[:k => key]
-        result ? result[:v] : nil
-      end
-
-      def store(key, value, options = {})
-        @db.transaction do
-          if key?(key, options)
-            sequel_table.update(:k => key, :v => value)
-          else
-            sequel_table.insert(:k => key, :v => value)
-          end
-          value
-        end
-      end
-
-      def delete(key, options = {})
-        @db.transaction do
-          if value = load(key, options)
-            sequel_table.filter(:k => key).delete
-            value
-          end
-        end
-      end
-
-      def clear(options = {})
-        sequel_table.delete
-        self
-      end
-
-      private
-
-      def sequel_table
-        @sequel_table ||= @db[@table]
-      end
-    end
-  end
-end

data/lib/juno/adapters/sqlite.rb

@@ -1,61 +0,0 @@
-require 'sqlite3'
-
-module Juno
-  module Adapters
-    # Sqlite3 backend
-    # @api public
-    class Sqlite < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      # * :table - Table name (default juno)
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        table = options[:table] || 'juno'
-        @db = ::SQLite3::Database.new(options[:file])
-        @db.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
-        @select = @db.prepare("select v from #{table} where k = ?")
-        @insert = @db.prepare("insert or replace into #{table} values (?, ?)")
-        @delete = @db.prepare("delete from #{table} where k = ?")
-        @clear = @db.prepare("delete from #{table}")
-      end
-
-      def key?(key, options = {})
-        !@select.execute!(key).empty?
-      end
-
-      def load(key, options = {})
-        rows = @select.execute!(key)
-        rows.empty? ? nil : rows.first.first
-      end
-
-      def store(key, value, options = {})
-        @insert.execute!(key, value)
-        value
-      end
-
-      def delete(key, options = {})
-        value = load(key, options)
-        @delete.execute!(key)
-        value
-      end
-
-      def clear(options = {})
-        @clear.execute!
-        self
-      end
-
-      def close
-        @select.close
-        @insert.close
-        @delete.close
-        @clear.close
-        @db.close
-        nil
-      end
-    end
-  end
-end

data/lib/juno/adapters/tokyocabinet.rb

@@ -1,41 +0,0 @@
-require 'tokyocabinet'
-
-module Juno
-  module Adapters
-    # TokyoCabinet backend
-    # @api public
-    class TokyoCabinet < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      # * :type - Database type (default :hdb, :bdb and :hdb possible)
-      def initialize(options = {})
-        file = options[:file]
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        if options[:type] == :bdb
-          @memory = ::TokyoCabinet::BDB.new
-          @memory.open(file, ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
-        else
-          @memory = ::TokyoCabinet::HDB.new
-          @memory.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
-        end or raise @memory.errmsg(@memory.ecode)
-      end
-
-      def delete(key, options = {})
-        value = load(key, options)
-        if value
-          @memory.delete(key)
-          value
-        end
-      end
-
-      def close
-        @memory.close
-        nil
-      end
-    end
-  end
-end

data/lib/juno/adapters/yaml.rb

@@ -1,15 +0,0 @@
-require 'yaml/store'
-
-module Juno
-  module Adapters
-    # YAML::Store backend
-    # @api public
-    class YAML < Juno::Adapters::PStore
-      protected
-
-      def new_store(options)
-        ::YAML::Store.new(options[:file])
-      end
-    end
-  end
-end

data/lib/juno/base.rb

@@ -1,62 +0,0 @@
-module Juno
-  # Simple interface to key/value stores with Hash-like interface.
-  # @api public
-  class Base
-    # Exists the value with key
-    #
-    # @param [Object] key
-    # @return [Boolean]
-    # @param [Hash] options
-    # @api public
-    def key?(key, options = {})
-      load(key, options) != nil
-    end
-
-    # Explicitly close the store
-    # @api public
-    def close
-    end
-
-    # Fetch value with key
-    #
-    # This is a overloaded method:
-    #
-    # * fetch(key, options = {}, &block) retrieve a key. if the key is not available, execute the
-    #   block and return its return value.
-    #
-    # * fetch(key, value, options = {}) retrieve a key. if the key is not available, return the value.
-    #
-    # @param [Object] key
-    # @param [Object] default Default value
-    # @param [Hash] options
-    # @return [Object] value from store
-    # @api public
-    def fetch(key, default = nil, options = nil)
-      if block_given?
-        raise ArgumentError, 'Only one argument accepted if block is given' if options
-        load(key, default || {}) || yield(key)
-      else
-        load(key, options || {}) || default
-      end
-    end
-
-    # Fetch value with key. Return nil if the key doesn't exist
-    #
-    # @param [Object] key
-    # @return [Object] value
-    # @api public
-    def [](key)
-      load(key)
-    end
-
-    # Store value with key
-    #
-    # @param [Object] key
-    # @param [Object] value
-    # @return value
-    # @api public
-    def []=(key, value)
-      store(key, value)
-    end
-  end
-end

data/lib/juno/builder.rb

@@ -1,39 +0,0 @@
-module Juno
-  # Builder implements the DSL to build a chain of store proxies
-  # @api private
-  class Builder
-    # @api private
-    def build
-      klass, options, block = @proxies.first
-      @proxies[1..-1].inject([klass.new(options, &block)]) do |stores, proxy|
-        klass, options, block = proxy
-        stores << klass.new(stores.last, options, &block)
-      end
-    end
-
-    def initialize(&block)
-      raise ArgumentError, 'No block given' unless block_given?
-      @proxies = []
-      instance_eval(&block)
-    end
-
-    # Add proxy to chain
-    #
-    # @param [Symbol or Class] proxy Name of proxy class or proxy class
-    # @param [Hash] options Options hash
-    def use(proxy, options = {}, &block)
-      proxy = Juno.const_get(proxy) if Symbol === proxy
-      raise ArgumentError, 'You must give a Class or a Symbol' unless Class === proxy
-      @proxies.unshift [proxy, options, block]
-      nil
-    end
-
-    # Add adapter to chain
-    #
-    # @param [Symbol] name Name of adapter class
-    # @param [Hash] options Options hash
-    def adapter(name, options = {}, &block)
-      use(Adapters.const_get(name), options, &block)
-    end
-  end
-end

data/lib/juno/cache.rb

@@ -1,78 +0,0 @@
-module Juno
-  # Combines two stores. One is used as cache, the other as backend.
-  #
-  # @example Add cache to chain
-  #   Juno.build do
-  #     use(:Cache) do
-  #      backend { adapter :File, :dir => 'data' }
-  #      cache { adapter :Memory }
-  #     end
-  #   end
-  #
-  # @api public
-  class Cache < Base
-    # @api private
-    class DSL
-      def initialize(options, &block)
-        @cache, @backend = options[:cache], options[:backend]
-        instance_eval(&block)
-      end
-
-      def backend(store = nil, &block)
-        raise 'Backend already set' if @backend
-        raise ArgumentError, 'Only argument or block allowed' if store && block
-        @backend = store || Juno.build(&block)
-      end
-
-      def cache(store = nil, &block)
-        raise 'Cache already set' if @cache
-        raise ArgumentError, 'Only argument or block allowed' if store && block
-        @cache = store || Juno.build(&block)
-      end
-
-      def result
-        [@cache, @backend]
-      end
-    end
-
-    attr_reader :cache, :backend
-
-    def initialize(options = {}, &block)
-      @cache, @backend = DSL.new(options, &block).result
-    end
-
-    def key?(key, options = {})
-      @cache.key?(key, options) || @backend.key?(key, options)
-    end
-
-    def load(key, options = {})
-      value = @cache.load(key, options)
-      unless value
-        value = @backend.load(key, options)
-        @cache.store(key, value, options) if value
-      end
-      value
-    end
-
-    def store(key, value, options = {})
-      @cache.store(key, value, options)
-      @backend.store(key, value, options)
-    end
-
-    def delete(key, options = {})
-      @cache.delete(key, options)
-      @backend.delete(key, options)
-    end
-
-    def clear(options = {})
-      @cache.clear(options)
-      @backend.clear(options)
-      self
-    end
-
-    def close
-      @cache.close
-      @backend.close
-    end
-  end
-end