redis_model 0.1.0.pre3

data/lib/redis_model/schema.rb

@@ -0,0 +1,114 @@
+module RedisModel
+  # Public: Schema information for RedisModel::Base-derived classes. It
+  # contains information required to manipulate Redis data including data type
+  # and key label.
+  class Schema
+    attr_reader :klass, :data_type, :data_type_module
+
+    # Public: Data type label and their corresponding module responsible for
+    # specified type.
+    DATA_TYPES = {
+      value: RedisModel::Types::Counter,
+      counter: RedisModel::Types::Counter,
+      list: RedisModel::Types::List,
+      sorted_set: RedisModel::Types::SortedSet,
+      float: RedisModel::Types::Float,
+      set: RedisModel::Types::Set,
+      hash: RedisModel::Types::Hash,
+      string: RedisModel::Types::String,
+      timestamp: RedisModel::Types::Timestamp,
+      integer: RedisModel::Types::Integer
+    }
+
+    # Public: Exception class indicating some class tried to initiate data_type
+    # when one of its direct ancestors already have initiated.
+    class DuplicateDefinition < StandardError ; end
+
+    # Public: Exception raised when invalid data_type label is provided.
+    class UnknownType < StandardError ; end
+
+    # Public: Global index of RedisModel::Schema objects.
+    #
+    # Returns the Hash of global schema index.
+    def self.collection
+      @collection ||= {}
+    end
+
+    # Public: Find schema information for specified class. It could be schema
+    # defined for one of ancestors of the class.
+    #
+    # klass - Class to find schema.
+    #
+    # Returns RedisModel::Schema object for given class, nil if it does not
+    #   exist.
+    def self.find(klass)
+      collection[(klass.ancestors - klass.included_modules).detect do |parent_klass|
+        collection[parent_klass]
+      end]
+    end
+
+    # Public: Register schema for specified class.
+    #
+    # klass   - Class to register schema.
+    # options - Additional options for schema.
+    #           :data_type - Data type of Redis value.
+    #
+    # Returns the Module corresponding to data type of the class.
+    def self.register(klass, options = {})
+      raise DuplicateDefinition.new if find(klass)
+
+      (collection[klass] = new(options.merge(klass: klass))).data_type_module
+    end
+
+    # Public: Initializes a Schema.
+    #
+    # options - Options for schema.
+    #           :klass     - Class being specified for the schema.
+    #           :data_type - Data type of Redis value.
+    #
+    # Returns newly initialized Schema object.
+    def initialize(options = {})
+      raise UnknownType.new unless DATA_TYPES[options[:data_type]]
+
+      @klass = options[:klass]
+      @data_type = options[:data_type]
+      @data_type_module = DATA_TYPES[@data_type]
+    end
+
+    # Public: Key label of Redis value associated with instance of classes
+    # inherit RedisModel::Base.
+    #
+    # object - Instance of RedisModel::Base-derived class.
+    #
+    # Returns String containing label for specified object.
+    def key_label(object)
+      [base_key_label, @custom_key_label_proc && @custom_key_label_proc.call(object)].compact.join(':')
+    end
+
+    # Public: Defines custom part of key label by passing a block having arity
+    # of 1 to this method.
+    #
+    # block - Block or proc that converts object into custom label string
+    #
+    # Examples:
+    #
+    #   schema.custom_key_label do |object|
+    #     object.id
+    #   end
+    #
+    # Returns nothing.
+    def custom_key_label(&block)
+      @custom_key_label_proc = block
+    end
+
+    protected
+
+    # Internal: Retrieves string used for label for Redis value associated with
+    # the schema. Base label can be 
+    #
+    # Returns String containing base label.
+    def base_key_label
+      @key_label_base ||= [RedisModel::Configurations.instance.app_name, RedisModel::Configurations.instance.environment, @klass.name.underscore].compact.join(':')
+    end
+  end
+end

data/lib/redis_model/types/base.rb

@@ -0,0 +1,32 @@
+module RedisModel
+  module Types
+    # Internal: Provides methods for Redis commands related to plain key
+    # operations and helpers.
+    module Base
+      # Public: Asserts existence of Redis key having the label using Redis
+      # command ExiSTS.
+      #
+      # Returns true if key exists, false otherwise.
+      def exists?
+        connection.exists(key_label)
+      end
+
+      # Public: Removes Redis value associated with the key using Redis command
+      # DEL.
+      #
+      # Returns 1 if key is deleted, 0 otherwise.
+      def del
+        connection.del(key_label)
+      end
+
+      alias_method :clear, :del
+
+      # Public: Helper method for global Redis connection.
+      #
+      # Returns global Redis connection object.
+      def connection
+        RedisModel::Base.connection
+      end
+    end
+  end
+end

data/lib/redis_model/types/base_value.rb

@@ -0,0 +1,26 @@
+module RedisModel
+  module Types
+    # Internal: Base methods for helper types based on basic key-value pairs.
+    module BaseValue
+      include RedisModel::Types::Base
+
+      # Public: Reads value of string stored in Redis using GET command.
+      #
+      # Returns String contained in Redis. nil if it does not exist.
+      def get
+        @cached_value ||= RedisModel::Base.connection.get(key_label)
+      end
+
+      # Public: Sets value of string stored in Redis using SEt command.
+      #
+      # value - Value to set.
+      #
+      # Returns String contained in Redis. nil if it does not exist.
+      def set(value, options = {})
+        @cached_value = nil
+
+        RedisModel::Base.connection.set(key_label, value, options)
+      end
+    end
+  end
+end

data/lib/redis_model/types/counter.rb

@@ -0,0 +1,25 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for counter data type.
+    module Counter
+      include RedisModel::Types::BaseValue
+
+      # Public: Atomically increments counter value using Redis command INCR or
+      # INCRBY.
+      #
+      # by - Amount to increment by (default: 1).
+      #
+      # Returns Integer value of counter after increment.
+      def incr(by = nil)
+        by ? connection.incrby(key_label, by) : connection.incr(key_label)
+      end
+
+      # Public: Retrieves Integer value of counter.
+      #
+      # Returns Integer value of counter.
+      def to_i
+        (get || 0).to_i
+      end
+    end
+  end
+end

data/lib/redis_model/types/float.rb

@@ -0,0 +1,17 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for Float data type.
+    module Float
+      include RedisModel::Types::BaseValue
+
+      # Public: Retrieves Float value stored in the key.
+      #
+      # Returns Float value stored in the key. nil if it does not exist.
+      def to_f
+        get && get.to_f
+      end
+
+      alias_method :to_value, :to_f
+    end
+  end
+end

data/lib/redis_model/types/hash.rb

@@ -0,0 +1,53 @@
+module RedisModel
+  module Types
+    # Internal: Methods for hash type of key in Redis.
+    module Hash
+      include Base
+
+      # Public: Sets a key in Hash using Redis HSET command.
+      #
+      # key   - Key to set.
+      # value - Value to set.
+      #
+      # Returns new value.
+      def []=(key, value)
+        result = connection.hset(key_label, key.to_s, value)
+
+        @cached_hash = nil
+
+        value
+      end
+
+      # Public: Retrieves a key in Hash using Redis HGET command.
+      #
+      # key   - Key to retrieve.
+      #
+      # Returns retrieved value.
+      def [](key)
+        connection.hget(key_label, key.to_s)
+      end
+
+      # Public: Increments a key in Hash using Redis HINCRBY command.
+      #
+      # key - Key to increment.
+      # by  - Amount for increment (default: 1)
+      #
+      # Returns incremented value.
+      def incr(key, by = 1)
+        result = connection.hincrby(key_label, key, by)
+
+        @cached_hash = nil
+
+        result.to_i
+      end
+
+      def to_hash
+        @cached_hash ||= connection.hgetall(key_label)
+      end
+
+      def keys
+        connection.hkeys(key_label)
+      end
+    end
+  end
+end

data/lib/redis_model/types/integer.rb

@@ -0,0 +1,17 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for Integer type.
+    module Integer
+      include RedisModel::Types::BaseValue
+
+      # Public: Retrieves value stored in Redis key as Integer.
+      #
+      # Returns Integer value stored in Redis key, nil if it does not exist.
+      def to_i
+        get && get.to_i
+      end
+
+      alias_method :to_value, :to_i
+    end
+  end
+end

data/lib/redis_model/types/list.rb

@@ -0,0 +1,40 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for List type.
+    module List
+      include RedisModel::Types::Base
+
+      # Public: Fetches elements in Redis list as Array using LRANGE command.
+      #
+      # Returns Array containing elements in the list.
+      def to_a
+        connection.lrange key_label, 0, -1
+      end
+
+      # Public: Retrieves length of Redis list using LLEN command.
+      #
+      # Returns Integer containing length of the list.
+      def count
+        connection.llen key_label
+      end
+
+      alias_method :length, :count
+
+      # Public: Retrieves a element in the list using LINDEX command.
+      #
+      # Returns String containing value of the specified element.
+      def [](index)
+        connection.lindex key_label, index
+      end
+
+      # Public: Pushes a element into the list using RPUSH command.
+      #
+      # Returns true.
+      def <<(value)
+        connection.rpush key_label, value
+      end
+
+      alias_method :push, :<<
+    end
+  end
+end

data/lib/redis_model/types/set.rb

@@ -0,0 +1,59 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for Set type.
+    module Set
+      include RedisModel::Types::Base
+
+      # Public: Fetches elements in Redis set as Array using SMEMBERS command.
+      #
+      # Returns Array containing elements in the set.
+      def to_a
+        connection.smembers key_label
+      end
+
+      # Public: Retrieves length of Redis set using SCARD command.
+      #
+      # Returns Integer containing cardinality of the set.
+      def count
+        connection.scard key_label
+      end
+
+      alias_method :length, :count
+
+      # Public: Pushes a element into the set using SADD command.
+      #
+      # Returns true.
+      def <<(value)
+        connection.sadd key_label, value
+      end
+
+      # Public: Removes a element from the set using SREM command.
+      #
+      # Returns true.
+      def remove(value)
+        connection.srem key_label, value
+      end
+
+      # Public: Picks a member among elements in the set using SRANDMEMBER
+      # command.
+      #
+      # count - Number of elements to pick.
+      #
+      # Returns Array containing elements in the set randomly selected.
+      def pick(count)
+        RedisModel::Base.connection.pipelined do
+          count.times do
+            connection.srandmember(key_label)
+          end
+        end
+      end
+
+      # Public: Asserts value is included in the set using SISMEMBER command.
+      #
+      # Returns true if value is included in the set, false otherwise.
+      def include?(value)
+        connection.sismember key_label, value.to_s
+      end
+    end
+  end
+end

data/lib/redis_model/types/sorted_set.rb

@@ -0,0 +1,184 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for Sorted Set type. Note that it assumes
+    # elements are sorted in descending order of score as default because the
+    # module is implemented for leaderboard feature. Future releases will
+    # revert this decision and will use default order of Redis.
+    module SortedSet
+      include RedisModel::Types::Base
+
+      # Public: Fetches elements in the sorted set as Array.
+      #
+      # Returns Array containing elements in the set.
+      def to_a
+        get_range('-inf', '+inf', include_boundaries: true)
+      end
+
+      # Public: Counts number of elements in (from, to) interval using ZCOUNT
+      # command.
+      #
+      # from - Beginning point of the interval.
+      # to   - Ending point of the interval.
+      #
+      # Returns Integer containing number of elements in the interval.
+      def count_range(from, to)
+        connection.zcount(key_label, from, to)
+      end
+
+      # Public: Asserts value is included in the set.
+      #
+      # Returns true if value is included in the set, false otherwise.
+      def include?(value)
+        !!connection.zrank(key_label, value)
+      end
+
+      # Public: Retrieves elements in [from, to] index interval. Elements are
+      # arranged in descending order of score. ZREVRANGE command is used.
+      #
+      # from    - Beginning point of the index interval.
+      # to      - Ending point of the index interval.
+      # options - Additional options for retrieval.
+      #           :withscores - If it is set to true, returned array
+      #                         contains values and corresponding scores
+      #                         of elements.
+      #
+      # Returns Integer containing number of elements in the interval.
+      def get_range_by_rank(from, to, options = {})
+        connection.zrevrange(key_label, from, to, options)
+      end
+
+      # Public: Retrieves elements in (from, to) index interval. Elements are
+      # arranged in ascending order of score. ZRANGE command is used.
+      #
+      # from    - Beginning point of the index interval.
+      # to      - Ending point of the index interval.
+      # options - Additional options for retrieval.
+      #           :withscores - If it is set to true, returned array
+      #                         contains values and corresponding scores
+      #                         of elements.
+      #
+      # Returns Integer containing number of elements in the interval.
+      def get_range_by_reverse_rank(from, to, options = {})
+        connection.zrange(key_label, from, to, options)
+      end
+
+      # Public: Retrieves index of element in the sorted set. Elements are
+      # arranged in descending order of score. ZREVRANK command is used.
+      #
+      # from    - Beginning point of the index interval.
+      # to      - Ending point of the index interval.
+      # options - Additional options for retrieval.
+      #           :withscores - If it is set to true, returned array
+      #                         contains values and corresponding scores
+      #                         of elements.
+      #
+      # Returns Integer containing number of elements in the interval.
+      def get_rank(key)
+        connection.zrevrank(key_label, key)
+      end
+
+      # Public: Retrieves score of element having specified value using ZSCORE
+      # command.
+      #
+      # value - Value of the element in concern.
+      #
+      # Returns score of element.
+      def score(value)
+        connection.zscore(key_label, value)
+      end
+
+      # Public: Retrieves length of Redis sorted set using ZCARD command.
+      #
+      # Returns Integer containing cardinality of the sorted set.
+      def count
+        connection.zcard(key_label)
+      end
+
+      alias_method :length, :count
+
+      # Public: Retrieves elements in the sorted set in (from, to) interval
+      # using ZREVRANGEBYSCORE command.
+      #
+      # from    - Beginning point of the interval.
+      # to      - Ending point of the interval.
+      # options - Additional options for retrieval.
+      #           :include_boundaries - If it is set to true, elements on
+      #                                 beginning/ending points are included.
+      #           :withscores         - If it is set to true, returned array
+      #                                 contains values and corresponding scores
+      #                                 of elements.
+      #
+      # Returns Array of element values or value/score pairs.
+      def get_range(from, to, options = {})
+        if options.delete(:include_boundaries)
+          connection.zrevrangebyscore(key_label, to, from, options)
+        else
+          connection.zrevrangebyscore(key_label, "(#{to}", "(#{from}", options)
+        end
+      end
+
+      # Public: Puts an element in sorted set using ZADD command.
+      #
+      # score - Score for the element.
+      # value - Value for the element.
+      #
+      # Returns true.
+      def put(score, value)
+        connection.zadd(key_label, score, value)
+      end
+
+      # Public: Removes an element from the sorted set using ZREM command.
+      #
+      # value - Value to remove.
+      #
+      # Returns true.
+      def remove(value)
+        connection.zrem(key_label, value)
+      end
+
+      # Public: Removes elements of the sorted set in specified interval using
+      # ZREMRANGEBYSCORE command.
+      #
+      # from - Beginning point of the interval (default: '-inf').
+      # to   - Ending point of the interval (default: '+inf').
+      #
+      # Returns true.
+      def remove_range(from = '-inf', to = '+inf')
+        connection.zremrangebyscore(key_label, from, to)
+      end
+
+      # Public: Duplicates the sorted set with new key label using ZUNIONSTORE
+      # command.
+      #
+      # Returns true if duplication was successful, false otherwise.
+      def duplicate(new_key_label)
+        connection.zunionstore(new_key_label, [key_label]) if exists?
+      end
+
+      # Public: Generates intersected sorted set with another sorted set or set
+      # and perform operations on the new intersected set optionally.
+      #
+      # set     - Another set to perform intersection with the sorted set.
+      # options - Additional options for the intersection.
+      #           :seed - Seed for the new key label used to avoid naming
+      #                   confliction.
+      # block   - An optional block that performs RedisModel commands with the
+      #           intersected sorted set. If the block is given, intersected
+      #           sorted set is removed after commands are completed.
+      #
+      # Returns RedisModel::Intersected object resulted from intersection if
+      #   block was not given. If block was given, result of block is returned.
+      def intersect(set, options = {}, &block)
+        result = intersected = RedisModel::Intersected.new([self, set], options[:seed])
+
+        if block_given?
+          intersected.generate
+          result = yield(intersected)
+          intersected.clear
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/redis_model/types/string.rb

@@ -0,0 +1,11 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for string type.
+    module String
+      include RedisModel::Types::BaseValue
+
+      alias_method :to_s, :get
+      alias_method :to_value, :get
+    end
+  end
+end

data/lib/redis_model/types/timestamp.rb

@@ -0,0 +1,26 @@
+module RedisModel
+  module Types
+    # Internal: Methods needed for timestamp type.
+    module Timestamp
+      include RedisModel::Types::BaseValue
+
+      # Public: Reads value on Redis and converts it to timestamp.
+      #
+      # Returns Time object.
+      def to_time
+        Time.parse(get) rescue nil
+      end
+
+      alias_method :to_value, :to_time
+
+      # Public: Sets ISO 8601 string of timestamp to Redis.
+      #
+      # timestamp - Timestamp to store.
+      #
+      # Returns nothing.
+      def set(timestamp)
+        super(timestamp.utc.iso8601)
+      end
+    end
+  end
+end

data/lib/redis_model/version.rb

@@ -0,0 +1,3 @@
+module RedisModel
+  VERSION = '0.1.0.pre3'
+end

data/lib/redis_model.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+require 'time'
+
+require 'redis'
+require 'active_support/inflector'
+
+require "redis_model/version"
+require 'redis_model/configurations'
+require 'redis_model/types/base'
+require 'redis_model/types/base_value'
+require 'redis_model/types/string'
+require 'redis_model/types/counter'
+require 'redis_model/types/list'
+require 'redis_model/types/sorted_set'
+require 'redis_model/types/float'
+require 'redis_model/types/set'
+require 'redis_model/types/hash'
+require 'redis_model/types/timestamp'
+require 'redis_model/types/integer'
+require 'redis_model/schema'
+require 'redis_model/base'
+require 'redis_model/belonged_to'
+require 'redis_model/attribute'
+require 'redis_model/class_attribute'
+require 'redis_model/intersected'
+
+# Public: RedisModel provides various types of interfaces to handle values on
+# Redis from applications, mostly with ORM including ActiveRecord. RedisModel
+# is highly customizable and tries to avoid polluting name space of previously
+# defined classes and modules.
+module RedisModel
+  def self.config
+    (@configurations ||= RedisModel::Configurations.instance).tap do |configurations|
+      yield configurations if block_given?
+    end
+  end
+end

data/redis_model.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis_model/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'redis_model'
+  spec.version       = RedisModel::VERSION
+  spec.authors       = ['Inbeom Hwang']
+  spec.email         = ['hwanginbeom@gmail.com']
+  spec.summary       = %q{Interfaces for Redis values.}
+  spec.description   = %q{RedisModel provides various types of interfaces to handle values on Redis}
+  spec.homepage      = 'http://gitlab.ultracaption.net/inbeom/redis_model'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'redis'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'kaminari'
+end