almicube 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5974ef075edf11c09d6e8c44485968661fcc8a5
-  data.tar.gz: ff7ca640f98417dc29d755aa314a57a8ebefca42
+  metadata.gz: 3b5b3dee4cf2a4ca349f8b5d218fe23cbb6fbb7c
+  data.tar.gz: d5423d3770485d8176bd9cb0ac306e0ed2e32ac0
 SHA512:
-  metadata.gz: 999950f31e8406189ebfce9726f6c5a6b99f7d4c389bb54e644dbcc9538d30c16e50169c449b35cbb86ce2cd3b3e214166a3c1acc0b2fd0b95d77d06c825f001
-  data.tar.gz: ae64515586232c660796d417702a84e3d72907aa0f1e89563548a44c40d04617f56c653eaca9aedf74fed83ab555bcbbf15aa6316af3aa96ddb4abfbd06f8c05
+  metadata.gz: 86cc68a0f86730eb0d64e526dd49135265090574ac085ea3bbdf267940573cfd1f222abbf6b1eae7348b408684de7f204a0552b0927666850f0b61a0a2d29b04
+  data.tar.gz: a3d2279edd141c513f93a6e34ae80ab77089d7e01f2c7c354af3fa5ee048ca22e2eea82fa630e850787c78e77b23266e298ecdf2d7395ee12245633a6b12e986

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    almicube (0.0.2)
+      activemodel (~> 4.0)
+      activesupport (~> 4.0)
+      redis (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.0)
+      activesupport (= 4.1.0)
+      builder (~> 3.1)
+    activesupport (4.1.0)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    json (1.8.1)
+    minitest (5.3.3)
+    redis (3.0.7)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    thread_safe (0.3.3)
+    tzinfo (1.1.0)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  almicube!
+  rspec (~> 2.0)

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/almicube.gemspec

@@ -19,4 +19,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "redis", "~> 3.0"
   spec.add_dependency "activesupport", "~> 4.0"
+  spec.add_dependency "activemodel", "~> 4.0"
+
+  spec.add_development_dependency "rspec", "~> 2.0"
 end

data/lib/almicube/aggregator/base.rb

@@ -0,0 +1,25 @@
+module Almicube
+  module Aggregator
+    class Base
+      include Almicube::Cog
+
+      class << self
+        def connection
+          @redis ||= Almicube::Config.config.connection
+        end
+      end
+
+      def aggregate(ranking=nil)
+        self.ranking = ranking unless active? || ranking.nil?
+
+        self.ranking.selector.before_aggregate if self.ranking.selector.respond_to? :before_aggregate
+
+        if self.ranking.data?
+          data_aggregate self.ranking.key
+        else
+          sub_aggregate self.ranking.key
+        end
+      end
+    end
+  end
+end

data/lib/almicube/aggregator/sum_aggregator.rb

@@ -0,0 +1,23 @@
+module Almicube
+  module Aggregator
+    class SumAggregator < Base
+      protected
+
+      def data_aggregate(key)
+        ranking.records.each do |record|
+          value = record.send(ranking.attribute_name) if record.respond_to? ranking.attribute_name
+          value = ranking.default_score if value.nil?
+          self.class.connection.zadd(key, value, record.to_param)
+        end
+      end
+
+      def sub_aggregate(key)
+        keys = ranking.bundled_keys.select { |k| self.class.connection.zcard(k) > 0 }
+        keys << ranking.selector.interstore
+        if keys.length
+          self.class.connection.zinterstore(key, keys)
+        end
+      end
+    end
+  end
+end

data/lib/almicube/builder.rb

@@ -1,41 +1,38 @@
 module Almicube
-  module Builder
-    class << self
-      def instance(name, options={})
-        raise ArgumentError, "invalid #1 name" unless has_builder? name
-        builders[name].new options
-      end
+  class Builder
+    attr_accessor :selector, :date, :bundler, :class_name, :attribute_name
 
-      def register(name, builder_class)
-        raise TypeError, 'invalid builder class' unless builder_class.kind_of? Builder::Base
-        builders[name] = builder_class
-      end
-
-      def has_builder?(name)
-        load_builder name
-        builders.has_key? name
-      end
+    def initialize(options={})
+      @class_name = options[:class_name]
+      @attribute_name = options[:attribute_name]
+      @selector = select_selector(options[:selector])
+      @bundler = select_bundler(options[:bundler])
+      @date = options[:date] || Date.today
+    end
 
-      def builders
-        @builders ||= {}
-      end
+    def data(date=nil)
+      date ||= self.date
+      Almicube::Ranking::DataRanking.new options
+    end
 
-      def load_builder(name)
-        "Almicube::Builder::#{"#{name}_ranking_builder".classify}".constantize
-      end
+    def options
+      { selector: selector,
+        bundler: bundler,
+        date: date,
+        class_name: class_name,
+        attribute_name: attribute_name }
     end
 
-    module Base
-      def self.included(base)
-        base.include InstanceMethods
-      end
+    protected
 
-      def register(name)
-        Builder.register(name, self)
-      end
+    def select_selector(selector)
+      selector = selector.constantize if selector.is_a?(String) && Object.const_defined?(selector.to_s)
+      selector = selector.new if selector.is_a? Class
+      selector
+    end
 
-      class InstanceMethods
-      end
+    def select_bundler(bundler)
+      bundler
     end
   end
 end

data/lib/almicube/bundler/base.rb

@@ -0,0 +1,18 @@
+module Almicube
+  module Bundler
+    class Base
+      include Almicube::Cog
+      attr_reader :name
+
+      def initialize(options={})
+        @name = options[:bundle] || options[:name]
+      end
+
+      alias :bundle :name
+
+      def keys
+        []
+      end
+    end
+  end
+end

data/lib/almicube/bundler/days_ago_bundler.rb

@@ -0,0 +1,22 @@
+module Almicube
+  module Bundler
+    class DaysAgoBundler < Base
+      attr_reader :range
+
+      def initialize(options={})
+        @range = ( options[:range] || 1 ).to_i
+        options[:name] ||= :"#{range}-days-ago"
+        super options
+      end
+
+      def keys
+        return [] unless has_ranking?
+        range.times.map do |i|
+          key = ranking.data_key
+          key[:date] = key[:date] - (i+1).days
+          key
+        end
+      end
+    end
+  end
+end

data/lib/almicube/bundler/today_bundler.rb

@@ -0,0 +1,9 @@
+module Almicube
+  module Bundler
+    class TodayBundler < Base
+      def keys
+        []
+      end
+    end
+  end
+end

data/lib/almicube/bundler/weekly_bundler.rb

@@ -0,0 +1,11 @@
+module Almicube
+  module Bundler
+    class WeeklyBundler < DaysAgoBundler
+      def initialize(options={})
+        options[:range] = 7
+        options[:name] = :weekly
+        super(options)
+      end
+    end
+  end
+end

data/lib/almicube/bundler/yesterday_bundler.rb

@@ -0,0 +1,16 @@
+module Almicube
+  module Bundler
+    class YesterdayBundler < Base
+      def initialize(options={})
+        options[:name] = :yesterday
+        super(options)
+      end
+
+      def keys
+        key = ranking.data_key
+        key[:date] = ranking.date - 1.days
+        [key]
+      end
+    end
+  end
+end

data/lib/almicube/cog.rb

@@ -0,0 +1,11 @@
+module Almicube
+  module Cog
+    attr_accessor :ranking
+
+    def active?
+      ! @ranking.nil?
+    end
+
+    alias :has_ranking? :active?
+  end
+end

data/lib/almicube/config.rb

@@ -0,0 +1,40 @@
+require 'active_model'
+
+module Almicube
+  class Config
+    include ActiveModel::Model
+    attr_accessor :connection, :key_format
+
+    class << self
+      def root
+        Rails.root if defined? Rails
+      end
+
+      def filepath
+        @filepath ||= File.join(root.to_s, "config", "almicube.yml")
+      end
+
+      def config
+        if @instance.nil? && File.exists?(filepath)
+          @instance = self.new YAML.load_file(filepath)
+        end
+        @instance ||= self.new {}
+      end
+
+      def reset
+        @instance = nil
+      end
+    end
+
+    def connection(env = :default)
+      @connection ||= { default: nil }
+      raise ArgumentError, "connection does not exist" unless @connection.has_key? env
+      @redis ||= Redis.new @connection[env] unless @connection[env].nil?
+      @redis ||= Redis.new
+    end
+
+    def key_format
+      @key_format ||= '%{prefix}:%{class_name}:%{attribute_name}:%{type}:%{distinction}:%{suffix}'
+    end
+  end
+end

data/lib/almicube/engine.rb

@@ -0,0 +1,6 @@
+module Almicube
+  class Engine < ::Rails::Engine
+    config.autoload_paths += Dir[File.join("#{config.root}", "lib", "**")] if Rails.env.development?
+    puts config.autoload_paths
+  end
+end

data/lib/almicube/key.rb

@@ -0,0 +1,46 @@
+module Almicube
+  class Key
+
+    ALLOWED_OPTIONS = %i[prefix suffix class_name attribute_name type distinction date selector]
+    KEY_PATTERN = /%{([a-z_]+)}/ # Example) %{sample_key}
+
+    attr_reader :options, :ranking
+
+    attr_accessor :config
+
+    def initialize(ranking, options={})
+      @ranking = ranking
+      @options = ranking.options.merge(options).select { |k| self.class::ALLOWED_OPTIONS.include? k.to_sym }
+      @config ||= Config.config
+    end
+
+    def [](name)
+      options[name.to_sym]
+    end
+
+    def []=(name, value)
+      options[name.to_sym] = value if self.class::ALLOWED_OPTIONS.include? name.to_sym
+    end
+
+    def method_missing(m, *args, &block)
+      if to_str.respond_to? m
+        to_str.send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    def to_str
+      key = config.key_format.clone
+      key.match( self.class::KEY_PATTERN ) do |m|
+        value = options.fetch(m[1].to_sym, '')
+        value = value.strftime(options.fetch(:date_format, '%Y%m%d')) if value.is_a? Date
+        value = value.label if value.kind_of? Selector::Base
+        key.gsub! m[0], value.to_s
+      end while key =~ self.class::KEY_PATTERN
+      key
+    end
+
+    alias :to_s :to_str
+  end
+end

data/lib/almicube/model.rb

@@ -10,16 +10,13 @@ module Almicube
             ranker = ranker.to_s
             options = options.symbolize_keys!.merge(class_name: self, attribute_name: ranker.to_sym)
 
-            builder_name = options.delete :builder
-            builder_name = :countable unless builder_name
-
             @ranking_builders ||= {}
-            @ranking_builders[ranker.to_sym] = Almicube::Builder.instance(builder_name, options)
+            @ranking_builders[ranker.to_sym] = Almicube::Builder.new options
 
             class_eval <<-EVAL
               def self.#{ranker}_ranking(date = Date.today)
                 @rankings ||= {}
-                @rankings[:"#{ranker}:\#{date.to_s}"] ||= @ranking_builders[:#{ranker}].build(date)
+                @rankings[:"#{ranker}:\#{date.to_s}"] ||= @ranking_builders[:#{ranker}].data(date)
               end
 
               def #{ranker}_ranking(date = Date.today)

data/lib/almicube/proxy/association_proxy.rb

@@ -1,7 +1,7 @@
 module Almicube
   class AssociationProxy
     def initialize(ranking, item)
-      raise TypeError, "without the Almicube::Ranking as #1 argument" unless ranking.kind_of? Ranking
+      raise TypeError, "without the Almicube::Ranking as #1 argument" unless ranking.kind_of? Ranking::Base
       @item = item
       @ranking = ranking
     end

data/lib/almicube/ranking/base.rb

@@ -0,0 +1,63 @@
+module Almicube
+  module Ranking
+    class Base
+      attr_reader :selector, :bundler, :aggregator, :class_name, :date
+      attr_accessor :per_page
+
+      def initialize(options={})
+        @selector = options[:selector]
+        @aggregator = options[:aggregator] || Aggregator::SumAggregator.new
+        @bundler = options[:bundler]
+        @prefix = options[:prefix]
+        @suffix = options[:suffix]
+        @date = options[:date] || Date.today
+        @class_name = options[:class_name]
+        @class_name = @class_name.constantize if @class_name.is_a? String
+        @per_page = options[:per_page] || 10
+
+        @selector.ranking = self unless @selector.nil?
+        @aggregator.ranking = self unless @aggregator.nil?
+        @bundler.ranking = self unless @bundler.nil?
+      end
+
+      def records
+        selector.records
+      end
+
+      def bundled_keys
+        bundler.keys || []
+      end
+
+      def connection
+        Almicube::Config.config.connection
+      end
+
+      def page(page=1)
+        aggregate!
+        page = [1, page.to_i].max
+        revrange = connection.zrevrange(key, (page - 1) * per_page, page * per_page - 1)
+        records = class_name.where("id IN (?)", revrange).all
+        revrange.inject([]) { |l, v| l << records.detect { |r| r.to_param == v } }
+      end
+
+      def aggregate!(options = {})
+        @aggregator.aggregate self
+      end
+
+      def aggregate(options = {})
+        aggregate! options
+        true
+      rescue Exception => e
+        false
+      end
+
+      def data?
+        false
+      end
+
+      protected
+
+      attr_reader :prefix, :suffix
+    end
+  end
+end

data/lib/almicube/ranking/data_ranking.rb

@@ -0,0 +1,128 @@
+require "redis"
+require "active_support/all"
+
+module Almicube
+  module Ranking
+    class DataRanking < Base
+      class << self
+        def default_options
+          { attribute_name: :score,
+            prefix: 'ranking',
+            suffix: '',
+            distinction: '%{date}',
+            date_format: '%Y%m%d',
+            date: Date.today,
+            per_page: 10,
+            as: Float,
+            default_score: 0,
+            class_name: nil }
+        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]
+
+        super(@options)
+
+        @selector ||= Selector::AllSelector.new self.options
+        @options.delete(:selector)
+        @selector.ranking = self
+
+        @options[:aggregator] ||= Aggregator::SumAggregator.new
+        @options[:aggregator].ranking = self
+      end
+
+      KEY_PATTERN = /%{([a-z_]+)}/ # Example) %{sample_key}
+
+      def key(options={})
+        Almicube::Key.new self, options.merge( type: :data )
+      end
+
+      def data_key
+        key_format(@options[:data_key], @options.merge({ type: :data }))
+      end
+
+      def attribute_name
+        @options.fetch(:attribute_name, :score).to_s.to_sym
+      end
+
+      def date
+        @options.fetch(:date, Date.today)
+      end
+
+      def in(target)
+        association_name = class_name.to_s.underscore.pluralize
+
+        if ( target.class != class_name ) && target.respond_to?(association_name)
+          _selector = Selector::HasManySelector.new target: target, association_name: association_name
+          _selector.ranking = self
+          return SubRanking.new self, selector: _selector
+        end
+
+        self
+      end
+
+      def ranged(name)
+        SubRanking.new(self).ranged(name)
+      end
+
+      def per_page=(value)
+        @options[:per_page] = value
+      end
+
+      def options
+        @options.select{ |k| k != :type }.merge({ selector: selector, aggregator: aggregator })
+      end
+
+      def data?
+        selector.data_provider?
+      end
+
+      def exists?
+        connection.exists key
+      end
+
+      def default_score
+        @options.fetch(:default_score, 0)
+      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 key_format(key_base, options)
+        key = key_base.to_s.clone
+        tmp_options = options.merge date: options.fetch(:date, Date.today).strftime(@options[:date_format])
+        tmp_options[:type] ||= :data
+        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
+end

data/lib/almicube/ranking/sub_ranking.rb

@@ -0,0 +1,51 @@
+module Almicube
+  module Ranking
+    class SubRanking < Base
+      attr_reader :ranking, :bundler
+
+      def initialize(ranking, options={})
+        super(options)
+
+        @ranking = ranking
+        self.selector ||= ranking.selector
+        self.bundler = ( options[:bundler] || Almicube::Bundler::YesterdayBundler.new )
+        @class_name ||= ranking.class_name
+      end
+
+      def key
+        key = ranking.key
+        key[:type] = :built
+        key[:suffix] = suffix
+        key[:selector] = selector
+        key[:distinction] = "%{date}:in-%{selector}" unless selector.is_a? Selector::AllSelector
+        key
+      end
+
+      def data_key
+        ranking.key
+      end
+
+      def bundler=(value)
+        @bundler = value
+        value.ranking = self
+      end
+
+      def selector=(value)
+        @selector = value
+        value.ranking = self
+      end
+
+      def ranged(name)
+        bundler_class = "Almicube::Bundler::#{name.to_s.classify}Bundler".constantize
+        self.bundler = bundler_class.new if bundler_class.is_a? Class
+        self
+      end
+
+      protected
+
+      def suffix
+        bundler.bundle unless bundler.nil?
+      end
+    end
+  end
+end

data/lib/almicube/selector/all_selector.rb

@@ -0,0 +1,18 @@
+module Almicube
+  module Selector
+    class AllSelector < Base
+
+      def records
+        ranking.class_name.all
+      end
+
+      def label
+        :data
+      end
+
+      def data_provider?
+        true
+      end
+    end
+  end
+end