sleek 0.0.1

data/lib/sleek/queries/query.rb

@@ -0,0 +1,105 @@
+module Sleek
+  module Queries
+    class Query
+      attr_reader :namespace, :bucket, :options
+
+      # Internal: Initialize the query.
+      #
+      # namespace - the Symbol namespace name.
+      # bucket    - the String bucket name.
+      # options   - the optional Hash of options.
+      #             :timeframe - the optional timeframe description.
+      #             :interval  - the optional interval description.
+      #
+      # Raises ArgumentError if passed options are invalid.
+      def initialize(namespace, bucket, options = {})
+        @namespace = namespace
+        @bucket = bucket
+        @options = options
+
+        raise ArgumentError, "options are invalid" unless valid_options?
+      end
+
+      # Internal: Get Mongoid::Criteria for events to perform the query.
+      #
+      # time_range - the optional range of Time objects.
+      def events(time_range = time_range)
+        evts = Event.where(namespace: namespace, bucket: bucket)
+        evts = evts.between("s.t" => time_range) if time_range
+        evts = apply_filters(evts) if filter?
+        evts
+      end
+
+      # Internal: Apply all the filters to the criteria.
+      def apply_filters(criteria)
+        filters.inject(criteria) { |crit, filter| filter.apply(crit) }
+      end
+
+      # Internal: Get filters.
+      def filters
+        filters = options[:filter]
+        
+        if filters.is_a?(Array) && filters.size == 3 && filters.none? { |f| f.is_a?(Array) }
+          filters = [filters]
+        elsif !filters.is_a?(Array) || !filters.all? { |f| f.is_a?(Array) && f.size == 3 }
+          raise ArgumentError, "wrong filter - #{filters}"
+        end
+
+        filters.map { |f| Sleek::Filter.new(*f) }
+      end
+
+      # Internal: Get timeframe for the query.
+      #
+      # Returns nil if no timeframe was passed to initializer.
+      def timeframe
+        Sleek::Timeframe.new(options[:timeframe]) if timeframe?
+      end
+
+      # Internal: Get timeframe range.
+      def time_range
+        timeframe.try(:to_time_range)
+      end
+
+      def series
+        Sleek::Interval.new(options[:interval], timeframe).timeframes if series? && timeframe?
+      end
+
+      # Internal: Check if options include filter.
+      def filter?
+        options[:filter].present?
+      end
+
+      # Internal: Check if options include timeframe.
+      def timeframe?
+        options[:timeframe].present?
+      end
+
+      # Internal: Check if options include interval.
+      def series?
+        options[:interval].present?
+      end
+
+      # Internal: Run the query.
+      def run
+        if series?
+          series.map do |tf|
+            { timeframe: tf, value: perform(events(tf.to_time_range)) }
+          end
+        else
+          perform(events)
+        end
+      end
+
+      # Internal: Perform the query on a set of events.
+      def perform(events)
+        raise NotImplementedError
+      end
+
+      # Internal: Validate the options.
+      def valid_options?
+        options.is_a?(Hash) && (filter? ? options[:filter].is_a?(Array) : true) &&
+          (series? ? timeframe? && series : true)
+      end
+    end
+  end
+end

data/lib/sleek/queries/sum.rb

@@ -0,0 +1,21 @@
+module Sleek
+  module Queries
+    # Internal: Sum query.
+    #
+    # Finds the average value for a given property.
+    #
+    # target_property - the String name of target property on event.
+    #
+    # Examples
+    #
+    #   sleek.queries.sum(:purchases, target_property: "total")
+    #   # => 2_072_70
+    class Sum < Query
+      include Targetable
+
+      def perform(events)
+        events.sum target_property
+      end
+    end
+  end
+end

data/lib/sleek/queries/targetable.rb

@@ -0,0 +1,13 @@
+module Sleek
+  module Queries
+    module Targetable
+      def valid_options?
+        super && options[:target_property].present?
+      end
+
+      def target_property
+        "d.#{options[:target_property]}"
+      end
+    end
+  end
+end

data/lib/sleek/queries.rb

@@ -0,0 +1,8 @@
+require 'sleek/queries/query'
+require 'sleek/queries/targetable'
+require 'sleek/queries/count'
+require 'sleek/queries/count_unique'
+require 'sleek/queries/minimum'
+require 'sleek/queries/maximum'
+require 'sleek/queries/average'
+require 'sleek/queries/sum'

data/lib/sleek/query_collection.rb

@@ -0,0 +1,25 @@
+module Sleek
+  class QueryCollection
+    attr_reader :namespace
+
+    # Inernal: Initialize query collection.
+    #
+    # namespace - the Symbol namespace name.
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    # Define method for each query
+    [:count, :count_unique, :minimum, :maximum, :sum, :average].each do |name|
+      klass = "Sleek::Queries::#{name.to_s.camelize}".constantize
+
+      define_method(name) do |bucket, options = {}|
+        klass.new(namespace, bucket, options).run
+      end
+    end
+
+    def inspect
+      "#<Sleek::QueryCollection ns=#{namespace}>"
+    end
+  end
+end

data/lib/sleek/timeframe.rb

@@ -0,0 +1,85 @@
+module Sleek
+  class Timeframe
+    # Internal: Initialize timeframe.
+    #
+    # timeframe - either a range of Time objects, an array of two Time
+    #             objects, or a special string.
+    #
+    # Possible special string format:
+    # (this|previous)_((\d+)_)?(minute|hour|day|week|month)s?
+    #
+    # Examples
+    #
+    #   Timeframe.new "this_2_days"
+    #
+    #   Timeframe.new "previous_hour"
+    def initialize(timeframe)
+      @timeframe = timeframe
+    end
+
+    # Public: Get timeframe start.
+    def start
+      to_time_range.begin
+    end
+
+    # Public: Get timeframe end.
+    def end
+      to_time_range.end
+    end
+
+    # Internal: Convert Timeframe instance to a range of Time objects.
+    def to_time_range
+      @range ||= self.class.to_range(@timeframe)
+    end
+
+    def inspect
+      "#<Sleek::Timeframe #{to_time_range}>"
+    end
+
+    class << self
+      # Internal: Transform the object passed to Timeframe initializer
+      # into a range of Time objects.
+      #
+      # timeframe - either a Range of Time objects, a two-element array
+      #             of Time Objects, or a special string.
+      #
+      # Raises ArgumentError if passed object can't be processed.
+      def to_range(timeframe)
+        case timeframe
+        when Range
+          t = timeframe if timeframe.time_range?
+        when Array
+          t = timeframe.first..timeframe.last if timeframe.size == 2 && timeframe.count { |tf| tf.is_a?(Time) } == 2
+        when String, Symbol
+          t = parse(timeframe.to_s)
+        end
+
+        raise ArgumentError, "wrong timeframe" unless t
+        t
+      end
+
+      # Internal: Process timeframe string to make up a range.
+      #
+      # timeframe - the String matching
+      #             (this|previous)_((\d+)_)?(minute|hour|day|week|month)s?
+      def parse(timeframe)
+        regexp = /(this|previous)_((\d+)_)?(minute|hour|day|week|month)s?/
+        _, category, _, number, interval = *timeframe.match(regexp)
+
+        unless category && interval
+          raise ArgumentError, "special timeframe string is malformed"
+        end
+
+        number ||= 1
+        number = number.to_i
+
+        end_point = Time.now.send("end_of_#{interval}").round
+        start_point = end_point - number.send(interval)
+
+        range = start_point..end_point
+        range = range - 1.send(interval) if category == 'previous'
+        range
+      end
+    end
+  end
+end

data/lib/sleek/version.rb

@@ -0,0 +1,3 @@
+module Sleek
+  VERSION = "0.0.1"
+end

data/lib/sleek.rb

@@ -0,0 +1,23 @@
+require 'mongoid'
+
+require 'sleek/core_ext/range'
+require 'sleek/core_ext/time'
+
+require 'sleek/version'
+require 'sleek/timeframe'
+require 'sleek/interval'
+require 'sleek/filter'
+require 'sleek/event'
+require 'sleek/queries'
+require 'sleek/query_collection'
+require 'sleek/base'
+
+module Sleek
+  def self.for_namespace(namespace)
+    Base.new namespace
+  end
+
+  def self.[](namespace)
+    for_namespace(namespace)
+  end
+end

data/sleek.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sleek/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sleek"
+  spec.version       = Sleek::VERSION
+  spec.authors       = ["Gosha Arinich"]
+  spec.email         = ["me@goshakkk.name"]
+  spec.description   = %q{Sleek is a library for doing analytics.}
+  spec.summary       = %q{Sleek is a library for doing analytics.}
+  spec.homepage      = "http://github.com/goshakkk/sleek"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_runtime_dependency 'mongoid', '~> 3.1'
+  spec.add_runtime_dependency 'activesupport', '~> 3.2'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec', '~> 2.13'
+  spec.add_development_dependency 'database_cleaner', '~> 0.9'
+end

data/spec/lib/sleek/base_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Sleek::Base do
+  subject(:sleek) { Sleek::Base.new(:default) }
+
+  describe "#initialize" do
+    it "sets the namespace" do
+      sleek = Sleek::Base.new(:my_namespace)
+      expect(sleek.namespace).to eq :my_namespace
+    end
+  end
+
+  describe "#record" do
+    it "creates an event record" do
+      data = { name: 'John Doe', email: 'j@d.com' }
+
+      Sleek::Event.should_receive(:create_with_namespace).with(:default, "signups", data)
+
+      sleek.record("signups", data)
+    end
+  end
+
+  describe "#queries" do
+    it "returns QueryCollection for current namespace" do
+      Sleek::QueryCollection.should_receive(:new).with(:default).and_call_original
+      qc = sleek.queries
+      expect(qc.namespace).to eq :default
+    end
+  end
+
+  describe "#delete_bucket" do
+    it "deletes everything from the bucket" do
+      events = stub('events')
+      sleek.should_receive(:events).with(:abc).and_return(events)
+      events.should_receive(:delete_all)
+      sleek.delete_bucket(:abc)
+    end
+  end
+
+  describe "#delete_property" do
+    it "it deletes the property from all events in bucket" do
+      events = stub('events')
+      sleek.should_receive(:events).with(:abc).and_return(events)
+      events.should_receive(:unset).with("d.test")
+      sleek.delete_property(:abc, "test")
+    end
+  end
+end

data/spec/lib/sleek/event_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Sleek::Event do
+  describe ".create_with_namespace" do
+    it "creates event record" do
+      expect { Sleek::Event.create_with_namespace(:default, "signups", { name: 'John Doe', email: 'john@doe.com' }) }.to change { Sleek::Event.count }.by(1)
+    end
+
+    it "sets namespace and bucket" do
+      evt = Sleek::Event.create_with_namespace(:default, "signups", {})
+      expect(evt.namespace).to eq :default
+      expect(evt.bucket).to eq "signups"
+    end
+
+    it "sets the data" do
+      data = { name: 'John Doe', email: 'j@d.com' }
+      evt = Sleek::Event.create_with_namespace(:ns, "buc", data)
+      expect(evt.data).to eq data
+    end
+  end
+end

data/spec/lib/sleek/filter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Sleek::Filter do
+  describe "#initialize" do
+    context "when valid operator is passed" do
+      it "does not raise an exception" do
+        expect { Sleek::Filter.new(:test, :eq, 1) }.to_not raise_exception ArgumentError
+      end
+    end
+
+    context "when invalid operator is passed" do
+      it "raises an exception" do
+        expect { Sleek::Filter.new(:test, :lol, 1) }.to raise_exception ArgumentError, "unsupported operator - lol"
+      end
+    end
+  end
+
+  describe "#apply" do
+    it "appleis the filter to the criteria" do
+      filter = Sleek::Filter.new(:test, :eq, 1)
+      criteria = stub('criteria')
+      criteria.should_receive(:eq).with("d.test" => 1)
+      filter.apply(criteria)
+    end
+  end
+end

data/spec/lib/sleek/interval_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Sleek::Interval do
+  describe "#initialize" do
+    it "transforms interval description into value" do
+      Sleek::Interval.should_receive(:interval_value).with(:hourly)
+      Sleek::Interval.new(:hourly, Sleek::Timeframe.new(Time.now.all_day))
+    end
+  end
+
+  describe "#timeframes" do
+    it "slices timeframe into interval-long timeframes" do
+      bd = Time.now.beginning_of_day
+      interval = Sleek::Interval.new(:hourly, Sleek::Timeframe.new(Time.now.all_day))
+      expect(interval.timeframes.count).to eq 23
+
+      23.times do |i|
+        subtf = interval.timeframes[i]
+        expect(subtf.start).to eq bd + 1.hour * i
+        expect(subtf.end).to eq bd + 1.hour * (i + 1)
+      end
+    end
+  end
+end

data/spec/lib/sleek/queries/average_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Average do
+  subject(:query) { Sleek::Queries::Average.new(:default, :purchases, target_property: "total") }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      events.should_receive(:avg).with("d.total").and_return(49_35)
+      expect(query.perform(events)).to eq 49_35
+    end
+  end
+end

data/spec/lib/sleek/queries/count_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Count do
+  subject(:query) { Sleek::Queries::Count.new(:default, :purchases) }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      events.should_receive(:count).and_return(42)
+      expect(query.perform(events)).to eq 42
+    end
+  end
+end

data/spec/lib/sleek/queries/count_unique_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Sleek::Queries::CountUnique do
+  subject(:query) { Sleek::Queries::CountUnique.new(:default, :purchases, target_property: "customer.id") }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      distinct_events = stub('distinct_events')
+      events.should_receive(:distinct).with("d.customer.id").and_return(distinct_events)
+      distinct_events.should_receive(:count).and_return(4)
+      expect(query.perform(events)).to eq 4
+    end
+  end
+end

data/spec/lib/sleek/queries/maximum_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Maximum do
+  subject(:query) { Sleek::Queries::Maximum.new(:default, :purchases, target_property: "total") }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      events.should_receive(:max).with("d.total").and_return(199_99)
+      expect(query.perform(events)).to eq 199_99
+    end
+  end
+end

data/spec/lib/sleek/queries/minimum_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Minimum do
+  subject(:query) { Sleek::Queries::Minimum.new(:default, :purchases, target_property: "total") }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      events.should_receive(:min).with("d.total").and_return(19_99)
+      expect(query.perform(events)).to eq 19_99
+    end
+  end
+end