pacecar 1.1.8

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008, Matt Jankowski & thoughtbot, inc.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,202 @@
+== Pacecar
+
+Pacecar adds named_scope methods and other common functionality to ActiveRecord classes via database column introspection.
+
+Pacecar automatically includes the Pacecar::Helpers module into all ActiveRecord::Base classes.
+
+To get all Pacecar functionality, you need to "include Pacecar" in your class.
+
+To get some subset (for example, only the state functionality), you can do something like "include Pacecar::State" to get only the module(s) you want.
+
+== Usage
+
+Assuming a database schema...
+
+  class CreateSchema < ActiveRecord::Migration
+    def self.up
+      create_table :users, :force => true do |t|
+        t.boolean :admin, :default => false, :null => false
+        t.datetime :approved_at
+        t.datetime :rejected_at
+        t.string :first_name
+        t.string :last_name
+        t.text :description
+        t.timestamps
+      end
+      create_table :posts, :force => true do |t|
+        t.string :owner_type
+        t.integer :owner_id
+        t.string :publication_state
+        t.string :post_type
+        t.timestamps
+      end
+      create_table :comments, :force => true do |t|
+        t.integer :user_id
+        t.text :description
+        t.timestamps
+      end
+    end
+  end
+
+And some basic model declarations...
+
+  class User < ActiveRecord::Base
+    include Pacecar
+    has_many :posts, :as => :owner
+    has_many :comments
+    has_many :articles
+    has_ranking :comments
+    has_recent_records :comments
+    has_recent_records :articles, :comments
+  end
+
+  class Post < ActiveRecord::Base
+    include Pacecar
+    PUBLICATION_STATES = %w(Draft Submitted Rejected Accepted)
+    TYPES = %w(Free Open Private Anonymous PostModern)
+    belongs_to :owner, :polymorphic => true
+    has_state :publication_state
+    has_state :post_type, :with => TYPES
+    has_polymorph :owner
+  end
+
+  class Comment < ActiveRecord::Base
+    include Pacecar
+    belongs_to :user
+  end
+
+  class Article < ActiveRecord::Base
+    belongs_to :user
+  end
+
+= All columns
+
+Records where approved_at is not null, or where it is null...
+
+  User.approved_at_present
+  User.approved_at_missing
+
+Records where first_name is not null, or where it is null...
+
+  User.first_name_present
+  User.first_name_missing
+
+Records ordered by first_name (default to 'asc', can specify to override)...
+
+  User.by_first_name
+  User.by_first_name(:asc)
+  User.by_first_name(:desc)
+
+Records where an attribute matches a search term (column LIKE "%term%")...
+
+  User.first_name_matches('John')
+
+Records where an attribute starts or ends with a search term...
+
+  User.first_name_starts_with('A')
+  User.first_name_ends_with('a')
+
+Records where any non-state text or string column matches term...
+
+  User.search_for('test')
+
+Records where any of a list of columns match the term...
+
+  User.search_for 'test', :on => [:first_name, :last_name]
+
+Records where all of a list of columns match the term...
+
+  User.search_for 'test', :on => [:first_name, :last_name], :require => :all
+
+= Boolean columns
+
+Records that are all admins or non-admins...
+
+  User.admin
+  User.not_admin
+
+The "balance" (count of true minus false for column in question)...
+
+  User.admin_balance
+
+= Datetime columns
+
+Records approved before or after certain times...
+
+  User.approved_at_before(5.days.ago)
+  User.approved_at_after(4.weeks.ago)
+
+Records with approved_at in the past or future...
+
+  User.approved_at_in_past
+  User.approved_at_in_future
+
+Records with approved_at inside or outside of two times...
+
+  User.approved_at_inside(10.days.ago, 1.day.ago)
+  User.approved_at_outside(2.days.ago, 1.day.ago)
+
+Records with certain year, month or day...
+
+  User.approved_at_in_year(2000)
+  User.approved_at_in_month(01)
+  User.approved_at_in_day(01)
+
+Records with a duration (time delta between two columns) of, over or under a certain number of days...
+
+  User.with_duration_of(14, :approved_at, :rejected_at)
+  User.with_duration_over(14, :approved_at, :rejected_at)
+  User.with_duration_under(14, :approved_at, :rejected_at)
+
+= Polymorphic relationships
+
+Records which have an owner_type of User...
+
+  Post.for_owner_type(User)
+
+= Associations
+
+Records with the most and least associated records...
+
+  User.maximum_comments
+  User.minimum_comments
+
+Records with associated records since a certain time...
+
+  User.recent_comments_since(2.days.ago)
+  User.recent_comments_and_posts_since(3.days.ago)
+  User.recent_comments_or_posts_since(4.days.ago)
+
+= State columns
+
+Records which are in a particular state, or not in a state...
+
+  Post.publication_state_draft
+  Post.post_type_not_open
+
+Query methods on instances to check state...
+
+  Post.first.publication_state_draft?
+  Post.last.post_type_not_open?
+
+= Limits
+
+First x records...
+
+  User.limited(10)
+
+= Named scopes
+
+Because these are all named_scope, you can combine them.
+
+To get all users that have a first_name set, who are admins and approved more than 2 weeks ago, ordered by their first name...
+
+  User.first_name_present.admin.approved_at_before(2.weeks.ago).by_first_name
+
+To get the top 10 commenters...
+
+  User.maximim_comments.limited(10)
+
+= License
+
+Pacecar is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/init.rb

@@ -0,0 +1 @@
+require 'pacecar'

data/lib/pacecar.rb

@@ -0,0 +1,32 @@
+require 'pacecar/associations'
+require 'pacecar/boolean'
+require 'pacecar/datetime'
+require 'pacecar/duration'
+require 'pacecar/helpers'
+require 'pacecar/limit'
+require 'pacecar/order'
+require 'pacecar/polymorph'
+require 'pacecar/presence'
+require 'pacecar/ranking'
+require 'pacecar/search'
+require 'pacecar/state'
+
+module Pacecar
+  def self.included(base)
+    base.class_eval do
+      include Pacecar::Associations
+      include Pacecar::Boolean
+      include Pacecar::Datetime
+      include Pacecar::Duration
+      include Pacecar::Limit
+      include Pacecar::Order
+      include Pacecar::Polymorph
+      include Pacecar::Presence
+      include Pacecar::Ranking
+      include Pacecar::Search
+      include Pacecar::State
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Pacecar::Helpers

data/lib/pacecar/associations.rb

@@ -0,0 +1,39 @@
+module Pacecar
+  module Associations
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_recent_records(*names)
+        names.each do |name|
+          named_scope "recent_#{name}_since".to_sym, lambda { |since|
+            {
+              :conditions => [conditions_for_name(name), { :since_time => since }]
+            }
+          }
+        end
+        unless names.first == names.last
+          named_scope "recent_#{names.join('_or_')}_since".to_sym, lambda { |since|
+            {
+              :conditions => [names.collect { |name| conditions_for_name(name) }.join(' or '), { :since_time => since }]
+            }
+          }
+          named_scope "recent_#{names.join('_and_')}_since".to_sym, lambda { |since|
+            {
+              :conditions => [names.collect { |name| conditions_for_name(name) }.join(' and '), { :since_time => since }]
+            }
+          }
+        end
+      end
+
+      protected
+
+      def conditions_for_name(name)
+        "((select count(*) from \"#{name}\" where \"#{name}\".#{reflections[name].primary_key_name} = #{quoted_table_name}.id and \"#{name}\".created_at > :since_time) > 0)"
+      end
+
+    end
+  end
+end

data/lib/pacecar/boolean.rb

@@ -0,0 +1,34 @@
+module Pacecar
+  module Boolean
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_boolean_scopes
+        base.send :define_balance_count
+      end
+
+      protected
+
+      def define_boolean_scopes
+        boolean_column_names.each do |name|
+          named_scope name.to_sym, :conditions => ["#{quoted_table_name}.#{name} = ?", true]
+          named_scope "not_#{name}".to_sym, :conditions => ["#{quoted_table_name}.#{name} = ?", false]
+        end
+      end
+
+      def define_balance_count
+        boolean_column_names.each do |name|
+          self.class_eval %Q{
+            def self.#{name}_balance
+              #{name}.count - not_#{name}.count
+            end
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/pacecar/datetime.rb

@@ -0,0 +1,64 @@
+module Pacecar
+  module Datetime
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_datetime_scopes
+      end
+
+      protected
+
+      def define_datetime_scopes
+        datetime_column_names.each do |name|
+          define_before_after_scopes(name)
+          define_past_future_scopes(name)
+          define_inside_outside_scopes(name)
+          define_in_date_scopes(name)
+        end
+      end
+
+      def define_before_after_scopes(name)
+        named_scope "#{name}_before".to_sym, lambda { |time|
+          { :conditions => ["#{quoted_table_name}.#{name} < ?", time] }
+        }
+        named_scope "#{name}_after".to_sym, lambda { |time|
+          { :conditions => ["#{quoted_table_name}.#{name} > ?", time] }
+        }
+      end
+
+      def define_past_future_scopes(name)
+        named_scope "#{name}_in_past", lambda { 
+          { :conditions => ["#{quoted_table_name}.#{name} < ?", Time.now] }
+        }
+        named_scope "#{name}_in_future", lambda {
+          { :conditions => ["#{quoted_table_name}.#{name} > ?", Time.now] }
+        }
+      end
+
+      def define_inside_outside_scopes(name)
+        named_scope "#{name}_inside".to_sym, lambda { |start, stop|
+          { :conditions => ["#{quoted_table_name}.#{name} > ? and #{quoted_table_name}.#{name} < ?", start, stop] }
+        }
+        named_scope "#{name}_outside".to_sym, lambda { |start, stop|
+          { :conditions => ["#{quoted_table_name}.#{name} < ? and #{quoted_table_name}.#{name} > ?", start, stop] }
+        }
+      end
+
+      def define_in_date_scopes(name)
+        named_scope "#{name}_in_year".to_sym, lambda { |year|
+          { :conditions => ["year(#{quoted_table_name}.#{name}) = ?", year] }
+        }
+        named_scope "#{name}_in_month".to_sym, lambda { |month|
+          { :conditions => ["month(#{quoted_table_name}.#{name}) = ?", month] }
+        }
+        named_scope "#{name}_in_day".to_sym, lambda { |day|
+          { :conditions => ["day(#{quoted_table_name}.#{name}) = ?", day] }
+        }
+      end
+
+    end
+  end
+end

data/lib/pacecar/duration.rb

@@ -0,0 +1,28 @@
+module Pacecar
+  module Duration
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_duration_scopes
+      end
+
+      protected
+
+      def define_duration_scopes
+        named_scope :with_duration_of, lambda { |duration, start, stop|
+          { :conditions => ["datediff(#{quoted_table_name}.#{start}, #{quoted_table_name}.#{stop}) = ?", duration] }
+        }
+        named_scope :with_duration_over, lambda { |duration, start, stop|
+          { :conditions => ["datediff(#{quoted_table_name}.#{start}, #{quoted_table_name}.#{stop}) > ?", duration] }
+        }
+        named_scope :with_duration_under, lambda { |duration, start, stop|
+          { :conditions => ["datediff(#{quoted_table_name}.#{start}, #{quoted_table_name}.#{stop}) < ?", duration] }
+        }
+      end
+
+    end
+  end
+end

data/lib/pacecar/helpers.rb

@@ -0,0 +1,50 @@
+module Pacecar
+  module Helpers
+
+    mattr_accessor :options
+    self.options = {
+      :state_pattern => /_(type|state)$/i,
+      :default_limit => 10
+    }
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def safe_columns
+        begin
+          columns
+        rescue ActiveRecord::StatementInvalid # If the table does not exist
+          Array.new
+        end
+      end
+
+      def column_names_for_type(*types)
+        safe_columns.select { |column| types.include? column.type }.collect(&:name)
+      end
+
+      def column_names_without_type(*types)
+        safe_columns.select { |column| ! types.include? column.type }.collect(&:name)
+      end
+
+      def boolean_column_names
+        column_names_for_type :boolean
+      end
+
+      def datetime_column_names
+        column_names_for_type :datetime, :date
+      end
+
+      def text_and_string_column_names
+        column_names_for_type :text, :string
+      end
+
+      def non_state_text_and_string_columns
+        text_and_string_column_names.reject { |name| name =~ Pacecar::Helpers.options[:state_pattern] }
+      end
+
+    end
+  end
+end

data/lib/pacecar/limit.rb

@@ -0,0 +1,22 @@
+module Pacecar
+  module Limit
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_limit_scopes
+      end
+
+      protected
+
+      def define_limit_scopes
+        named_scope :limited, lambda { |*args|
+          { :limit => args.flatten.first || (defined?(per_page) ? per_page : Pacecar::Helpers.options[:default_limit]) }
+        }
+      end
+
+    end
+  end
+end

data/lib/pacecar/order.rb

@@ -0,0 +1,24 @@
+module Pacecar
+  module Order
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_order_scopes
+      end
+
+      protected
+
+      def define_order_scopes
+        safe_columns.collect(&:name).each do |name|
+          named_scope "by_#{name}".to_sym, lambda { |*args|
+            { :order => "#{quoted_table_name}.#{name} #{args.flatten.first || 'asc'}" }
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/pacecar/polymorph.rb

@@ -0,0 +1,17 @@
+module Pacecar
+  module Polymorph
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_polymorph(name)
+        named_scope "for_#{name}_type".to_sym, lambda { |type|
+          { :conditions => ["#{quoted_table_name}.#{name}_type = ?", type.to_s] }
+        }
+      end
+
+    end
+  end
+end

data/lib/pacecar/presence.rb

@@ -0,0 +1,23 @@
+module Pacecar
+  module Presence
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_presence_scopes
+      end
+
+      protected
+
+      def define_presence_scopes
+        column_names_without_type(:boolean).each do |name|
+          named_scope "#{name}_present".to_sym, :conditions => "#{quoted_table_name}.#{name} is not null"
+          named_scope "#{name}_missing".to_sym, :conditions => "#{quoted_table_name}.#{name} is null"
+        end
+      end
+
+    end
+  end
+end

data/lib/pacecar/ranking.rb

@@ -0,0 +1,26 @@
+module Pacecar
+  module Ranking
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_ranking(association)
+        define_ranking_scope association, :maximum, :desc
+        define_ranking_scope association, :minimum, :asc
+      end
+
+      protected
+
+      def define_ranking_scope(association, name, direction)
+        named_scope "#{name}_#{association}",
+        :joins => "inner join #{association} on #{association}.#{reflections[association].primary_key_name} = #{quoted_table_name}.#{primary_key}",
+        :select => "#{quoted_table_name}.*, count(#{quoted_table_name}.#{primary_key}) as #{association}_count",
+        :group => "#{association}.#{reflections[association].primary_key_name}",
+        :order => "#{association}_count #{direction}"
+      end
+
+    end
+  end
+end

data/lib/pacecar/search.rb

@@ -0,0 +1,42 @@
+module Pacecar
+  module Search
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.send :define_search_scopes
+        base.send :define_basic_search_scope
+      end
+
+      protected
+
+      def define_search_scopes
+        text_and_string_column_names.each do |name|
+          named_scope "#{name}_matches".to_sym, lambda { |query|
+            { :conditions => ["#{quoted_table_name}.#{name} like :query", { :query => "%#{query}%" }] }
+          }
+          named_scope "#{name}_starts_with".to_sym, lambda { |query|
+            { :conditions => ["#{quoted_table_name}.#{name} like :query", { :query => "#{query}%" }] }
+          }
+          named_scope "#{name}_ends_with".to_sym, lambda { |query|
+            { :conditions => ["#{quoted_table_name}.#{name} like :query", { :query => "%#{query}" }] }
+          }
+        end
+      end
+
+      def define_basic_search_scope
+        named_scope :search_for, lambda { |*args|
+          opts = args.extract_options!
+          query = args.flatten.first
+          columns = opts[:on] || non_state_text_and_string_columns
+          joiner = opts[:require].eql?(:all) ? 'and' : 'or'
+          match = columns.collect { |name| "#{quoted_table_name}.#{name} like :query" }.join(" #{joiner} ")
+          { :conditions => [match, { :query => "%#{query}%" } ] }
+        }
+      end
+
+    end
+  end
+end

data/lib/pacecar/state.rb

@@ -0,0 +1,36 @@
+module Pacecar
+  module State
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_state(*names)
+        opts = names.extract_options!
+        names.each do |name|
+          constant = opts[:with] || const_get(name.to_s.pluralize.upcase)
+          constant.each do |state|
+            named_scope "#{name}_#{state.downcase}".to_sym, :conditions => ["#{quoted_table_name}.#{name} = ?", state]
+            named_scope "#{name}_not_#{state.downcase}".to_sym, :conditions => ["#{quoted_table_name}.#{name} <> ?", state]
+            self.class_eval %Q{
+              def #{name}_#{state.downcase}?
+                #{name} == '#{state}'
+              end
+              def #{name}_not_#{state.downcase}?
+                #{name} != '#{state}'
+              end
+            }
+          end
+          named_scope "#{name}".to_sym, lambda { |state|
+            { :conditions => ["#{quoted_table_name}.#{name} = ?", state] }
+          }
+          named_scope "#{name}_not".to_sym, lambda { |state|
+            { :conditions => ["#{quoted_table_name}.#{name} <> ?", state] }
+          }
+        end
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: pacecar
+version: !ruby/object:Gem::Version 
+  version: 1.1.8
+platform: ruby
+authors: 
+- Matt Jankowski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-01 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Generated scopes for ActiveRecord classes.
+email: mjankowski@thoughtbot.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- init.rb
+- lib/pacecar/associations.rb
+- lib/pacecar/boolean.rb
+- lib/pacecar/datetime.rb
+- lib/pacecar/duration.rb
+- lib/pacecar/helpers.rb
+- lib/pacecar/limit.rb
+- lib/pacecar/order.rb
+- lib/pacecar/polymorph.rb
+- lib/pacecar/presence.rb
+- lib/pacecar/ranking.rb
+- lib/pacecar/search.rb
+- lib/pacecar/state.rb
+- lib/pacecar.rb
+- MIT-LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/thoughtbot/pacecar
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Pacecar adds named_scope methods to ActiveRecord classes via database column introspection.
+test_files: []
+