almicube 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 94b199c38dcd6cb5b6599020ca0f935f7081810c
+  data.tar.gz: fe414a3b3946b9cfee359866f94780e36c75dc6e
+SHA512:
+  metadata.gz: 8200ccaadf03f53d208f55f8e0659089e38075fd5c40ef0d0bca1e2bf306dd86a30020c74861c88c4065ad731cadc8f74fc690943be20beb17aef9bdad999dcb
+  data.tar.gz: ecae74f249d13c1668cc564b9420ae2c33fa1f4a9c9453e6a8ece13a4f852d435647cffd70c0d32b69b6198f7e446afdaad66a9865e6fbedf3f71861ff88e5a4

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Nia
+
+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,37 @@
+almicube
+========
+
+Extend Your Model
+--------
+
+in `app/models/item.rb`
+
+```ruby
+class Item < ActiveRecord::Base
+  ranking_with :access, as: Integer
+end
+```
+
+in `app/controllers/items\_controller.rb`
+
+```ruby
+class ItemsController
+  def index
+    @items = Item.access_ranking.page params[:page]
+  end
+end
+
+in `app/views/items/index.html.erb`
+
+```erb
+<ul>
+  <% @items.each do |item| %>
+    <li>[<%= item.access_ranking.rank %>] <%= item.name %><li>
+  <% end %>
+</ul>
+```
+
+Note
+--------
+
+- Almicube uses Redis for DataStore.

data/almicube.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'almicube/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "almicube"
+  spec.version       = Almicube::VERSION
+  spec.authors       = ["niaeashes"]
+  spec.email         = ["nia.eashes@gmail.com"]
+  spec.summary       = "Ranking extension for your model"
+  spec.description   = "Provide raking system for your ActiveRecord Model on Rails 4 with SortedSet of Redis DataBase."
+  spec.homepage      = "https://github.com/niaeashes/almicube"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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", "~> 3.0"
+  spec.add_dependency "activesupport", "~> 4.0"
+end

data/lib/almicube/model.rb

@@ -0,0 +1,46 @@
+require 'active_support/all'
+
+module Almicube
+  module Model
+    def self.included(base)
+      base.class_eval do
+        class << self
+
+          def ranking_with(ranker, options={})
+            ranker = ranker.to_s
+            options.symbolize_keys!.merge(Ranking.default_options)
+
+            class_name = ( options.fetch :class_name, Almicube::Ranking ).to_s
+            as = options.fetch :as, Float
+            per_page = options.fetch :per_page, 10
+
+            class_eval <<-EVAL
+              def self.#{ranker}_ranking(date = Date.today)
+                @rankings ||= {}
+                @rankings[:"#{ranker}:\#{date.to_s}"] ||= #{class_name}.build attribute_name: :#{ranker}, class_name: self, as: #{as}, date: date, per_page: #{per_page}
+              end
+
+              def #{ranker}_ranking(date = Date.today)
+                Almicube::AssociationProxy.new(self.class.#{ranker}_ranking(date), self)
+              end
+
+              def #{ranker}_rank(date = Date.today)
+                self.#{ranker}_ranking(date).rank
+              end
+
+              def #{ranker}_score(date = Date.today)
+                self.#{ranker}_ranking(date).score
+              end
+
+              def #{ranker}_incr(date = Date.today, score = 1)
+                self.#{ranker}_ranking(date).incr(score)
+              end
+            EVAL
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/almicube/proxy/association_proxy.rb

@@ -0,0 +1,25 @@
+module Almicube
+  class AssociationProxy
+    def initialize(ranking, item)
+      raise TypeError, "without the Almicube::Ranking as #1 argument" unless ranking.kind_of? Ranking
+      @item = item
+      @ranking = ranking
+    end
+
+    def score
+      @ranking.score(@item)
+    end
+
+    def rank
+      @ranking.rank(@item)
+    end
+
+    def incr(score = 1)
+      @ranking.incr(@item, score)
+    end
+
+    def to_s
+      "#{@item.to_s}: #{@ranking.key} [#{rank} - #{score}]"
+    end
+  end
+end

data/lib/almicube/ranged_ranking.rb

@@ -0,0 +1,44 @@
+module Almicube
+  class RangedRanking < Almicube::Ranking
+    class << self
+      def overwrite_params
+        { key: '%{prefix}:%{class_name}:%{range}:%{suffix}', type: :range }
+      end
+    end
+
+    def aggregate(options={})
+      keys = range_days(range).times.inject([]) do |keys, i|
+        key = key_format(@options[:data_key], @options.merge( date: date.to_date - i.days, type: :data ))
+        keys << key if connection.exists key
+        keys
+      end
+      connection.zunionstore key, keys, aggregate: :sum
+    end
+
+    def range
+      @options.fetch(:range, default_range)
+    end
+
+    def default_range
+      :weekly
+    end
+
+    protected
+
+    def range_days(range, default = nil)
+      case range.to_sym
+      when :yesterday
+        1
+      when :weekly
+        7
+      when :twice_weekly
+        14
+      when :monthly
+        30
+      else
+        return default unless default.nil?
+        range_days(default_range, 7)
+      end
+    end
+  end
+end

data/lib/almicube/ranking.rb

@@ -0,0 +1,133 @@
+require "redis"
+require "active_support/all"
+
+module Almicube
+  class Ranking
+    class << self
+      def default_options
+        { attribute_name: :score,
+          type: :data,
+          prefix: 'ranking:%{type}',
+          suffix: '%{attribute_name}',
+          key: '%{prefix}:%{class_name}:%{date}:%{suffix}',
+          date_format: '%Y%m%d',
+          date: Date.today,
+          per_page: 10,
+          as: Float,
+          default_score: 0 }
+      end
+
+      def connection
+        @connection ||= Redis.new
+      end
+
+      def build(options={})
+        self.new options
+      end
+    end
+
+    def initialize(options={})
+      @options = self.class.default_options.merge options.symbolize_keys
+
+      raise TypeError, ":as option is only allowed Integer or Float" unless [Integer, Float].include? @options[:as]
+    end
+
+    def ranged(range)
+      Almicube::RangedRanking.new @options.merge( range: range, data_key: @options[:key] ).merge(Almicube::RangedRanking.overwrite_params)
+    end
+
+    KEY_PATTERN = /%{([a-z_]+)}/ # Example) %{sample_key}
+
+    def key
+      key_format(@options[:key], @options)
+    end
+
+    def all
+      target_class.all
+    end
+
+    def page(page=1)
+      page = [1, page.to_i].max
+      revrange = connection.zrevrange(key, (page - 1) * per_page, page * per_page - 1)
+      records = target_class.find(revrange)
+      revrange.inject([]) { |l, v| l << records.detect { |r| r.to_param == v } }
+    end
+
+    def attribute_name
+      @options.fetch(:attribute_name, :score).to_s.to_sym
+    end
+
+    def date
+      @options.fetch(:date, Date.today)
+    end
+
+    def per_page
+      @options.fetch(:per_page, 0)
+    end
+
+    def per_page=(value)
+      @options[:per_page] = value
+    end
+
+    def aggregate!(options = {})
+      overwrite = !! ( options.try(:overwrite) || false )
+      raise "ranking is already exists. if you want to force aggregating: set { overwrite: true }" if exists? && ! overwrite
+
+      all.each do |record|
+        score = @options.fetch(:default_score, 0)
+        score = record.send attribute_name if record.respond_to? attribute_name
+        connection.zadd key, score.to_f, record.to_param
+      end
+    end
+
+    def aggregate(options = {})
+      aggregate! options
+      true
+    rescue Exception => e
+      false
+    end
+
+    def exists?
+      connection.exists key
+    end
+
+    def score(item)
+      actual_score = ( connection.zscore key, item.to_param ) || @options.fetch(:default_score, 0)
+      case @options[:as].to_s
+      when "Integer"
+        actual_score.to_i
+      when "Float"
+        actual_score.to_f
+      else
+        actual_score
+      end
+    end
+
+    def rank(item)
+      connection.zrevrank(key, item.to_param) + 1
+    end
+
+    def incr(item, score = 1)
+      connection.zincrby key, score, item.to_param
+    end
+
+    protected
+
+    def connection
+      self.class.connection
+    end
+
+    def target_class
+      @options[:class_name].to_s.constantize
+    end
+
+    def key_format(key_base, options)
+      key = key_base.clone
+      tmp_options = options.merge date: options.fetch(:date, Date.today).strftime(@options[:date_format])
+      key.match( self.class::KEY_PATTERN ) do |m|
+        key.gsub! m[0], tmp_options.fetch(m[1].to_sym, '').to_s
+      end while key =~ self.class::KEY_PATTERN
+      key
+    end
+  end
+end

data/lib/almicube/version.rb

@@ -0,0 +1,3 @@
+module Almicube
+  VERSION = '0.0.1'
+end

data/lib/almicube.rb

@@ -0,0 +1,10 @@
+module Almicube
+  autoload :Ranking, 'almicube/ranking'
+  autoload :RangedRanking, 'almicube/ranged_ranking'
+  autoload :Model, 'almicube/model'
+  autoload :AssociationProxy, 'almicube/proxy/association_proxy'
+
+  if defined? ActiveRecord
+    ActiveRecord::Base.send :include, Almicube::Model
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: almicube
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- niaeashes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Provide raking system for your ActiveRecord Model on Rails 4 with SortedSet
+  of Redis DataBase.
+email:
+- nia.eashes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- almicube.gemspec
+- lib/almicube.rb
+- lib/almicube/model.rb
+- lib/almicube/proxy/association_proxy.rb
+- lib/almicube/ranged_ranking.rb
+- lib/almicube/ranking.rb
+- lib/almicube/version.rb
+homepage: https://github.com/niaeashes/almicube
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ranking extension for your model
+test_files: []