timeframeable 0.0.1 → 0.1.0

data/README.md

@@ -19,21 +19,52 @@ Or install it yourself as:
 
 ## Usage
 
-Inject dates from ```params[:start]``` and ```params[:end]``` or their default values into ```@timeframe.start``` and ```@timeframe.end```:
+### Controller module
 
-    timeframeable :defaults => [:beginning_of_month, :now]
+Typical usage:
 
-Inject dates from ```params[:s]``` and ```params[:e]``` or their default values into ```@timeframe.start``` and ```@timeframe.end```:
+```ruby
+class FrontController < ApplicationController
+  include Timeframeable::Controller
+  timeframeable
+```
 
-    timeframeable :defaults => [:beginning_of_month, :now], :start_key => :s, :end_key => :e
+This will inject dates from `params[:start]` and `params[:end]` into `@timeframe.start` and `@timeframe.end`. `nil` will be used if parameter was not found. You can specify default values to avoid this:
 
-Inject dates from ```params[:start]``` and ```params[:end]``` or their default values into ```@timeframe.start``` and ```@timeframe.end```, and inject dates from ```params[:s]``` and ```params[:e]``` or their default values into ```@tf.start``` and ```@tf.end```:
+```ruby
+  timeframeable :defaults => [:beginning_of_month, :now]
+```
 
-    timeframeable :defaults => [:beginning_of_month, :now]
-    timeframeable :defaults => [:beginning_of_month, :now], :start_key => :s, :end_key => :e, :variable => :'@tf'
+You can specify keys to seek at params hash:
+
+```ruby
+  timeframeable :defaults => [:beginning_of_month, :now],
+    :start_key => :s,
+    :end_key   => :e
+```
+
+Or even specify instance variable to fill:
+
+```ruby
+  timeframeable :defaults => [:beginning_of_month, :now],
+    :start_key => :s,
+    :end_key   => :e,
+    :variable  => :tf
+```
+
+### ActiveRecord module
+
+```ruby
+class Model < ActiveRecord::Base
+  include Timeframeable::Scope
+end
+
+Model.timeframe(:created_at, @timeframe).count
+```
 
 ## TODO
-If there will be such a need, it may be usefull to add ```:start_value``` and ```:end_value``` lambda options, which will extract appropriate values from ```params``` bypassing ```:start_key``` and ```:end_key```.
+
+It might be usefull to add `:start_value` and `:end_value` lambda options, which will extract appropriate values from `params` bypassing `:start_key` and `:end_key`.
 
 ## Contributing
 

data/lib/timeframeable.rb

@@ -6,40 +6,13 @@ require 'active_support/core_ext/date/conversions'
 require 'active_support/core_ext/time/calculations'
 require 'active_support/core_ext/date_time/calculations'
 require 'active_support/core_ext/date_time/conversions'
+require 'timeframeable/controller'
+require 'timeframeable/scope'
 
 module Timeframeable
-  extend ActiveSupport::Concern
 
   Timeframe = Struct.new(:start, :end)
 
-  module ClassMethods
-    def timeframeable(options={})
-      raise 'Timeframe defaults not defined' if options[:defaults].blank?
-      raise 'Invalid Timeframe defaults' unless options[:defaults].size == 2
-
-      options = options.dup
-
-      options[:start_key] ||= :start
-      options[:end_key]   ||= :end
-      options[:variable]  ||= :'@timeframe'
-      options[:defaults] = options[:defaults].map do |x|
-        if x.is_a? Symbol
-          if x == :now
-            DateTime.now
-          else
-            DateTime.now.send(x)
-          end
-        else
-          x
-        end
-      end
-
-      before_filter do
-        set_timeframe options
-      end
-    end
-  end
-
   def self.parse_date(param, extrapolate=nil)
     return unless param
 
@@ -72,21 +45,13 @@ module Timeframeable
         else
       end
 
-      result
+      result.utc
     else
       begin
-        DateTime.parse(param.to_s)
+        DateTime.parse(param.to_s).utc
       rescue
         return
       end
     end
   end
-
-private
-
-  def set_timeframe(options)
-    start_date = Timeframeable.parse_date(params[options[:start_key]]) || options[:defaults][0].to_datetime
-    end_date   = Timeframeable.parse_date(params[options[:end_key]], :end) || options[:defaults][1].to_datetime
-    instance_variable_set options[:variable], Timeframe.new(start_date.utc, end_date.utc)
-  end
-end
+end

data/lib/timeframeable/controller.rb

@@ -0,0 +1,38 @@
+module Timeframeable
+  module Controller
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def timeframeable(options={})
+        options = options.dup
+        options[:start_key] ||= :start
+        options[:end_key]   ||= :end
+        options[:variable]  ||= :timeframe
+        options[:defaults]  ||= []
+        options[:defaults] = options[:defaults].map do |x|
+          if x.is_a? Symbol
+            if x == :now
+              DateTime.now.utc
+            else
+              DateTime.now.send(x).utc
+            end
+          else
+            x && x.to_datetime.utc
+          end
+        end
+
+        before_filter do
+          set_timeframe options
+        end
+      end
+    end
+
+  private
+
+    def set_timeframe(options)
+      start_date = Timeframeable.parse_date(params[options[:start_key]]) || options[:defaults][0]
+      end_date   = Timeframeable.parse_date(params[options[:end_key]], :end) || options[:defaults][1]
+      instance_variable_set :"@#{options[:variable]}", Timeframe.new(start_date, end_date)
+    end
+  end
+end

data/lib/timeframeable/scope.rb

@@ -0,0 +1,16 @@
+module Timeframeable
+  module Scope
+    extend ActiveSupport::Concern
+
+    included do
+      class_eval do
+        scope :timeframe, lambda {|field, timeframe|
+          scope = scoped
+          scope = scope.where(arel_table[field].gteq(timeframe.start)) if timeframe.start
+          scope = scope.where(arel_table[field].lteq(timeframe.end))   if timeframe.end
+          scope
+        }
+      end
+    end
+  end
+end

data/lib/timeframeable/version.rb

@@ -1,3 +1,3 @@
 module Timeframeable
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/spec/lib/timeframeable/controller_spec.rb

@@ -0,0 +1,145 @@
+require_relative '../../spec_helper'
+require 'timeframeable'
+require 'timecop'
+
+describe Timeframeable::Controller do
+
+  def assert_utc(date)
+    case date
+      when DateTime
+        date.utc?.should be_true
+      when Struct
+        date.start.utc?.should be_true if date.start
+        date.end.utc?.should be_true if date.end
+      else
+        raise "Unknown object: #{date}"
+    end
+    date
+  end
+
+  it 'has dedicated data structure' do
+    date = Timeframeable::Timeframe.new(1, 2)
+    date.start.should == 1
+    date.end.should   == 2
+  end
+
+  describe 'Timeframeable.parse_date' do
+
+    it 'uses DateTime.parse for strings' do
+      date = DateTime.now.change(:usec => 0)
+      assert_utc(Timeframeable.parse_date(date.to_s)).should == date
+    end
+
+    it 'suppress exceptions on invalid strings' do
+      Timeframeable.parse_date('trololo').should be_nil
+    end
+
+    it 'accepts composite param' do
+      assert_utc(Timeframeable.parse_date({:year => 2013, :month => 1, :day => 15})).should ==
+        DateTime.new(2013, 1, 15)
+    end
+
+    it 'accepts incomplete composite param' do
+      assert_utc(Timeframeable.parse_date({:year => 2013, :month => 1})).should ==
+        DateTime.new(2013, 1, 1)
+      assert_utc(Timeframeable.parse_date({:month => 1})).should ==
+        DateTime.new(Date.today.year, 1, 1)
+    end
+
+    it 'extrapolates range to its end' do
+      assert_utc(Timeframeable.parse_date({:year => 2013, :month => 1, :day => 15}, :end)).should ==
+        DateTime.new(2013, 1, 15).end_of_day
+      assert_utc(Timeframeable.parse_date({:year => 2013, :month => 1}, :end)).should ==
+        DateTime.new(2013, 1, 1).end_of_month.end_of_day
+    end
+  end
+
+  context 'controller' do
+    let(:controller) { Class.new.new }
+    let(:default_options) {
+      {
+        :start_key => :start,
+        :end_key => :end,
+        :variable => :timeframe,
+        :defaults => [DateTime.now.beginning_of_month, DateTime.now]
+      }
+    }
+
+    before do
+      controller.class.class_eval do
+        include Timeframeable::Controller
+      end
+      mock(controller.class).before_filter().at_least(1) {|block| controller.instance_eval(&block) }
+    end
+
+    describe 'Controller.timeframeable' do
+
+      it 'timeframes without options' do
+        default_options[:defaults] = []
+        mock(controller).set_timeframe(default_options)
+        controller.class.timeframeable
+      end
+
+      it 'timeframes with default options' do
+        options_given = {:defaults => default_options[:defaults]}
+        options_got = default_options
+        mock(controller).set_timeframe(options_got)
+        controller.class.timeframeable(options_given)
+      end
+
+      it 'timeframes with symbol options' do
+        Timecop.freeze(DateTime.now) do
+          options_given = {:defaults => [:beginning_of_month, :now]}
+          options_got = default_options.merge(:defaults => [DateTime.now.beginning_of_month, DateTime.now])
+          mock(controller).set_timeframe(options_got)
+          controller.class.timeframeable(options_given)
+        end
+      end
+
+      it 'timeframes with custom options' do
+        Timecop.freeze(DateTime.now) do
+          options_given = {:defaults => [:beginning_of_month, :now], :start_key => :s, :end_key => :e, :variable => :'@tf'}
+          options_got = default_options.merge(options_given).merge(:defaults => [DateTime.now.beginning_of_month, DateTime.now])
+          mock(controller).set_timeframe(options_got)
+          controller.class.timeframeable(options_given)
+        end
+      end
+    end
+
+    describe 'Controller#set_timeframe' do
+      it 'falls back to nils' do
+        stub(controller).params{ {} }
+        default_options[:defaults] = []
+        controller.class.timeframeable default_options
+        assert_utc(controller.instance_variable_get(:"@#{default_options[:variable]}")).should ==
+          Timeframeable::Timeframe.new(nil, nil)
+      end
+
+      it 'falls back to default values' do
+        stub(controller).params{ {} }
+        controller.class.timeframeable default_options
+        assert_utc(controller.instance_variable_get(:"@#{default_options[:variable]}")).should ==
+          Timeframeable::Timeframe.new(*default_options[:defaults])
+      end
+
+      it 'uses actual params' do
+        dates = default_options[:defaults].map{|d| d.prev_month.utc.change(:usec => 0) }
+        stub(controller).params{ Hash[[:start, :end].zip(dates.map(&:to_s))] }
+        controller.class.timeframeable default_options
+        assert_utc(controller.instance_variable_get(:"@#{default_options[:variable]}")).should ==
+          Timeframeable::Timeframe.new(*dates)
+      end
+
+      it 'allows multiple timeframes to be set' do
+        stub(controller).params{ {} }
+        other_options = default_options.merge(:variable => :test, :defaults => default_options[:defaults].map(&:prev_month))
+        controller.class.timeframeable default_options
+        controller.class.timeframeable other_options
+        assert_utc(controller.instance_variable_get(:"@#{default_options[:variable]}")).should ==
+          Timeframeable::Timeframe.new(*default_options[:defaults])
+        assert_utc(controller.instance_variable_get(:"@#{other_options[:variable]}")).should ==
+          Timeframeable::Timeframe.new(*other_options[:defaults])
+      end
+    end
+  end
+end

data/spec/lib/timeframeable/scope_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../../spec_helper'
+require 'timeframeable'
+require 'active_record'
+
+describe Timeframeable::Scope do
+
+  before :all do
+    module App end
+    ActiveRecord::Base.establish_connection(
+      :adapter  => 'sqlite3',
+      :database => ':memory:'
+    )
+  end
+
+  before do
+    App.send(:remove_const, :Model) if App.const_defined?(:Model)
+    class App::Model < ActiveRecord::Base
+      include Timeframeable::Scope
+    end
+  end
+
+  it 'has scope that accepts timeframe' do
+    timeframe = Timeframeable::Timeframe.new(DateTime.parse('2013-01-01 00:00:00'), DateTime.parse('2013-01-31 23:59:59'))
+    timeframe_r = timeframe.clone
+    timeframe_r.start = nil
+    timeframe_l = timeframe.clone
+    timeframe_l.end = nil
+    App::Model.timeframe(:date, timeframe).to_sql.should ==
+      %(SELECT "models".* FROM "models"  WHERE ("models"."date" >= '2013-01-01 00:00:00') AND ("models"."date" <= '2013-01-31 23:59:59'))
+    App::Model.timeframe(:date, timeframe_r).to_sql.should ==
+      %(SELECT "models".* FROM "models"  WHERE ("models"."date" <= '2013-01-31 23:59:59'))
+    App::Model.timeframe(:date, timeframe_l).to_sql.should ==
+      %(SELECT "models".* FROM "models"  WHERE ("models"."date" >= '2013-01-01 00:00:00'))
+  end
+end

data/timeframeable.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_dependency 'activesupport'
+  gem.add_development_dependency 'activerecord'
+  gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rr'
   gem.add_development_dependency 'timecop'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timeframeable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -27,6 +27,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -88,8 +120,11 @@ files:
 - README.md
 - Rakefile
 - lib/timeframeable.rb
+- lib/timeframeable/controller.rb
+- lib/timeframeable/scope.rb
 - lib/timeframeable/version.rb
-- spec/lib/timeframeable_spec.rb
+- spec/lib/timeframeable/controller_spec.rb
+- spec/lib/timeframeable/scope_spec.rb
 - spec/spec_helper.rb
 - timeframeable.gemspec
 homepage: ''
@@ -117,6 +152,7 @@ signing_key:
 specification_version: 3
 summary: datetime range extractor
 test_files:
-- spec/lib/timeframeable_spec.rb
+- spec/lib/timeframeable/controller_spec.rb
+- spec/lib/timeframeable/scope_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/lib/timeframeable_spec.rb

@@ -1,111 +0,0 @@
-require_relative '../spec_helper'
-require 'timeframeable'
-require 'timecop'
-
-describe Timeframeable do
-
-  it 'has dedicated data structure' do
-    data = Timeframeable::Timeframe.new(1, 2)
-    data.start.should == 1
-    data.end.should   == 2
-  end
-
-  describe 'Timeframeable.parse_date' do
-
-    it 'uses DateTime.parse for strings' do
-      data = DateTime.now.change(:usec => 0)
-      Timeframeable.parse_date(data.to_s).should == data
-    end
-
-    it 'suppress exceptions on invalid strings' do
-      Timeframeable.parse_date('trololo').should be_nil
-    end
-
-    it 'accepts composite param' do
-      Timeframeable.parse_date({:year => 2013, :month => 1, :day => 15}).should == DateTime.new(2013, 1, 15)
-    end
-
-    it 'extrapolates range to its end' do
-      Timeframeable.parse_date({:year => 2013, :month => 1, :day => 15}, :end).should == DateTime.new(2013, 1, 15).end_of_day
-      Timeframeable.parse_date({:year => 2013, :month => 1}, :end).should == DateTime.new(2013, 1, 1).end_of_month.end_of_day
-    end
-  end
-
-  context 'controller' do
-    let(:controller) { Class.new.new }
-    let(:default_options) {
-      {
-        :start_key => :start,
-        :end_key => :end,
-        :variable => :'@timeframe',
-        :defaults => [DateTime.now.beginning_of_month, DateTime.now]
-      }
-    }
-
-    before do
-      controller.class.class_eval do
-        include Timeframeable
-      end
-    end
-
-    describe 'Controller.timeframeable' do
-
-      before do
-        mock(controller.class).before_filter() {|block| controller.instance_eval(&block) }
-      end
-
-      it 'timeframes with default options' do
-        options_given = {:defaults => default_options[:defaults]}
-        options_got = default_options
-        mock(controller).set_timeframe(options_got)
-        controller.class.timeframeable(options_given)
-      end
-
-      it 'timeframes with symbol options' do
-        Timecop.freeze(DateTime.now) do
-          options_given = {:defaults => [:beginning_of_month, :now]}
-          options_got = default_options.merge(:defaults => [DateTime.now.beginning_of_month, DateTime.now])
-          mock(controller).set_timeframe(options_got)
-          controller.class.timeframeable(options_given)
-        end
-      end
-
-      it 'timeframes with custom options' do
-        Timecop.freeze(DateTime.now) do
-          options_given = {:defaults => [:beginning_of_month, :now], :start_key => :s, :end_key => :e, :variable => :'@tf'}
-          options_got = default_options.merge(options_given).merge(:defaults => [DateTime.now.beginning_of_month, DateTime.now])
-          mock(controller).set_timeframe(options_got)
-          controller.class.timeframeable(options_given)
-        end
-      end
-    end
-
-    describe 'Controller#set_timeframe' do
-      it 'falls back to default values' do
-        stub(controller).params{ {} }
-        controller.send :set_timeframe, default_options
-        controller.instance_variable_get(default_options[:variable]).should ==
-          Timeframeable::Timeframe.new(*default_options[:defaults])
-      end
-
-      it 'uses actual params' do
-        dates = default_options[:defaults].map{|d| d.prev_month.utc.change(:usec => 0) }
-        stub(controller).params{ Hash[[:start, :end].zip(dates.map(&:to_s))] }
-        controller.send :set_timeframe, default_options
-        controller.instance_variable_get(default_options[:variable]).should ==
-          Timeframeable::Timeframe.new(*dates)
-      end
-
-      it 'allows multiple timeframes to be set' do
-        stub(controller).params{ {} }
-        other_options = default_options.merge(:variable => :'@test', :defaults => default_options[:defaults].map(&:prev_month))
-        controller.send :set_timeframe, default_options
-        controller.send :set_timeframe, other_options
-        controller.instance_variable_get(default_options[:variable]).should ==
-          Timeframeable::Timeframe.new(*default_options[:defaults])
-        controller.instance_variable_get(other_options[:variable]).should ==
-          Timeframeable::Timeframe.new(*other_options[:defaults])
-      end
-    end
-  end
-end