minuteman 1.0.2 → 1.0.3

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source "http://rubygems.org"
 
 gemspec
 gem "rake"

data/Gemfile.lock

@@ -1,23 +1,30 @@
 PATH
   remote: .
   specs:
-    minuteman (1.0.2)
-      redis (~> 3.0.2)
+    minuteman (1.0.3)
+      redis (~> 3.0.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    minitest (4.2.0)
+    given_core (3.0.0)
+      sorcerer (>= 0.3.7)
+    minitest (4.3.2)
+    minitest-given (3.0.0)
+      given_core (= 3.0.0)
+      minitest (> 4.3)
     rake (0.9.2.2)
-    redis (3.0.2)
+    redis (3.0.3)
     redis-namespace (1.2.1)
       redis (~> 3.0.0)
+    sorcerer (1.0.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  minitest (~> 4.2.0)
+  minitest (~> 4.3.0)
+  minitest-given (~> 3.0.0)
   minuteman!
   rake
   redis-namespace (~> 1.2.1)

data/HUGS

@@ -0,0 +1,15 @@
+THE HUGWARE LICENSE
+
+LICENSE
+
+If there is no other license you can do whatever you want with this while you
+retain the attribution to the author.
+
+HUGS
+
+The author spent time to make this software so please show some grattitude,
+in any
+form. A hug, a tweet, a beer on a conference or just a plain old email. Your
+choice.
+
+Less hate, more hugs.

data/README.md

@@ -1,7 +1,7 @@
 ![Minuteman](http://elcuervo.github.com/minuteman/img/minuteman-readme.png)
 
 # Minuteman
-[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/elcuervo/minuteman)
+[![Code Climate](https://codeclimate.com/github/elcuervo/minuteman.png)](https://codeclimate.com/github/elcuervo/minuteman)
 [![Build Status](https://secure.travis-ci.org/elcuervo/minuteman.png?branch=master)](https://travis-ci.org/elcuervo/minuteman)
 
 _Wikipedia_: Minutemen were members of teams from Massachusetts that were well-prepared
@@ -63,6 +63,9 @@ Currently Minutemen supports two options `:silent (default: false)` and `:redis
 
 **silent**: when `true` the operations will not raise errors to prevent failures
 
+**time_spans**: an `Array` of Minuteman compatible `TimeSpan`. Eg. `%w[year month
+day]` will only track events on that timespans. Ignoring the rest
+
 **redis**: can be a Hash with the options to be sent to `Redis.new` or a `Redis`
 connection already established (`Redis::Namespace` works as well).
 

data/Rakefile

@@ -1,4 +1,4 @@
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new("spec") do |t|
   t.pattern = "test/**/*_test.rb"

data/lib/minuteman.rb

@@ -3,21 +3,6 @@ require "time"
 require "forwardable"
 require "minuteman/time_events"
 
-# Until redis gem gets updated
-class Redis
-  def bitop(operation, destkey, *keys)
-    synchronize do |client|
-      client.call([:bitop, operation, destkey] + keys)
-    end
-  end
-
-  def bitcount(key, start = 0, stop = -1)
-    synchronize do |client|
-      client.call([:bitcount, key, start, stop])
-    end
-  end
-end
-
 # Public: Minuteman core classs
 #
 class Minuteman
@@ -48,21 +33,9 @@ class Minuteman
 
     self.options = default_options.merge!(options)
     self.redis = define_connection(redis_options)
-  end
-
-  # Public: Generates the methods to fech data
-  #
-  #   event_name - The event name to be searched for
-  #   date       - A Time object used to do the search
-  #
-  %w[year month week day hour minute].each do |method_name|
-    define_method(method_name) do |*args|
-      event_name, date = *args
-      date ||= Time.now.utc
 
-      constructor = self.class.const_get(method_name.capitalize)
-      constructor.new(event_name, date)
-    end
+    spans = self.options.fetch(:time_spans, %w[year month week day hour minute])
+    @time_spans = generate_spans(spans)
   end
 
   # Public: Marks an id to a given event on a given time
@@ -78,7 +51,7 @@ class Minuteman
   #
   def track(event_name, ids, time = Time.now.utc)
     event_time = time.kind_of?(Time) ? time : Time.parse(time.to_s)
-    time_events = TimeEvents.start(event_name, event_time)
+    time_events = TimeEvents.start(@time_spans, event_name, event_time)
 
     track_events(time_events, Array(ids))
   end
@@ -112,13 +85,29 @@ class Minuteman
 
   private
 
+  # Public: Generates the methods to fech data
+  #
+  #   spans: An array of timespans corresponding to a TimeSpan class
+  #
+  def generate_spans(spans)
+    spans.map do |method_name|
+      constructor = self.class.const_get(method_name.capitalize)
+
+      define_singleton_method(method_name) do |*args|
+        event_name, date = *args
+        date ||= Time.now.utc
+
+        constructor.new(event_name, date)
+      end
+
+      constructor
+    end
+  end
+
   # Private: Default configuration options
   #
   def default_options
-    {
-      cache:  true,
-      silent: false
-    }
+    { cache:  true, silent: false }
   end
 
   # Private: Determines to use or instance a Redis connection
@@ -157,8 +146,6 @@ class Minuteman
   # Private: The prefix key of all the operations
   #
   def operations_cache_key_prefix
-    [
-      PREFIX, Minuteman::KeysMethods::BIT_OPERATION_PREFIX
-    ].join("_")
+    [ PREFIX, Minuteman::KeysMethods::BIT_OPERATION_PREFIX ].join("_")
   end
 end

data/lib/minuteman/time_events.rb

@@ -9,8 +9,8 @@ class Minuteman
     #   event_name - The event to be tracked
     #   date       - A given Time object
     #
-    def self.start(event_name, time)
-      [Year, Month, Week, Day, Hour, Minute].map do |t|
+    def self.start(time_spans, event_name, time)
+      time_spans.map do |t|
         t.new(event_name, time)
       end
     end

data/minuteman.gemspec

@@ -1,17 +1,18 @@
 Gem::Specification.new do |s|
   s.name              = "minuteman"
-  s.version           = "1.0.2"
+  s.version           = "1.0.3"
   s.summary           = "Bit Analytics"
   s.description       = "Fast and furious tracking system using Redis bitwise operations"
   s.authors           = ["elcuervo"]
-  s.licenses          = ["MIT"]
+  s.licenses          = ["MIT", "HUGWARE"]
   s.email             = ["yo@brunoaguirre.com"]
   s.homepage          = "http://github.com/elcuervo/minuteman"
   s.files             = `git ls-files`.split("\n")
   s.test_files        = `git ls-files test`.split("\n")
 
-  s.add_dependency("redis", "~> 3.0.2")
+  s.add_dependency("redis", "~> 3.0.3")
 
-  s.add_development_dependency("minitest",        "~> 4.2.0")
+  s.add_development_dependency("minitest",        "~> 4.3.0")
+  s.add_development_dependency("minitest-given",  "~> 3.0.0")
   s.add_development_dependency("redis-namespace", "~> 1.2.1")
 end

data/test/bench/minuteman_bench.rb

@@ -7,9 +7,9 @@ describe Minuteman do
     last_week = today - (3600 * 24 * 7)
 
     @analytics = Minuteman.new
-    @analytics.mark("login", 12)
-    @analytics.mark("login", [2, 42])
-    @analytics.mark("login:successful", 567, last_week)
+    @analytics.track("login", 12)
+    @analytics.track("login", [2, 42])
+    @analytics.track("login:successful", 567, last_week)
 
     @week_events       = @analytics.week("login")
     @last_week_events  = @analytics.week("login", last_week)

data/test/test_helper.rb

@@ -3,6 +3,7 @@ $:.unshift File.dirname(__FILE__) + '/../lib'
 require "bundler/setup"
 require "minitest/spec"
 require "minitest/pride"
+require "minitest/given"
 require "minitest/autorun"
 require "minuteman"
 require "redis-namespace"

data/test/unit/minuteman_test.rb

@@ -1,217 +1,225 @@
 require_relative "../test_helper"
 
 describe Minuteman do
-  before do
-    @analytics = Minuteman.new
-
-    today = Time.now.utc
-    last_month  = today - (3600 * 24 * 30)
-    last_week   = today - (3600 * 24 * 7)
-    last_minute = today - 120
-
-    @analytics.track("login", 12)
-    @analytics.track("login", [2, 42])
-    @analytics.track("login", 2, last_week)
-    @analytics.track("login:successful", 567, last_month)
-
-    @year_events   = @analytics.year("login", today)
-    @week_events   = @analytics.week("login", today)
-    @month_events  = @analytics.month("login", today)
-    @day_events    = @analytics.day("login", today)
-    @hour_events   = @analytics.hour("login", today)
-    @minute_events = @analytics.minute("login", today)
-
-    @last_week_events = @analytics.week("login", last_week)
-    @last_minute_events = @analytics.minute("login", last_minute)
-    @last_month_events = @analytics.month("login:successful", last_month)
-  end
-
-  after { @analytics.reset_all }
+  Given(:analytics)   { Minuteman.new }
 
-  it "should initialize correctly" do
-    assert @analytics.redis
-  end
-
-  it "should track an event on a time" do
-    assert_equal 3, @year_events.length
-    assert_equal 3, @week_events.length
-    assert_equal 1, @last_week_events.length
-    assert_equal 1, @last_month_events.length
-    assert_equal [true, true, false], @week_events.include?(12, 2, 1)
-
-    assert @year_events.include?(12)
-    assert @month_events.include?(12)
-    assert @day_events.include?(12)
-    assert @hour_events.include?(12)
-    assert @minute_events.include?(12)
-
-    assert @last_week_events.include?(2)
-    assert !@month_events.include?(5)
-    assert !@last_minute_events.include?(12)
-    assert @last_month_events.include?(567)
-  end
+  after { analytics.reset_all }
 
-  it "should list all the events" do
-    assert_equal 2, @analytics.events.size
-    assert_equal ["login", "login:successful"], @analytics.events.sort
-  end
+  context "configuration" do
+    Then { analytics.redis }
+    Then { analytics.options[:cache] == true }
 
-  it "should reset all the keys" do
-    assert_equal 2, @analytics.events.size
+    context "switching options" do
+      Given(:minuteman) { Minuteman.new }
 
-    @analytics.reset_all
+      When { minuteman.options[:cache] = false }
+      Then { minuteman.options[:cache] == false }
+    end
 
-    assert_equal 0, @analytics.events.size
-  end
+    context "changing time spans" do
+      Given(:time_spans) { %w[year month day hour] }
+      Given(:minuteman) { Minuteman.new(time_spans: time_spans) }
 
-  it "should reset all bit operation keys" do
-    @week_events & @last_week_events
-    assert_equal 1, @analytics.operations.size
+      When { minuteman.track("login", 12) }
 
-    @analytics.reset_operations_cache
+      Then { minuteman.respond_to?(:year) }
+      Then { minuteman.respond_to?(:month) }
+      Then { minuteman.respond_to?(:day) }
+      Then { minuteman.respond_to?(:hour) }
 
-    assert_equal 0, @analytics.operations.size
-  end
+      Then { !minuteman.respond_to?(:minute) }
+      Then { !minuteman.respond_to?(:week) }
 
-  it "should accept the AND bitwise operations" do
-    and_operation = @week_events & @last_week_events
+      Then { minuteman.redis.keys.size == 4 }
+      Then { minuteman.options[:time_spans] == time_spans }
+    end
 
-    assert @week_events.include?(2)
-    assert @week_events.include?(12)
+    context "fail silently" do
+      Given(:minuteman) { Minuteman.new(silent: true, redis: { port: 1234 }) }
+      When(:result) { minuteman.track("test", 1) }
+      Then { result == nil }
+    end
 
-    assert @last_week_events.include?(2)
-    assert !@last_week_events.include?(12)
+    context "fail loudly" do
+      Given(:minuteman) { Minuteman.new(redis: { port: 1234 }) }
+      When(:result) { minuteman.track("test", 1) }
+      Then { result == Failure(Redis::CannotConnectError) }
+    end
 
-    assert_equal 1, and_operation.length
+    context "changing Redis connection" do
+      Given(:redis) { Redis.new }
+      Then { Minuteman.redis != redis }
 
-    assert !and_operation.include?(12)
-    assert and_operation.include?(2)
-  end
+      context "return the correct connection" do
+        When(:minuteman) { Minuteman.new(redis: redis) }
 
-  it "should accept the OR bitwise operations" do
-    or_operation = @week_events | @last_week_events
+        Then { minuteman.redis == redis }
+      end
 
-    assert @week_events.include?(2)
-    assert @last_week_events.include?(2)
-    assert !@last_week_events.include?(12)
+      context "switching the connection" do
+        Given(:minuteman) { Minuteman.new }
+        When { minuteman.redis = redis }
+        Then { redis == Minuteman.redis }
+      end
 
-    assert_equal 3, or_operation.length
+      context "using Redis::Namespace" do
+        Given(:namespace) { Redis::Namespace.new(:ns, redis: Redis.new) }
+        Given(:minuteman) { Minuteman.new(redis: namespace) }
 
-    assert or_operation.include?(12)
-    assert or_operation.include?(2)
+        Then { minuteman.redis == namespace }
+      end
+    end
   end
 
-  it "should accept the NOT bitwise operations" do
-    not_operation = ~@week_events
-
-    assert @week_events.include?(2)
-    assert @week_events.include?(12)
-
-    assert !not_operation.include?(12)
-    assert !not_operation.include?(2)
-  end
+  context "event tracking" do
+    Given(:today)       { Time.now.utc }
+    Given(:last_month)  { today - (3600 * 24 * 30) }
+    Given(:last_week)   { today - (3600 * 24 * 7) }
+    Given(:last_minute) { today - 120 }
+
+    Given(:year_events) { analytics.year("login", today) }
+    Given(:week_events) { analytics.week("login", today) }
+    Given(:month_events) { analytics.month("login", today) }
+    Given(:day_events) { analytics.day("login", today) }
+    Given(:hour_events) { analytics.hour("login", today) }
+    Given(:minute_events) { analytics.minute("login", today) }
+    Given(:last_week_events) { analytics.week("login", last_week) }
+    Given(:last_minute_events) { analytics.minute("login", last_minute) }
+    Given(:last_month_events) { analytics.month("login:successful", last_month) }
+
+    before do
+      analytics.track("login", 12)
+      analytics.track("login", [2, 42])
+      analytics.track("login", 2, last_week)
+      analytics.track("login:successful", 567, last_month)
+    end
 
-  it "should have an alias for the OR operator" do
-    or_operation = @week_events + @last_week_events
+    Then { analytics.events.size == 2 }
+    Then { year_events.length == 3 }
+    Then { week_events.length == 3 }
+    Then { last_week_events.length == 1 }
+    Then { last_month_events.length == 1 }
 
-    assert @week_events.include?(2)
-    assert @last_week_events.include?(2)
-    assert !@last_week_events.include?(12)
+    context "reseting" do
+      before { analytics.reset_all }
+      Then { analytics.events.size == 0 }
 
-    assert_equal 3, or_operation.length
+      context "bit operations" do
+        before { week_events & last_week_events }
 
-    assert or_operation.include?(12)
-    assert or_operation.include?(2)
-  end
+        When { analytics.reset_operations_cache }
+        Then { analytics.operations.size == 0 }
+      end
+    end
 
-  it "should accept the substraction of a set" do
-    substract_operation = @year_events - @week_events
+    context "on a given time" do
+      Then { year_events.length == 3 }
+      Then { week_events.length == 3 }
+
+      Then { week_events.include?(12, 2, 1) == [true, true, false] }
+      Then { year_events.include?(12) }
+      Then { month_events.include?(12) }
+      Then { day_events.include?(12) }
+      Then { hour_events.include?(12) }
+      Then { minute_events.include?(12) }
+
+      Then { last_week_events.include?(2) }
+      Then { !month_events.include?(5) }
+      Then { !last_minute_events.include?(12) }
+      Then { last_month_events.include?(567) }
+    end
 
-    assert @week_events.include?(2)
-    assert @year_events.include?(2)
-    assert !substract_operation.include?(2)
-  end
+    context "listing events" do
+      Then { analytics.events.size == 2 }
+      Then { analytics.events.sort == ["login", "login:successful"] }
+    end
 
-  it "should accept multiple consecutive operations" do
-    multi_operation = @week_events & @last_week_events | @year_events
+    context "composing" do
+      context "using AND" do
+        Given(:and_operation) { week_events & last_week_events }
 
-    assert_kind_of Minuteman::BitOperations::Result, multi_operation
-  end
+        Then { week_events.include?(2) }
+        Then { week_events.include?(12) }
 
-  it "should return the ids that belong to a given set" do
-    ids = @week_events & [2, 12, 43]
+        Then { last_week_events.include?(2) }
+        Then { !last_week_events.include?(12) }
 
-    assert_kind_of Minuteman::BitOperations::Data, ids
-    assert_equal [2, 12], ids
-  end
-
-  it "should return the ids that do not belong to the given set" do
-    ids = @week_events - [2, 12, 43]
+        Then { !and_operation.include?(12) }
+        Then { and_operation.include?(2) }
+        Then { and_operation.length == 1 }
+      end
 
-    assert_kind_of Minuteman::BitOperations::Data, ids
-    assert_equal [43], ids
-  end
+      context "using OR" do
+        Given(:or_operation) { week_events | last_week_events }
 
-  it "should return a set with data that behaves like an array" do
-    ids = @week_events & [2, 12, 43]
+        Then { week_events.include?(2) }
+        Then { last_week_events.include?(2) }
+        Then { !last_week_events.include?(12) }
 
-    assert_kind_of Enumerator, ids.each
-    assert_kind_of Enumerator, ids.map
-    assert_equal 2, ids.size
-  end
-end
+        Then { or_operation.include?(12) }
+        Then { or_operation.include?(2) }
+        Then { or_operation.length == 3 }
+      end
 
-describe "Using options" do
-  it "should be able to stop using the cache" do
-    minuteman = Minuteman.new
-    assert_equal true, minuteman.options[:cache]
+      context "using NOT" do
+        Given(:not_operation) { ~week_events }
 
-    minuteman.options[:cache] = false
+        Then { week_events.include?(2) }
+        Then { week_events.include?(12) }
 
-    assert_equal false, minuteman.options[:cache]
-  end
-end
+        Then { !not_operation.include?(12) }
+        Then { !not_operation.include?(2) }
+      end
 
-describe "Changing Minuteman redis connections" do
-  it "should support using a Redis instance" do
-    redis = Redis.new
-    minuteman = Minuteman.new(redis: redis)
+      context "using OR alias (+)" do
+        Given(:or_operation) { week_events + last_week_events }
 
-    assert_equal redis, Minuteman.redis
-    assert_equal redis, minuteman.redis
-  end
+        Then { week_events.include?(2) }
+        Then { last_week_events.include?(2) }
+        Then { !last_week_events.include?(12) }
 
-  it "should support changing the current connection" do
-    redis = Redis.new
-    minuteman = Minuteman.new
+        Then { or_operation.include?(12) }
+        Then { or_operation.include?(2) }
+        Then { or_operation.length == 3 }
+      end
 
-    assert redis != Minuteman.redis
+      context "using MINUS" do
+        Given(:substract_operation) { year_events - week_events }
 
-    minuteman.redis = redis
+        Then { week_events.include?(2) }
+        Then { year_events.include?(2) }
+        Then { !substract_operation.include?(2) }
+      end
+    end
 
-    assert_equal redis, minuteman.redis
-  end
+    context "composing multiple operations" do
+      Given(:multi_operation) { week_events & last_week_events | year_events }
+      Then { multi_operation.is_a?(Minuteman::BitOperations::Result) }
+    end
 
-  it "should support Redis::Namespace" do
-    namespace = Redis::Namespace.new(:ns, redis: Redis.new)
+    context "composing against arrays" do
+      context "using AND returns the intersection" do
+        Given(:ids) { week_events & [2, 12, 43] }
 
-    minuteman = Minuteman.new(redis: namespace)
+        Then { ids.is_a?(Minuteman::BitOperations::Data) }
+        Then { ids == [2, 12] }
+      end
 
-    assert_equal namespace, Minuteman.redis
-    assert_equal namespace, minuteman.redis
-  end
+      context "using MINUS returns the difference" do
+        Given(:ids) { week_events - [2, 12, 43] }
 
-  it "should fail silently" do
-    minuteman = Minuteman.new(silent: true, redis: { port: 1234 })
+        Then { ids.is_a?(Minuteman::BitOperations::Data) }
+        Then { ids == [43] }
+      end
 
-    minuteman.track("test", 1)
-  end
+      context "returns an object that behaves like Array" do
+        Given(:ids) { week_events & [2, 12, 43] }
 
-  it "should fail loudly" do
-    minuteman = Minuteman.new(redis: { port: 1234 })
+        Then { ids.each.is_a?(Enumerator) }
+        Then { ids.map.is_a?(Enumerator) }
+        Then { ids.size == 2 }
+      end
 
-    assert_raises Redis::CannotConnectError do
-      minuteman.track("test", 1)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minuteman
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-29 00:00:00.000000000 Z
+date: 2013-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 4.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 4.3.0
+- !ruby/object:Gem::Dependency
+  name: minitest-given
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: redis-namespace
   requirement: !ruby/object:Gem::Requirement
@@ -69,6 +85,7 @@ files:
 - .travis.yml
 - Gemfile
 - Gemfile.lock
+- HUGS
 - LICENSE
 - README.md
 - Rakefile
@@ -96,6 +113,7 @@ files:
 homepage: http://github.com/elcuervo/minuteman
 licenses:
 - MIT
+- HUGWARE
 post_install_message: 
 rdoc_options: []
 require_paths: