redis_model 0.1.0.pre3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7a542c893f6a0451c7e008f352c6ed233696177
+  data.tar.gz: ee2e0ba63aabc72f0eaa61237d117ab0fef4ea9b
+SHA512:
+  metadata.gz: ee8f88e7a912a8388b6b6a71c4c57df60b2c0f9ad0ff570a1497d512cc967dad0357a2a5ff8d794e9dc648c9354b7818a2c5095f754c5b77a3f2fa368aec5014
+  data.tar.gz: 4083958ab4af9bac45607e21fdb14989f350096a38882de0c6b0e045eae2579f8a0f0f0158ccddaf8b9bebcd1a3d8535646fc49c236fabc9fc61f088d1449562

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Inbeom Hwang
+
+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,187 @@
+# RedisModel
+
+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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'redis_model'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis_model
+
+## Usage
+
+To cover as many use cases as possible, RedisModel provides three different
+interfaces to handle values on Redis.
+
+### Configuration
+
+Keys of values on Redis in concern of RedisModel objects have naming convention
+consisted of four parts:
+
+  - Application name (optional)
+  - Environment (optional)
+  - Class name converted to underscore notation
+  - Custom key label (optional)
+
+It is recommended to set proper application name and environment (which is set
+automatically using environment variables) to separate key namespace between
+other applications and environments. It can be configured upon initial
+bootstrapping stage (e.g. Rails initializers):
+
+    # In config/initializers/redis_model.rb:
+
+    RedisModel::Base.config do |config|
+      config.app_name = 'my_application' # Optional (recommended)
+      config.environment = 'production' # Optional
+      config.redis_url = 'redis://localhost:6379'
+    end
+
+### Standalone Usage
+
+Classes inherit `RedisModel::Base` can handle single type of value on Redis.
+
+    class SomeCounter < RedisModel::Base
+      data_type :counter # Required
+    end
+
+All child classes inherit from `RedisModel::Base` must declare type of data
+to handle. Available types include primitive Redis object types and some
+helpers (sorted alphabetically):
+
+  - `:counter`
+  - `:float`
+  - `:hash`
+  - `:integer`
+  - `:list`
+  - `:set`
+  - `:sorted_set`
+  - `:string`
+  - `:timestamp`
+
+For detailed specifications for each data type, refer documentation on modules
+corresponding to data typees under `redis_model/types`.
+
+If RedisModel is configured as above, all instances of `SomeCounter` refers to
+the same key (which is `(application name):(environment):some_counter`). Key
+label associated with instances can be retrieved by invoking
+`RedisModel::Base#key_label` method. If it is necessary, you can define custom
+key label for instances as:
+
+    class SomeCounter < RedisModel::Base
+      attr_reader :id
+
+      data_type :counter
+
+      # Uses return value of SomeCounter#id as custom label
+      custom_key_label &:id
+    end
+
+After defining `custom_key_label`, key labels of instances becomes:
+
+    some_counter = SomeCounter.new.tap { |counter| counter.id = 1 }
+
+    some_counter.key_label
+    # => (application name):(environment):some_counter:1
+
+Custom key label is useful if Redis values associated with instance attributes.
+If it is needed to define multiple Redis values associated with an instance,
+instance-level attributes will be more useful.
+
+### Instance-level Attributes
+
+Instances of classes mix in `RedisModel::Attribute` module can have multiple
+number of attributes associated with values on Redis. Classes defined as models
+in certain ORM can be a good example for this use case:
+
+    class User < ActiveRecord::Base
+      include RedisModel::Attribute
+
+      # Defines an instance-level attribute wired to Redis value.
+      redis_model_attribute :sign_in_count, :counter
+    end
+
+After defining `redis_model_attribute`, getter method for the attribute is
+defined as instance method of the class.
+
+    user = User.find(1)
+
+    user.sign_in_count.to_i
+    # => 0
+
+    user.sign_in_count.incr
+
+    user.sign_in_count.to_i
+    # => 1
+
+Internally, `redis_model_attribute` defines a class inherit from
+`RedisModel::Base` having name of attribute converted to camel case. In this
+case, it will be defined as:
+
+    `User::SignInCount`
+
+By this manner, Redis values referenced by the newly defined class has
+consistent key label. By default, instance-level attributes use return value of
+`#id` method of parent class as custom label. If it is required to use
+different method of parent class as custom label, `:foreign_key` option should
+be specified:
+
+    class User < ActiveRecord::Base
+      include RedisModel::Attribute
+
+      # User#name will be used as custom label.
+      redis_model_attribute :sign_in_count, :counter, foreign_key: :name
+    end
+
+In many cases, it is required to define multiple attributes in single parent
+class. As DSL defining single attribute is quite verbose compared to what it
+does, `RedisModel::Attribute` provides helper to make multiple definitions
+cleaner:
+
+    class User < ActiveRecord::Base
+      include RedisModel::Attribute
+
+      redis_model_attributes do
+        counter :sign_in_count
+        set :post_ids
+        set :order_ids
+      end
+    end
+
+### Class-level Attributes
+
+Ocasionally class-level attributes used as global scope variables are required.
+Although it can be obtained by defining new class inherit from
+`RedisModel::Base`, defining class attributes is cleaner and more concise.
+
+    class User < ActiveRecord::Base
+      include RedisModel::ClassAttribute
+
+      redis_class_attribue :registration_counter, :counter
+    end
+
+    User.registration_counter.to_i
+    # => 0
+
+    User.registration_counter.incr
+
+    User.registration_counter.to_i
+    # => 1
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/redis_model/fork )
+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,15 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'redis_model'
+
+  ARGV.clear
+  IRB.start
+end

data/lib/redis_model/adapters/paperclip.rb

@@ -0,0 +1,51 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+require 'paperclip'
+require 'paperclip/glue'
+
+module RedisModel
+  module Adapters
+    # Public: Adapter for putting Paperclip attachment into RedisModel::Base-
+    # derived classes.
+    module Paperclip
+      extend ActiveSupport::Concern
+      include RedisModel::Attribute
+
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations
+        include ::Paperclip::Glue
+        extend Override
+
+        define_model_callbacks :save, :destroy, :commit
+      end
+
+      def save
+        run_callbacks :save do
+          true
+        end
+      end
+
+      def destroy
+        run_callbacks :destroy do
+          true
+        end
+      end
+
+      module Override
+        def has_attached_file(*args)
+          define_paperclip_attributes_for(args.first)
+
+          super(*args)
+        end
+
+        def define_paperclip_attributes_for(attachment)
+          redis_model_attribute :"#{attachment}_file_name", :string
+          redis_model_attribute :"#{attachment}_file_size", :integer
+          redis_model_attribute :"#{attachment}_content_type", :string
+          redis_model_attribute :"#{attachment}_updated_at", :timestamp
+        end
+      end
+    end
+  end
+end

data/lib/redis_model/attribute.rb

@@ -0,0 +1,124 @@
+module RedisModel
+  # Public: Implementations for instance-level Redis attributes for specified
+  # class.
+  #
+  # Example:
+  #
+  #   class User < ActiveRecord::Base
+  #     includes RedisModel::Attribute
+  #
+  #     redis_model_attribute :sign_in_count, :counter
+  #   end
+  #
+  #   user = User.find(1)
+  #   user.sign_in_count.incr
+  #   user.sign_in_count.to_i # Now it is set to 1
+  module Attribute
+    # Internal: Provides helper for DSL for RedisModel attributes which are
+    # defined in block of RedisModel::Attribute.redis_model_attributes method.
+    class DefinitionHelper
+      # Public: Returns class in which attributes are defined.
+      attr_reader :klass
+
+      # Public: Returns Hash of default options for attributes.
+      attr_reader :default_options
+
+      # Public: Defines a RedisModel attribute with given data type and name.
+      #
+      # attribute_name - Name of the attribute.
+      # options        - Additional options for the attribute.
+      #
+      # Returns nothing.
+      #
+      # Signature
+      #
+      #   <data_type>(attribute_name, options)
+      #
+      # data_type - Data type.
+      RedisModel::Schema::DATA_TYPES.each do |data_type, _|
+        define_method(data_type) do |*args|
+          column_name = args[0]
+          options = args[1] || {}
+
+          @klass.redis_model_attribute args.first, data_type, @default_options.merge(options)
+        end
+      end
+
+      # Internal: Initializes new DefinitionHelper instance.
+      #
+      # klass   - Class in which attributes are defined.
+      # options - Default options for attribute definitions.
+      #
+      # Returns newly instantiated RedisModel::Attribute::DefinitionHelper
+      #   object.
+      def initialize(klass, default_options)
+        @klass = klass
+        @default_options = default_options
+      end
+    end
+
+    module ClassMethods
+      # Public: Defines an instance-level attribute.
+      #
+      # attribute_name - Name of the attribute.
+      # type           - Data type of the attribute.
+      # options        - Additional options for the attribute definition.
+      #                  :foreign_key - Foreign key used for the attribute.
+      #
+      # Returns nothing.
+      def redis_model_attribute(attribute_name, type, options = {})
+        Class.new(RedisModel::BelongedTo) do
+          data_type type
+
+          if options[:foreign_key]
+            custom_key_label do |redis_model|
+              redis_model.parent.send(options[:foreign_key])
+            end
+          else
+            custom_key_label(&:parent_id)
+          end
+        end.tap do |klass|
+          const_set(attribute_name.to_s.camelize, klass)
+          define_redis_attribute_method(attribute_name, klass)
+        end
+      end
+
+      # Public: Defines multiple instance-level attributes.
+      #
+      # block - A block contains definitions of multiple attributes.
+      #
+      # Example:
+      #
+      #   class User
+      #     redis_model_attributes
+      #   end
+      #
+      # Returns nothing.
+      def redis_model_attributes(options = {}, &block)
+        RedisModel::Attribute::DefinitionHelper.new(self, options).tap do |definition_helper|
+          definition_helper.instance_eval(&block) if block_given?
+        end
+      end
+
+      # Internal: Defines getter/setter method for specified attribute.
+      #
+      # attribute_name - Name of the attribute.
+      # klass          - Class for the attribute.
+      #
+      # Returns nothing.
+      def define_redis_attribute_method(attribute_name, klass)
+        define_method(attribute_name) do
+          klass.new(parent: self).to_value
+        end
+
+        define_method("#{attribute_name}=") do |value|
+          klass.new(parent: self).set(value)
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/redis_model/base.rb

@@ -0,0 +1,67 @@
+module RedisModel
+  # Public: Parent class for classes associated with Redis attributes. It
+  # provides methods to manipulate values on Redis storage.
+  class Base
+    # Public: DSL which defines data type for classes extending
+    # RedisModel::Base. It is mandatory for child classes to indicate data type
+    # before manipulating Redis values.
+    #
+    # type - The Symbol indicating data type for the class.
+    #
+    # Examples
+    #
+    #   class Foo < RedisModel::Base
+    #     data_type :counter # Defines data type for instances of Foo class.
+    #   end
+    #
+    #   foo = Foo.new
+    #   foo.incr
+    #   foo.to_i # 1
+    #
+    # Returns nothing.
+    def self.data_type(type, options = {})
+      include RedisModel::Schema.register(self, options.merge(data_type: type))
+    end
+
+    # Public: Retrieves proper RedisModel::Schema object describes schema
+    # information for class being referenced.
+    #
+    # Returns RedisModel::Schema object for the class or its direct ancestor,
+    #   nil if schema was not found.
+    def self.redis_model_schema
+      @schema ||= RedisModel::Schema.find(self)
+    end
+
+    # Public: Global Redis connection object. It is initialized only once.
+    #
+    # Returns Redis connection for objects using RedisModel.
+    def self.connection
+      @@connection ||= Redis.new(url: RedisModel::Configurations.instance.redis_url)
+    end
+
+    # Public: Sets custom key label for the object.
+    #
+    # block - Required Block which returns custom key for given object.
+    #
+    # Returns nothing.
+    def self.custom_key_label(&block)
+      redis_model_schema.custom_key_label(&block)
+    end
+
+    # Public: Retrieves key label for instantiated object.
+    #
+    # Returns the String label for the object.
+    def key_label
+      self.class.redis_model_schema.key_label(self)
+    end
+
+    # Internal: Converts value stored in Redis to primitive Ruby object. It acts
+    # as a helper method which converts getters for certain types of RedisModel
+    # attributes to return primitive types.
+    #
+    # Returns the primitive value of the object if it is available.
+    def to_value
+      self
+    end
+  end
+end

data/lib/redis_model/belonged_to.rb

@@ -0,0 +1,27 @@
+module RedisModel
+  # Internal: Base class for instance-level RedisModel attributes. Instances
+  # of this object should have reference to parent object.
+  class BelongedTo < RedisModel::Base
+    attr_accessor :parent, :parent_id
+
+    # Internal: Instantiates new RedisModel::BelongedTo object with given
+    # options.
+    #
+    # options - Options for new object.
+    #           :parent    - Parent object.
+    #           :parent_id - ID of parent object.
+    #
+    # Returns newly instantiated RedisModel::BelongedTo object.
+    def initialize(attrs = {}, options = {})
+      @parent = attrs[:parent]
+      @parent_id = attrs[:parent_id]
+    end
+
+    # Internal: ID of parent model.
+    #
+    # Returns ID of parent model.
+    def parent_id
+      @parent_id || @parent.id
+    end
+  end
+end

data/lib/redis_model/class_attribute.rb

@@ -0,0 +1,50 @@
+require 'redis_model/base'
+
+module RedisModel
+  # Public: Implementations for class-level RedisModel attributes.
+  #
+  # Example:
+  #
+  #   class User < ActiveRecord::Base
+  #     include RedisModel::ClassAttribute
+  #
+  #     redis_class_attribute :registration_count, :counter
+  #   end
+  #
+  #   User.registration_count.incr
+  #   User.registration_count.to_i # Now it is set to 1
+  module ClassAttribute
+    module ClassMethods
+      # Public: Defines a RedisModel class attribute with given data type and
+      # name.
+      def redis_class_attribute(attribute_name, type)
+        new_klass = Class.new(RedisModel::Base) do
+          data_type type
+        end
+
+        const_set(attribute_name.to_s.camelize, new_klass)
+        define_redis_class_attribute_method(attribute_name, new_klass)
+      end
+
+      def redis_class_attribute_classes
+        @redis_class_attribute_classes ||= Hash.new
+      end
+
+      def define_redis_class_attribute_method(attribute_name, new_klass)
+        singleton_class.class_eval do
+          define_method(attribute_name) do
+            new_klass.new.to_value
+          end
+
+          define_method("#{attribute_name}=") do |value|
+            new_klass.new.set(value)
+          end
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/redis_model/configurations.rb

@@ -0,0 +1,15 @@
+module RedisModel
+  class Configurations
+    include Singleton
+
+    attr_accessor :redis_url, :app_name, :environment
+
+    def environment
+      @environment || (defined?(Rails) ? Rails.env : (ENV['RAILS_ENV'] || ENV['RACK_ENV']))
+    end
+
+    def redis_url
+      @redis_url || 'redis://localhost:6379'
+    end
+  end
+end

data/lib/redis_model/helpers/sorted_set_paginator.rb

@@ -0,0 +1,80 @@
+require 'kaminari'
+require 'kaminari/models/array_extension'
+
+module RedisModel
+  module Helpers
+    # Public: Pagination helper for elements contained in a sorted set defined
+    # based on RedisModel.
+    #
+    # Example:
+    #
+    #   paginator = RedisModel::Helpers::SortedSetPaginator.new(sorted_set_object)
+    #
+    #   paginator.per(10).page(2)
+    #   # => Returns objects in the second page.
+    #
+    # Elements in sorted set is ordered in descending score order, which is
+    # consistent with that of RedisModel::Types::SortedSet handles the object.
+    class SortedSetPaginator
+      include Enumerable
+
+      def initialize(sorted_set)
+        @sorted_set = sorted_set
+      end
+
+      def load_default_options
+        @per ||= 20
+        @page ||= 1
+      end
+
+      def page(page_number)
+        @page = page_number.to_i
+
+        self
+      end
+
+      def per(number_per_page)
+        @per = number_per_page.to_i
+
+        self
+      end
+
+      def since_id(id)
+        @since = id
+
+        self
+      end
+
+      def max_id(id)
+        @max = id
+
+        self
+      end
+
+      def each(&block)
+        result.each do |element|
+          yield element
+        end
+      end
+
+      def result
+        load_default_options
+
+        @result ||= (@since || @max) ? result_with_score : result_with_rank
+      end
+
+      def result_with_score
+        raw_result = @sorted_set.get_range(@since || '-inf', @max || '+inf')
+
+        Kaminari.paginate_array(raw_result).page(@page).per(@per)
+      end
+
+      def result_with_rank
+        from = (@page - 1) * @per
+        to = from + @per - 1
+
+        @sorted_set.get_range_by_rank(from, to)
+      end
+    end
+  end
+end

data/lib/redis_model/intersected.rb

@@ -0,0 +1,17 @@
+module RedisModel
+  class Intersected < RedisModel::Base
+    attr_reader :key_label
+
+    data_type :sorted_set
+
+    def initialize(sets, seed = rand(256))
+      @sets = sets
+      @key_label = (@sets.map(&:key_label) + [DateTime.current.to_i, seed]).compact.join(':')
+    end
+
+    def generate(expire_in = nil)
+      RedisModel::Base.connection.zinterstore @key_label, @sets.map(&:key_label)
+      RedisModel::Base.connection.expire(@key_label, expire_in) if expire_in
+    end
+  end
+end