almicube 0.0.2 → 0.0.3

data/lib/almicube/selector/base.rb

@@ -0,0 +1,32 @@
+module Almicube
+  module Selector
+    class Base
+      include Almicube::Cog
+
+      attr_reader :class_name
+
+      def initialize(options={})
+        @class_name = options[:class_name]
+        @class_name = class_name.constantize if class_name.is_a? String
+        @label = options[:label]
+      end
+
+      alias :model_class :class_name
+
+      def label
+        @label
+      end
+
+      def data_provider?
+        false
+      end
+
+      def before_aggregate
+      end
+
+      def interstore
+        nil
+      end
+    end
+  end
+end

data/lib/almicube/selector/has_many_selector.rb

@@ -0,0 +1,42 @@
+module Almicube
+  module Selector
+    class HasManySelector < Base
+
+      attr_reader :target, :association_name
+
+      def initialize(options={})
+        super(options)
+
+        @target = options[:target]
+        @association_name = options[:association_name]
+      end
+
+      def records
+        target.send(association_name)
+      end
+
+      def label
+        "#{target.class.to_s.underscore}-#{target.to_param}"
+      end
+
+      def before_aggregate
+        records.map{ |r| r.to_param }.each do |i|
+          Config.config.connection.zadd(interstore_key, 0, i)
+        end
+      end
+
+      def interstore
+        interstore_key
+      end
+
+      protected
+
+      def interstore_key
+        _key = ranking.key
+        _key[:distinction] = label
+        _key[:suffix] = ""
+        _key
+      end
+    end
+  end
+end

data/lib/almicube/selector/method_selector.rb

@@ -0,0 +1,34 @@
+module Almicube
+  module Selector
+    class MethodSelector < Base
+      attr_reader :accessor, :counter
+
+      def initialize(options={})
+        super(options)
+
+        @accessor = options[:accessor] || :all
+        @counter = options[:counter] || :count
+
+        raise "invalid options" unless valid?
+      end
+
+      def records
+        class_name.send(accessor)
+      end
+
+      def count
+        class_name.send(counter)
+      end
+
+      def valid?
+        validate_accessor
+      end
+
+      protected
+
+      def validate_accessor
+        class_name.class == Class && class_name.respond_to?(accessor)
+      end
+    end
+  end
+end

data/lib/almicube/version.rb

@@ -1,3 +1,3 @@
 module Almicube
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/almicube.rb

@@ -1,16 +1,46 @@
+require 'yaml'
+
 module Almicube
-  autoload :Ranking, 'almicube/ranking'
+  module Ranking
+    autoload :Base, 'almicube/ranking/base'
+    autoload :DataRanking, 'almicube/ranking/data_ranking'
+    autoload :SubRanking, 'almicube/ranking/sub_ranking'
+  end
+
   autoload :RangedRanking, 'almicube/ranged_ranking'
   autoload :Model, 'almicube/model'
   autoload :AssociationProxy, 'almicube/proxy/association_proxy'
+  autoload :Config, 'almicube/config'
+  autoload :Cog, 'almicube/cog'
+  autoload :Key, 'almicube/key'
 
   autoload :Builder, 'almicube/builder'
-  module Builder
-    autoload :CountableRankingBuilder, 'almicube/builder/countable_ranking_builder'
-    autoload :AverageRankingBuilder, 'almicube/builder/average_ranking_builder'
+
+  module Bundler
+    autoload :Base, 'almicube/bundler/base'
+    autoload :DaysAgoBundler, 'almicube/bundler/days_ago_bundler'
+    autoload :TodayBundler, 'almicube/bundler/today_bundler'
+    autoload :YesterdayBundler, 'almicube/bundler/yesterday_bundler'
+    autoload :WeeklyBundler, 'almicube/bundler/weekly_bundler'
+  end
+
+  module Selector
+    autoload :Base, 'almicube/selector/base'
+    autoload :AllSelector, 'almicube/selector/all_selector'
+    autoload :MethodSelector, 'almicube/selector/method_selector'
+    autoload :HasManySelector, 'almicube/selector/has_many_selector'
+  end
+
+  module Aggregator
+    autoload :Base, 'almicube/aggregator/base'
+    autoload :SumAggregator, 'almicube/aggregator/sum_aggregator'
   end
 
   if defined? ActiveRecord
     ActiveRecord::Base.send :include, Almicube::Model
   end
+
+  if defined? Rails
+    require 'almicube/engine'
+  end
 end

data/spec/almicube/aggregator/sum_aggregator_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Almicube::Aggregator::SumAggregator do
+  let(:size) { 1 }
+  let(:size_d) { size * 10 }
+
+  before(:all) { @connection = Redis.new }
+  before { @connection.flushdb }
+
+  it { expect(size).to be > 0 }
+
+  shared_examples "correct aggregation" do
+    before { aggregator.ranking = ranking }
+
+    it "add new sorted set" do
+      expect{ aggregator.aggregate }.to change{ @connection.dbsize }.by 1
+    end
+    it "has correct items" do
+      expect(@connection.zcard(ranking.key)).to eq 0
+      aggregator.aggregate
+      expect(@connection.zcard(ranking.key)).to eq ranking.records.count
+    end
+  end
+
+  context "data ranking" do
+    context "target attribute is score" do
+      let(:ranking) { double( key: "sample:score", attribute_name: :score, data?: true ) }
+      let(:aggregator) { described_class.new }
+      before do
+        ranking.stub(:records) { size_d.times.map { |i| double( to_param: i, score: i*10 ) } }
+      end
+      it_behaves_like "correct aggregation"
+    end
+
+    context "target attribute is access" do
+      let(:ranking) { double( key: "sample:access", attribute_name: :access, data?: true) }
+      let(:aggregator) { described_class.new }
+      before do
+        ranking.stub(:records) { size_d.times.map { |i| double( to_param: i, access: 1000 ) } }
+      end
+      it_behaves_like "correct aggregation"
+    end
+  end
+
+  context "sub ranking" do
+    context "target attribute is score" do
+      let(:ranking) { double( key: "sample:score", bundled_keys: ["sample:score:1", "sample:score:2"], attribute_name: :score, data?: false ) }
+      let(:aggregator) { described_class.new }
+      before do
+        ranking.stub(:records) { size_d.times.map { |i| double( to_param: i, score: i*10 ) } }
+        2.times.each do |i|
+          ranking.records.each do |record|
+            @connection.zadd("sample:score:#{i+1}", 20, record.to_param )
+          end
+        end
+      end
+      it_behaves_like "correct aggregation"
+      it "has ranking to set all score 40" do
+        aggregator.ranking = ranking
+        aggregator.aggregate
+        @connection.zrange("sample:score", 0, -1).each do |id|
+          expect(@connection.zscore("sample:score", id)).to eq 40
+        end
+      end
+    end
+
+    context "target attribute is access" do
+      let(:key) { "sample:access" }
+      let(:bundled_keys) { ["#{key}:1", "#{key}:2"] }
+      let(:ranking) { double( key: key, bundled_keys: bundled_keys, attribute_name: :access, data?: false ) }
+      let(:aggregator) { described_class.new }
+      before do
+        ranking.stub(:records) { size_d.times.map { |i| double( to_param: i, access: 1000 ) } }
+        2.times.each do |i|
+          ranking.records.each { |record| @connection.zadd("#{key}:#{i+1}", 1000, record.to_param ) }
+        end
+      end
+      it_behaves_like "correct aggregation"
+      it "has ranking to set all score 2000" do
+        aggregator.ranking = ranking
+        aggregator.aggregate
+        @connection.zrange("sample:access", 0, -1).each do |id|
+          expect(@connection.zscore("sample:access", id)).to eq 2000
+        end
+      end
+    end
+  end
+
+  it_behaves_like "ranking cog" do
+    let(:target) { described_class.new }
+  end
+end

data/spec/almicube/builder_sprc.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Almicube::Builder do
+  let(:builder) { described_class.new }
+
+  describe "#selector" do
+    describe "defaults all selector" do
+      it { expect(builder.selector).to be_kind_of Almicube::Selector::AllSelector }
+    end
+
+    describe "with class name on initializer" do
+      before { builder.selector = "MockSelector" }
+      it { expect(builder.selector).to be_kind_of MockSelector }
+    end
+  end
+
+  describe "#data" do
+    describe "returns DataRanking instance" do
+      it { expect(builder.data).to be_kind_of Almicube::Ranking::DataRanking }
+    end
+  end
+end

data/spec/almicube/bundler/days_ago_bundler_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Almicube::Bundler::DaysAgoBundler do
+  let(:ranking) { Almicube::Ranking::DataRanking.new }
+
+  describe "#name" do
+    let(:bundler) { described_class.new range: 7 }
+    before { bundler.ranking = ranking }
+    it { expect(bundler.name).to eq :"7-days-ago" }
+  end
+
+  describe "#keys" do
+    let(:bundler) { described_class.new range: 7 }
+    before { bundler.ranking = ranking }
+    it { expect(bundler.keys.length).to eq 7 }
+    7.times.each do |i|
+      it { expect(bundler.keys[i]).to match /:#{(Date.today-(i+1).days).strftime("%Y%m%d")}:/ }
+    end
+  end
+end

data/spec/almicube/bundler/today_bundler_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Almicube::Bundler::TodayBundler do
+  let(:bundler) { described_class.new bundle: :bundle }
+
+  describe "#name" do
+    it { expect(bundler.name).to eq :bundle }
+  end
+
+  describe "#bundle" do
+    it { expect(bundler.bundle).to eq bundler.name }
+  end
+
+  describe "#active?" do
+    context "with ranking" do
+      before { bundler.ranking = double() }
+      it { expect(bundler).to be_active }
+    end
+
+    context "without ranking" do
+      it { expect(bundler).not_to be_active }
+    end
+  end
+end

data/spec/almicube/bundler/yesterday_bundler_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Almicube::Bundler::YesterdayBundler do
+  describe "#name" do
+    let(:bundler) { described_class.new }
+    it { expect(bundler.name).to eq :yesterday }
+  end
+
+  describe "#keys" do
+    let(:ranking) { Almicube::Ranking::SubRanking.new(Almicube::Ranking::DataRanking.new) }
+    let(:bundler) { described_class.new }
+    before { bundler.ranking = ranking }
+    it { expect(bundler.keys[0]).to match /:#{(Date.today-1.days).strftime("%Y%m%d")}:/ }
+    it { expect(bundler.keys.length).to eq 1 }
+  end
+end

data/spec/almicube/config_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Almicube::Config do
+  before do
+    File.stub(:exists?).and_return(true)
+    YAML.stub(:load_file).and_return(test_config)
+    described_class.reset
+  end
+
+  describe "#connection" do
+    let(:default_param) { { url: "redis://0.0.0.0:6380/1" } }
+    let(:development_param) { { url: "redis://0.0.0.0:6380/15" } }
+    let(:test_config) do
+      {
+        connection: {
+          default: default_param,
+          development: development_param
+        }
+      }
+    end
+
+    context "with default connection" do
+      before { Redis.should_receive(:new).with( default_param ) }
+      it { described_class.config.connection }
+    end
+
+    context "with actual connection" do
+      before { Redis.should_receive(:new).with( development_param ) }
+      it { described_class.config.connection :development }
+    end
+
+    context "with no-exists connection" do
+      before { Redis.stub(:new) }
+      it { expect{ described_class.config.connection :noexists }.to raise_error }
+    end
+
+    context "already setting up default connection" do
+      let(:redis) { double("redis") }
+      before do
+        Redis.stub(:new).and_return(redis)
+        described_class.config.connection
+      end
+      it { expect(described_class.config.connection).to eq redis }
+    end
+  end
+end

data/spec/almicube/key_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Almicube::Key do
+  describe "#options" do
+    context "pass options through constructor" do
+      let(:ranking) { Almicube::Ranking::DataRanking.new }
+      let(:key) { described_class.new ranking, prefix: "aaa", suffix: "bbb" }
+
+      it { expect(key[:prefix]).to eq "aaa" }
+      it { expect(key[:suffix]).to eq "bbb" }
+    end
+
+    context "pass options through ranking instance" do
+      let(:ranking) { Almicube::Ranking::DataRanking.new prefix: "ccc", suffix: "ddd" }
+      let(:key) { described_class.new ranking }
+
+      it { expect(key[:prefix]).to eq "ccc" }
+      it { expect(key[:suffix]).to eq "ddd" }
+    end
+  end
+
+  describe "#to_str" do
+    let(:ranking) { double( options: {} ) }
+    let(:key) { described_class.new ranking, prefix: "aaa", suffix: "bbb" }
+    before { key[:type] = :built }
+    it { expect("#{key}").to match /^aaa:/ }
+    it { expect("#{key}").to match /:bbb$/ }
+    it { expect("#{key}").to match /:built:/ }
+  end
+end

data/spec/almicube/ranking/base_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Almicube::Ranking::Base do
+  describe "#bundled_keys" do
+    let(:bundler) { double( keys: ["1", "2"] ) }
+    let(:ranking) { described_class.new bundler: bundler }
+    it { expect(ranking.bundled_keys).to eq ["1", "2"] }
+  end
+end

data/spec/almicube/ranking/data_ranking_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+class MockAggregator < Almicube::Aggregator::Base
+end
+
+describe Almicube::Ranking::DataRanking do
+  describe "#selector" do
+    let(:ranking) { described_class.new selector: selector }
+
+    describe "sets the mock selector" do
+      let(:selector) { MockSelector.new records: records }
+      let(:records) { [double(), double()] }
+      it { expect(ranking.records).to eq records }
+      it { expect(ranking.selector).to eq selector }
+    end
+
+    describe "does not set the selector" do
+      let(:selector) { nil }
+      it { expect(ranking.selector).to be_kind_of Almicube::Selector::AllSelector }
+    end
+  end
+
+  describe "#aggregator" do
+    let(:ranking) { described_class.new aggregator: aggregator }
+
+    describe "set the mock aggregator" do
+      let(:aggregator) { MockAggregator.new }
+      before { aggregator.should_receive(:aggregate).with(ranking) }
+      it { ranking.aggregate }
+    end
+  end
+
+  describe "#per_page" do
+    let(:ranking) { described_class.new per_page: 10 }
+    it { expect(ranking.per_page).to eq 10 }
+  end
+
+  describe "#class_name" do
+    let(:ranking) { described_class.new class_name: MockModel }
+    it { expect(ranking.class_name).to eq MockModel }
+  end
+
+  describe "#data?" do
+    let(:ranking) { described_class.new }
+    it { expect(ranking).to be_data }
+  end
+
+  describe "#key" do
+    context "with prefix and suffix" do
+      let(:ranking) { described_class.new prefix: "aaa", suffix: "bbb" }
+      it { expect(ranking.key).to match /^aaa:/ }
+      it { expect(ranking.key).to match /:bbb$/ }
+    end
+
+    describe "differents between two days data" do
+      let(:today) { Date.today }
+      let(:ranking1) { described_class.new date: today }
+      let(:ranking2) { described_class.new date: today - 1.days }
+
+      it { expect(ranking1.key).to match /#{today.strftime("%Y%m%d")}/ }
+      it { expect(ranking1.key).to_not match /#{ranking2.key}/ }
+    end
+
+    describe "include class name" do
+      let(:ranking) { described_class.new class_name: MockModel }
+
+      it { expect(ranking.key).to match /#{MockModel.to_s}/ }
+    end
+
+    describe "include attribute name" do
+      let(:ranking) { described_class.new attribute_name: :score }
+
+      it { expect(ranking.key).to match /score/ }
+    end
+
+    describe "include data flag" do
+      context "without specific selector" do
+        let(:ranking) { described_class.new }
+
+        it { expect(ranking.key).to match /:data:/ }
+      end
+    end
+
+    describe "exclude bundler name" do
+      let(:ranking) { described_class.new bundler: MockBundler.new }
+
+      it { expect(ranking.key).not_to match /bundle/ }
+    end
+  end
+
+  describe "#options" do
+    let(:ranking) { described_class.new }
+    let(:options) { ranking.options }
+
+    %i[selector aggregator date per_page prefix suffix].each do |key|
+      it { expect(options).to have_key key }
+    end
+
+    %i[type].each do |key|
+      it { expect(options).not_to have_key key }
+    end
+  end
+end

data/spec/almicube/ranking/sub_ranking_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Almicube::Ranking::SubRanking do
+  let(:data_selector) { MockSelector.new }
+  let(:data_ranking) { Almicube::Ranking::DataRanking.new( selector: data_selector ) }
+
+  describe "#key" do
+    let(:ranking) { described_class.new(data_ranking, bundler: bundler) }
+    let(:bundler) { double( bundle: :bundled ) }
+
+    it { expect(ranking.key).not_to match /:data:/ }
+    it { expect(ranking.key).to match /:built:/ }
+    it { expect(ranking.key).to match /:bundled$/ }
+  end
+
+  describe "#selector" do
+    context "uses optional selector" do
+      let(:selector) { double( records: [] ) }
+      let(:ranking) { described_class.new(data_ranking, selector: selector) }
+      it { expect(ranking.selector).to eq selector }
+    end
+
+    context "uses selector on data ranking" do
+      let(:ranking) { described_class.new(data_ranking) }
+      it { expect(ranking.selector).to eq data_selector }
+    end
+  end
+
+  describe "#records" do
+    let(:selector) { double( records: ["a", "b"] ) }
+    let(:ranking) { described_class.new(data_ranking, selector: selector) }
+    it { expect(ranking.records).to eq selector.records }
+  end
+end

data/spec/almicube/selector/all_selector_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Almicube::Selector::AllSelector do
+  let(:ranking) { double( class_name: MockModel ) }
+
+  describe "#data_probider?" do
+    it { expect(described_class.new).to be_data_provider }
+  end
+
+  describe "#records" do
+    let(:selector) { described_class.new }
+    before { selector.ranking = ranking }
+    it "should send :all an instance of MockModel" do
+      MockModel.should_receive(:all)
+      selector.records
+    end
+  end
+
+  it_behaves_like "ranking cog" do
+    let(:target) { described_class.new }
+  end
+end

data/spec/almicube/selector/method_selector_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'mocks/model'
+
+describe Almicube::Selector::MethodSelector do
+  describe "#initialize" do
+    it { expect{ described_class.new }.to raise_error }
+    it { expect{ described_class.new class_name: "UnknownClassName" }.to raise_error }
+    it { expect{ described_class.new accessor: :invalid, class_name: MockModelForSelector }.to raise_error }
+    it { expect{ described_class.new accessor: :all, class_name: MockModelForSelector }.to_not raise_error }
+  end
+
+  describe "#records" do
+    context "setted accessor method is all" do
+      let(:selector) { described_class.new accessor: :all, class_name: MockModelForSelector }
+      let(:records) { [double(), double()] }
+      before { MockModelForSelector.should_receive(:all).and_return(records) }
+      it { expect(selector.records).to eq records }
+    end
+  end
+
+  describe "#count" do
+    context "setted counter method is count" do
+      let(:selector) { described_class.new counter: :count, class_name: MockModelForSelector }
+      let(:count) { 100 }
+      before { MockModelForSelector.should_receive(:count).and_return(count) }
+      it { expect(selector.count).to eq count }
+    end
+  end
+
+  describe "default accessor" do
+    let(:selector) { described_class.new class_name: MockModelForSelector }
+    it { expect(selector.accessor).to eq :all }
+  end
+
+  describe "default counter" do
+    let(:selector) { described_class.new class_name: MockModelForSelector }
+    it { expect(selector.counter).to eq :count }
+  end
+end

data/spec/almicube/selector/mock_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'mocks/model'
+
+describe Almicube::Selector::Base do
+  describe "#records" do
+    let(:selector) { described_class.new }
+    it { expect{ selector.records }.to raise_error }
+  end
+
+  describe "#initialize" do
+    let(:selector) { described_class.new options }
+    describe "with class_name" do
+      let(:options) { { class_name: MockModelForSelector } }
+      it { expect(selector.class_name).to eq MockModelForSelector }
+      it { expect(selector.model_class).to eq MockModelForSelector }
+    end
+  end
+
+  describe "#label" do
+    let(:selector) { described_class.new options }
+    describe "with label" do
+      let(:options) { { label: :sample } }
+      it { expect(selector.label).to eq :sample }
+    end
+  end
+
+  describe "#data_provider?" do
+    let(:selector) { described_class.new options }
+    describe "is false" do
+      let(:options) { {} }
+      it { expect(selector).to_not be_data_provider }
+    end
+  end
+end

data/spec/mocks/aggregator.rb

@@ -0,0 +1,2 @@
+class MockAggregator < Almicube::Aggregator::Base
+end

data/spec/mocks/bundler.rb

@@ -0,0 +1,5 @@
+class MockBundler < Almicube::Bundler::Base
+  def initialize(options={})
+    @name = :bundle
+  end
+end