redistat 0.0.1

data/lib/redistat/event.rb

@@ -0,0 +1,94 @@
+module Redistat
+  class Event
+    include Database
+    
+    attr_reader :id
+    attr_reader :key
+    
+    attr_accessor :stats
+    attr_accessor :meta
+    attr_accessor :options
+    
+    def initialize(scope, label = nil, date = nil, stats = {}, options = {}, meta = {}, is_new = true)
+      @options = default_options.merge(options)
+      @key = Key.new(scope, label, date, @options)
+      @stats = stats ||= {}
+      @meta = meta ||= {}
+      @new = is_new
+    end
+
+    def default_options
+      { :depth => :hour, :store_event => false }
+    end
+    
+    def new?
+      @new
+    end
+    
+    def date
+      @key.date
+    end
+    
+    def date=(input)
+      @key.date = input
+    end
+    
+    def scope
+      @key.scope
+    end
+    
+    def scope=(input)
+      @key.scope = input
+    end
+    
+    def label
+      @key.label
+    end
+    
+    def label_hash
+      @key.label_hash
+    end
+    
+    def label=(input)
+      @key.label = input
+    end
+
+    def next_id
+      db.incr("#{self.scope}#{KEY_NEXT_ID}")
+    end
+    
+    def save
+      return false if !self.new?
+      Summary.update_all(@key, @stats, depth_limit)
+      if @options[:store_event]
+        @id = self.next_id
+        db.hmset("#{self.scope}#{KEY_EVENT}#{@id}",
+                 "scope", self.scope,
+                 "label", self.label,
+                 "date", self.date.to_time.to_s,
+                 "stats", self.stats.to_json,
+                 "meta", self.meta.to_json,
+                 "options", self.options.to_json)
+        db.sadd("#{self.scope}#{KEY_EVENT_IDS}", @id)
+      end
+      @new = false
+      self
+    end
+    
+    def depth_limit
+      @options[:depth] ||= @key.depth
+    end
+    
+    def self.create(*args)
+      self.new(*args).save
+    end
+    
+    def self.find(scope, id)
+      event = db.hgetall "#{scope}#{KEY_EVENT}#{id}"
+      return nil if event.size == 0
+      self.new( event["scope"], event["label"], event["date"], JSON.parse(event["stats"]),
+                JSON.parse(event["meta"]), JSON.parse(event["options"]), false )
+    end
+    
+  end
+end

data/lib/redistat/finder.rb

@@ -0,0 +1,165 @@
+module Redistat
+  class Finder
+    include Database
+    
+    attr_reader :options
+    
+    def initialize(options = {})
+      @options = options
+    end
+    
+    def valid_options?
+      return true if !@options[:scope].blank? && !@options[:label].blank? && !@options[:from].blank? && !@options[:till].blank?
+      false
+    end
+    
+    def find(options = {})
+      @options.merge!(options)
+      raise InvalidOptions.new if !valid_options?
+      if @options[:interval].nil? || !@options[:interval]
+        find_by_magic
+      else
+        find_by_interval
+      end
+    end
+    
+    def find_by_interval(options = {})
+      @options.merge!(options)
+      raise InvalidOptions.new if !valid_options?
+      key = build_key
+      col = Collection.new(@options)
+      col.total = Result.new(@options)
+      build_date_sets.each do |set|
+        set[:add].each do |date|
+          result = Result.new
+          result.date = Date.new(date).to_time
+          db.hgetall("#{key.prefix}#{date}").each do |k, v|
+            result[k] = v
+            col.total.set_or_incr(k, v.to_i)
+          end
+          col << result
+        end
+      end
+      col
+    end
+    
+    def find_by_magic(options = {})
+      @options.merge!(options)
+      raise InvalidOptions.new if !valid_options?
+      key = Key.new(@options[:scope], @options[:label])
+      col = Collection.new(@options)
+      col.total = Result.new(@options)
+      col << col.total
+      build_date_sets.each do |set|
+        sum = Result.new
+        sum = summarize_add_keys(set[:add], key, sum)
+        sum = summarize_rem_keys(set[:rem], key, sum)
+        sum.each do |k, v|
+          col.total.set_or_incr(k, v.to_i)
+        end
+      end
+      col
+    end
+    
+    def build_date_sets
+      Finder::DateSet.new(@options[:from], @options[:till], @options[:depth], @options[:interval])
+    end
+    
+    def build_key
+      Key.new(@options[:scope], @options[:label])
+    end
+    
+    def summarize_add_keys(sets, key, sum)
+      sets.each do |date|
+        db.hgetall("#{key.prefix}#{date}").each do |k, v|
+          sum.set_or_incr(k, v.to_i)
+        end
+      end
+      sum
+    end
+    
+    def summarize_rem_keys(sets, key, sum)
+      sets.each do |date|
+        db.hgetall("#{key.prefix}#{date}").each do |k, v|
+          sum.set_or_incr(k, -v.to_i)
+        end
+      end
+      sum
+    end
+    
+    class << self
+    
+      def find(*args)
+        new.find(*args)
+      end
+      
+      def scope(scope)
+        new.scope(scope)
+      end
+      
+      def label(label)
+        new.label(label)
+      end
+      
+      def dates(from, till)
+        new.dates(from, till)
+      end
+      alias :date :dates
+      
+      def from(date)
+        new.from(date)
+      end
+      
+      def till(date)
+        new.till(date)
+      end
+      alias :untill :till
+      
+      def depth(unit)
+        new.depth(unit)
+      end
+      
+      def interval(unit)
+        new.interval(unit)
+      end
+      
+    end
+    
+    def scope(scope)
+      @options[:scope] = scope
+      self
+    end
+    
+    def label(label)
+      @options[:label] = label
+      self
+    end
+    
+    def dates(from, till)
+      from(from).till(till)
+    end
+    alias :date :dates
+    
+    def from(date)
+      @options[:from] = date
+      self
+    end
+    
+    def till(date)
+      @options[:till] = date
+      self
+    end
+    alias :until :till
+    
+    def depth(unit)
+      @options[:depth] = unit
+      self
+    end
+    
+    def interval(unit)
+      @options[:interval] = unit
+      self
+    end
+    
+  end
+end

data/lib/redistat/finder/date_set.rb

@@ -0,0 +1,95 @@
+module Redistat
+  class Finder
+    class DateSet < Array
+      
+      def initialize(start_date = nil, end_date = nil, depth = nil, interval = false)
+        if !start_date.nil? && !end_date.nil?
+          find_date_sets(start_date, end_date, depth, interval)
+        end
+      end
+
+      def find_date_sets(start_date, end_date, depth = nil, interval = false)
+        start_date = start_date.to_time if start_date.is_a?(::Date)
+        end_date = end_date.to_time if end_date.is_a?(::Date)
+        if !interval
+          find_date_sets_by_magic(start_date, end_date, depth)
+        else
+          find_date_sets_by_interval(start_date, end_date, depth)
+        end
+      end
+
+      private
+
+      def find_date_sets_by_magic(start_date, end_date, depth = nil)
+        depth ||= :hour
+        depths = Date::DEPTHS[Date::DEPTHS.index(:year), Date::DEPTHS.index(depth)+1].reverse
+        depths.each_with_index do |d, i|
+          sets = [find_start_keys_for(d, start_date, end_date, (i == 0))]
+          sets << find_end_keys_for(d, start_date, end_date, (i == 0))
+          sets.each do |set|
+            self << set if set != { :add => [], :rem => [] }
+          end
+        end
+        self
+      end
+
+      def find_date_sets_by_interval(start_date, end_date, depth, inclusive = true)
+        depth ||= :hour
+        self << { :add => start_date.map_beginning_of_each(depth, :include_start => inclusive, :include_end => inclusive).until(end_date) { |t| t.to_rs.to_s(depth) }, :rem => [] }
+      end
+
+      def find_start_keys_for(unit, start_date, end_date, lowest_depth = false)
+        return find_start_year_for(start_date, end_date, lowest_depth) if unit == :year
+        index = Date::DEPTHS.index(unit)
+        nunit = Date::DEPTHS[(index > 0) ? index-1 : index]
+        if start_date < start_date.round(nunit) || start_date.next(nunit).beginning_of(nunit) > end_date.beginning_of(nunit)
+          add = []
+          start_date.beginning_of_each(unit, :include_start => lowest_depth).until(start_date.end_of(nunit)) do |t|
+            add << t.to_rs.to_s(unit) if t < end_date.beginning_of(unit)
+          end
+          { :add => add, :rem => [] }
+        else
+          { :add => [start_date.beginning_of(nunit).to_rs.to_s(nunit)],
+            :rem => start_date.beginning_of(nunit).map_beginning_of_each(unit, :include_start => true, :include_end => !lowest_depth).until(start_date) { |t| t.to_rs.to_s(unit) } }
+        end
+      end
+
+      def find_end_keys_for(unit, start_date, end_date, lowest_depth = false)
+        return find_end_year_for(start_date, end_date, lowest_depth) if unit == :year
+        index = Date::DEPTHS.index(unit)
+        nunit = Date::DEPTHS[(index > 0) ? index-1 : index]
+        has_nunit = end_date.prev(nunit).beginning_of(nunit) >= start_date.beginning_of(nunit)
+        nearest_nunit = end_date.round(nunit)
+        if end_date >= nearest_nunit && has_nunit
+          add = []
+          end_date.beginning_of(nunit).beginning_of_each(unit, :include_start => true, :include_end => lowest_depth).until(end_date) do |t|
+            add << t.to_rs.to_s(unit) if t > start_date.beginning_of(unit)
+          end
+          { :add => add, :rem => [] }
+        elsif has_nunit
+          { :add => [end_date.beginning_of(nunit).to_rs.to_s(nunit)], 
+            :rem => end_date.map_beginning_of_each(unit, :include_start => !lowest_depth).until(end_date.end_of(nunit)) { |t| t.to_rs.to_s(unit) } }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+
+      def find_start_year_for(start_date, end_date, lowest_depth = false)
+        if start_date.years_since(1).beginning_of_year < end_date.beginning_of_year
+          { :add => start_date.map_beginning_of_each_year(:include_end => lowest_depth).until(end_date) { |t| t.to_rs.to_s(:year) }, :rem => [] }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+
+      def find_end_year_for(start_date, end_date, lowest_depth = false)
+        if lowest_depth
+          { :add => [end_date.beginning_of_year.to_rs.to_s(:year)], :rem => [] }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+      
+    end
+  end
+end

data/lib/redistat/key.rb

@@ -0,0 +1,54 @@
+module Redistat
+  class Key
+    
+    attr_accessor :scope
+    attr_accessor :date
+    attr_accessor :options
+    
+    def initialize(scope, label = nil, date = nil, options = {})
+      @scope = scope
+      self.label = label if !label.nil?
+      self.date = date ||= Time.now
+      @options = default_options.merge(options ||= {})
+    end
+    
+    def default_options
+      { :depth => :day }
+    end
+    
+    def prefix
+      key = "#{@scope}"
+      key << "/" + ((@options[:label_hash].nil? || @options[:label_hash] == true) ? @label.hash : @label.name) if !label.nil?
+      key << ":"
+      key
+    end
+    
+    def date=(input)
+      @date = (input.instance_of?(Redistat::Date)) ? input : Date.new(input) # Redistat::Date, not ::Date
+    end
+    
+    def depth
+      @options[:depth]
+    end
+    
+    def label
+      @label.name
+    end
+    
+    def label_hash
+      @label.hash
+    end
+    
+    def label=(input)
+      @label = (input.instance_of?(Redistat::Label)) ? input : Label.create(input)
+    end
+    
+    def to_s(depth = nil)
+      depth ||= @options[:depth]
+      key = self.prefix
+      key << @date.to_s(depth)
+      key
+    end
+    
+  end
+end

data/lib/redistat/label.rb

@@ -0,0 +1,27 @@
+module Redistat
+  class Label
+    include Database
+    
+    attr_reader :name
+    attr_reader :hash
+    
+    def initialize(str)
+      @name = str.to_s
+      @hash = Digest::SHA1.hexdigest(@name)
+    end
+    
+    def save
+      @saved = (db.set("#{KEY_LEBELS}#{@hash}", @name) == "OK")
+      self
+    end
+    
+    def saved?
+      @saved ||= false
+    end
+    
+    def self.create(name)
+      self.new(name).save
+    end
+    
+  end
+end

data/lib/redistat/model.rb

@@ -0,0 +1,50 @@
+module Redistat
+  module Model
+    
+    def self.included(base)
+      base.extend(self)
+    end
+    
+    def store(label, stats = {}, date = nil, meta = {}, opts = {})
+      Event.new(name, label, date, stats, options.merge(opts), meta).save
+    end
+    alias :event :store
+    
+    def fetch(label, from, till, opts = {})
+      Finder.find({
+        :scope => name,
+        :label => label,
+        :from  => from,
+        :till  => till
+      }.merge(options.merge(opts)))
+    end
+    alias :find :fetch
+    
+    def depth(depth = nil)
+      if !depth.nil?
+        options[:depth] = depth
+      else
+        options[:depth] || nil
+      end
+    end
+    
+    def store_event(boolean = nil)
+      if !boolean.nil?
+        options[:store_event] = boolean
+      else
+        options[:store_event] || nil
+      end
+    end
+    
+    def options
+      @options ||= {}
+    end
+    
+    private
+    
+    def name
+      @name ||= self.to_s
+    end
+    
+  end
+end