magic_scopes 1.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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,55 @@
+= MagicScopes
+
+MagicScopes is the scopes generator for ActiveRecord.
+
+It adds magic_scopes method (and nothing else) to ActiveRecord::Base.
+
+It depends on ActiveRecord and ActiveSupport and can be used without Rails.
+MagicScopes module should be included manually in the latter case.
+
+It also has support for the StateMachine gem and can generate scopes for states.
+
+
+== MagicScopes can generate these scopes:
+
+* <b>with</b> and <b>without</b> options will generate scopes such as <b>with_rating</b>, <b>without_rating</b> that will look for non null and null values, respectively. For state attributes thee redefine corresponding state_machine scopes so they can be called without parameters to check against null and non null. (You can use it in the normal way too, of course). These scopes can be used with boolean, state, integer, decimal, time, date, datetime, float and string attributes. For integer, decimal, time, date, datetime and string attributes value(s) can be passed to the scope so the check will be performed against passed values (not against null/non null vakues). (ex.: with_rating(1,2,3), without_rating([5,4,3]))
+* <b>is</b> and <b>not</b> options will generate scopes such as <b>published</b>, <b>not_published</b> ("is" is the one option that is not reflected in the name of the generated scope) that look for true and and false or null values for boolean attributes and for the specified state and for state that is not the specifieed one no null for state attributes.
+* <b>eq</b> (stands for equal), <b>ne</b> (not equal), <b>gt</b> (greater than), <b>gte</b> (greater than or equal), <b>lt</b> (lesser than), <b>lte</b> (lesser than or equal) options generate scopes with corresponding suffixes and accept list of values or array as parameteters. Options names are self explanatory. These scopes can be used with integer, decimal, time, date and datetime attributes. lt and gt options can be used with float attributes.
+* for string attributes <b>like</b> and <b>ilike</b> options can be specified which generate scopes like <b>title_like</b>, <b>title_ilike</b> which accept list or array of arguments and look for values like the specified ones, case sensitive and insensitive, respectively.
+* <b>by</b> and <b>by_desc</b> options can be used with integer, decimal, time, date, datetime, float and string attributes and generate scopes like <b>by_created_at</b> and <b>by_created_at_desc</b>, which sort by created at asc and created at desc, respectively.
+* <b>for</b> and <b>not_for</b> scopes can be used with belongs_to associations (including polymorphic ones) and generate scopes like <b>for_user</b>, <b>not_for_commentable</b>. They can accept list or array of associations. Also, hash(es) with id and type keys can be specified for polymorphic associations.
+
+
+== Usage examples
+
+* Call to magic_scopes without parameters will generate all possible scopes for all attributes, belongs_to associations and states. By specifying parameters you tell magic_scopes to generate only the scopes you need.
+    magic_scopes
+
+* With specified attributes it will generate all possible scopes for title and bogus attributes.
+    magic_scopes :title, :bogus
+
+* You can specify in (stands for include) and ex (for exclude) options, so:
+  * it will generate with and by scopes for all suitable attributes when in option is specified.
+      magic_scopes in: %w(with by)
+  * It will generate generate all possible scopes except with and by ones when ex option is specified.
+      magic_scopes ex: %w(with by)
+  * It will generate with and by scopes for all suitable attributes in specified list when both attributes list and in options are cpecified:
+      magic_scopes :title, :bogus, in: %w(with by)
+  * You can also override scopes that should be generated per attribute:
+      magic_scopes :title, :rating, bogus: :by_desc, in: %w(with by)
+    It will generate with and by scopes for title and rating attributes and by_desc scope for bogus attribute.
+
+  * All options accept strings, symbols and arrays as arguments.
+
+
+== Standard scopes
+
+In addition, some standard scopes can be specified using :std option, they are:
+asc and sorted sort by id asc, desc and recent sort by id desc and random sorts in random order.
+ex.: magic_scopes :title, :bogus, in: %w(with without), std: %w(recent rendom)
+magic_scopes generate all possible standard scopes unless std option is specified.
+
+MagicScopes is thoroughly tested and ready for production.
+It works with ActiveRecord >= 3.0 and ruby 1.9. (1.8 is not supported).
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MagicScopes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Default: Run all specs.'
+task default: :spec

data/lib/magic_scopes.rb

@@ -0,0 +1,28 @@
+require 'magic_scopes/standard_scopes'
+require 'magic_scopes/scopes_builder'
+require 'magic_scopes/scopes_generators/mixins/order_scopes'
+require 'magic_scopes/scopes_generators/mixins/comparison_scopes'
+require 'magic_scopes/scopes_generators/mixins/equality_scopes'
+require 'magic_scopes/scopes_generators/mixins/presence_scopes'
+require 'magic_scopes/scopes_generators/base'
+require 'magic_scopes/scopes_generators/boolean'
+require 'magic_scopes/scopes_generators/integer'
+require 'magic_scopes/scopes_generators/string'
+require 'magic_scopes/scopes_generators/float'
+require 'magic_scopes/scopes_generators/association'
+require 'magic_scopes/scopes_generators/state'
+require 'magic_scopes/version'
+require 'magic_scopes/railtie' if defined?(Rails)
+
+
+module MagicScopes
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def magic_scopes(*attrs)
+      builder = ScopesBuilder.new(self, *attrs)
+      builder.generate_standard_scopes
+      builder.generate_scopes
+    end
+  end
+end

data/lib/magic_scopes/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails/railtie'
+
+module MagicScopes
+  class Railtie < Rails::Railtie
+    initializer 'magic_scopes.extend_active_record_base' do |app|
+      ActiveSupport.on_load(:active_record) do
+        send(:include, MagicScopes)
+      end
+    end
+  end
+end

data/lib/magic_scopes/scopes_builder.rb

@@ -0,0 +1,203 @@
+module MagicScopes
+  class ScopesBuilder
+
+    include MagicScopes::StandardScopes
+
+    STANDARD_OPTIONS = [:std, :in, :ex]
+
+    MAGIC_SCOPES = {
+      boolean:     [:is, :not, :with, :without],
+      integer:     [:with, :without, :eq, :ne, :gt, :gte, :lt, :lte, :by, :by_desc],
+      float:       [:with, :without, :lt, :gt, :by, :by_desc],
+      string:      [:with, :without, :eq, :ne, :by, :by_desc, :like, :not_like, :ilike, :not_ilike],
+      association: [:for, :not_for]
+    }
+    MAGIC_SCOPES[:state]   = MAGIC_SCOPES[:boolean]
+    MAGIC_SCOPES[:decimal] = MAGIC_SCOPES[:time] = MAGIC_SCOPES[:datetime] = MAGIC_SCOPES[:date] = MAGIC_SCOPES[:integer]
+    MAGIC_SCOPES[:text]    = MAGIC_SCOPES[:string]
+
+    delegate :scope, :order, :columns_hash, :reflections, :state_machines, to: :@model
+
+    def initialize(model, *attrs)
+      @model   = model
+      @options = attrs.extract_options!.symbolize_keys
+      check_options
+      @attributes_with_scopes = extract_attributes_with_scopes
+      @attributes             = make_attributes(attrs)
+      @is_attributes_passed   = attrs.present? || @attributes_with_scopes.present?
+      @needed_scopes          = make_needed_scopes
+    end
+
+    def generate_standard_scopes
+      (@options[:std] || STANDARD_SCOPES).each { |scope_type| send("#{scope_type}_scope") }
+    end
+
+    def generate_scopes
+      @attributes.inject({}) { |hsh, attr| hsh[attr] = generate_scopes_for_attr(attr, @needed_scopes); hsh }.merge(
+        @attributes_with_scopes.inject({}) { |hsh, (attr, attr_scopes)| hsh[attr] = generate_scopes_for_attr(attr, attr_scopes); hsh }
+      )
+    end
+
+
+    private
+
+    def generate_scopes_for_attr(attr, scopes)
+      scopes.inject([]) do |ar, scope_info|
+        scope_info = Array.wrap(scope_info)
+        if has_scope_generator_for?(attr, scope_info[0])
+          generate_scope_for(attr, scope_info[0], scope_info[1] != scope_info[0] ? scope_info[1] : nil)
+          ar << scope_info[0]
+        end
+        ar
+      end
+    end
+
+    def check_options
+      @options.assert_valid_keys(*valid_options)
+
+      if @options[:in] && @options[:ex]
+        raise ArgumentError, "In(clude) and ex(clude) options can not be specified simultaneously"
+      end
+
+      if @options[:std] && option = @options[:std].find { |opt| STANDARD_SCOPES.exclude?(opt.to_sym) }
+        raise ArgumentError, "Unknown option #{option} passed to magic_scopes#std"
+      end
+    end
+
+    def extract_attributes_with_scopes
+      attributes_with_scopes = @options.inject({}) do |hsh, (option_key, options)|
+        unless option_key.in?(STANDARD_OPTIONS)
+          hsh[option_key] = unless options.is_a?(Hash)
+              Array.wrap(@options.delete(option_key)).inject({}) { |hsh, option| hsh[option.to_sym] = option.to_sym; hsh }
+            else
+              options
+            end
+        end
+        hsh
+      end
+      extract_states_from_attrs!(attributes_with_scopes)
+
+      wrong_scope = nil
+      if wrong_attr = attributes_with_scopes.find do |attr, scopes_hash|
+        wrong_scope = scopes_hash.find { |scope_type, _| scope_types(attr).exclude?(scope_type.to_sym) }
+      end
+        raise ArgumentError, "Unknown scope #{wrong_scope} for attribute #{wrong_attr[0]} passed to magic_scopes"
+      end
+
+      attributes_with_scopes
+    end
+
+    def valid_options
+      @valid_options ||= (STANDARD_OPTIONS + columns_hash.keys + reflections.keys).map(&:to_sym)
+    end
+
+    def scope_types(*attrs)
+      filtered_scopes = if attrs.empty?
+          MAGIC_SCOPES
+        else
+          needed_attr_types = attrs.map { |attr| attrs_with_types[attr] }
+          MAGIC_SCOPES.select { |k, _| k.in?(needed_attr_types)  }
+        end
+      filtered_scopes.values.flatten.uniq
+    end
+
+    def make_attributes(attrs)
+      attributes = if attrs.empty?
+          all_possible_attributes - @attributes_with_scopes.keys
+        else
+          extract_states_from_attrs(attrs.map(&:to_sym))
+        end
+
+      if wrong_attr = attributes.find { |attr| all_possible_attributes.exclude?(attr) }
+        raise ActiveRecord::UnknownAttributeError, "Unknown attribute #{wrong_attr} passed to magic_scopes"
+      end
+      if attr = attributes.find { |attr| @attributes_with_scopes.keys.include?(attr) }
+        raise ArgumentError, "Attribute #{attr} specified using both list and hash"
+      end
+      attributes
+    end
+
+    def make_needed_scopes
+      scopes_options = @options[:in] || @options[:ex]
+      scopes_options = if scopes_options
+        scopes_options = Array.wrap(scopes_options).map(&:to_sym)
+        if wrong_scope = scopes_options.find { |scope_type| scope_types.exclude?(scope_type) }
+          raise ArgumentError, "Unknown scope #{wrong_scope} passed to magic_scopes"
+        end
+        scopes_options
+      end
+
+      needed_scopes = if @options[:in]
+          scopes_options
+        elsif @options[:ex]
+          scope_types(*@attributes) - scopes_options
+        else
+          scope_types
+        end
+
+      if scopes_options && @is_attributes_passed && wrong_scope = check_for_wrong_scope(needed_scopes)
+        raise ArgumentError, "Can not build scope #{wrong_scope} for all passed attributes"
+      end
+
+      needed_scopes
+    end
+
+    def check_for_wrong_scope(scopes)
+      scopes.find { |scope_type| @attributes.any? { |attr| !has_scope_generator_for?(attr, scope_type) } }
+    end
+
+    def generate_scope_for(attr, scope_type, scope_name = nil)
+      type = type_for_attr(attr)
+      "MagicScopes::#{type.to_s.classify}ScopesGenerator".constantize.instance(@model, attr).send(scope_type, scope_name)
+    end
+
+    def has_scope_generator_for?(attr, scope_type)
+      scope_type.in?(MAGIC_SCOPES[type_for_attr(attr)])
+    end
+
+    def type_for_attr(attr)
+      attrs_with_types[attr]
+    end
+
+    def all_possible_attributes
+      @all_possible_attributes ||= extract_states_from_attrs(columns_hash.keys.map(&:to_sym) + reflections.keys)
+    end
+
+    def extract_states_from_attrs(attrs)
+      if defined?(StateMachine)
+        machines = state_machines.keys
+        if attrs.is_a?(Array)
+          attrs += machines.inject([]) do |ar, sm_key|
+            ar += state_machines[sm_key].states.map(&:name).compact if sm_key.in?(attrs)
+            ar
+          end
+          attrs -= machines
+        else
+          machines_states = machines.inject(attrs) do |hsh, sm_key|
+            state_machines[sm_key].states.map(&:name).compact.each { |state| hsh[state] = attrs[sm_key] } if sm_key.in?(attrs)
+            hsh
+          end
+          attrs.except!(*machines)
+        end
+      end
+      attrs
+    end
+
+    def extract_states_from_attrs!(attrs)
+      attrs = extract_states_from_attrs(attrs)
+    end
+
+    def attrs_with_types
+      @attrs_with_types ||= all_possible_attributes.inject({}) do |hsh, attr|
+        hsh[attr] = if reflections[attr]
+            :association
+          elsif (type = columns_hash[attr.to_s].try(:type)) && (!defined?(StateMachine) || !state_machines.keys.include?(attr))
+            type
+          else
+            :state
+          end
+        hsh
+      end
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/association.rb

@@ -0,0 +1,76 @@
+module MagicScopes
+  class AssociationScopesGenerator < ScopesGenerator::Base
+
+    def initialize(model, attr)
+      super
+      @model    = model
+      @attr     = attr
+      @key      = "#{model.table_name}.#{attr.to_s.foreign_key}"
+      @type_key = "#{model.table_name}.#{attr}_type"
+    end
+
+    def for(name)
+      if @model.reflections[@attr].options[:polymorphic]
+        scope name || "for_#{@attr}", ->(*vals) {
+          raise ArgumentError, "No argument for for_#{@attr} scope" if vals.empty?
+          ids_and_types = vals.map { |v| extract_ids_and_types(v, @attr) }.flatten
+          conditions = ids_and_types.map { |hsh| "(#{@key} = ? AND #{@type_key} = ?)" }.join(' OR ')
+          where(conditions, *ids_and_types.map(&:values).flatten)
+        }
+      else
+        scope name || "for_#{@attr}", ->(*vals) {
+          raise ArgumentError, "No argument for for_#{@attr} scope" if vals.empty?
+          where(@key => vals.map { |v| extract_ids(v, @attr) }.flatten )
+        }
+      end
+    end
+
+    def not_for(name)
+      if @model.reflections[@attr.to_sym].options[:polymorphic]
+        scope name || "not_for_#{@attr}", ->(*vals) {
+          raise ArgumentError, "No argument for for_#{@attr} scope" if vals.empty?
+          ids_and_types = vals.map { |v| extract_ids_and_types(v, @attr) }.flatten
+          conditions = ids_and_types.map { |hsh| "(#{@key} != ? AND #{@type_key} != ?)" }.join(' AND ')
+          where("#{conditions} OR (#{@key} IS NULL OR #{@type_key} IS NULL)", *ids_and_types.map(&:values).flatten)
+        }
+      else
+        scope name || "not_for_#{@attr}", ->(*vals) {
+          raise ArgumentError, "No argument for for_#{@attr} scope" if vals.empty?
+          ids = vals.map { |v| extract_ids(v, @attr) }.flatten
+          conditions = ids.size == 1 ? "!= ?" : "NOT IN (?)"
+          where("#{@key} #{conditions} OR #{@key} IS NULL", ids.size == 1 ? ids[0] : ids)
+        }
+      end
+    end
+
+
+    private
+
+    def extract_ids(val, attr)
+      if val.is_a?(Fixnum) || (val.is_a?(String) && val.to_i != 0)
+        val
+      elsif val.is_a?(ActiveRecord::Base)
+        val.id
+      elsif val.is_a?(Array) && val.all? { |v| v.is_a?(Fixnum) || (v.is_a?(String) && v.to_i != 0) || v.is_a?(ActiveRecord::Base) }
+        val.is_a?(ActiveRecord::Base) ? val.map(&:id) : val
+      else
+        raise ArgumentError, "Wrong argument type #{attr.class.name} for argument #{attr}"
+      end
+    end
+
+    def extract_ids_and_types(val, attr)
+      if val.is_a?(ActiveRecord::Base)
+        {id: val.id, type: val.class.name}
+      elsif val.is_a?(Hash) && val.assert_valid_keys(:id, :type)
+        val
+      elsif val.is_a?(Array) && val.all? { |v| v.is_a?(ActiveRecord::Base) }
+        val.map { |v| {id: v.id, type: v.class.name} }
+      elsif val.is_a?(Array) && val.size == 2 && id = val.find { |v| v.respond_to?(:to_i) && v.to_i != 0 }
+        val.delete(id)
+        {id: id, type: val[0]}
+      else
+        raise ArgumentError, "Wrong argument type #{attr.class.name} for argument #{attr}"
+      end
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/base.rb

@@ -0,0 +1,27 @@
+module MagicScopes
+  module ScopesGenerator
+    class Base
+
+      @@instances = {}
+
+      private_class_method :new
+
+      def initialize(model, attr)
+        @model = model
+        @attr  = attr
+        @key   = "#{model.table_name}.#{attr}"
+      end
+
+      def self.instance(model, attr)
+        if @@instances[model.name].try(:has_key?, attr)
+          @@instances[model.name][attr]
+        else
+          @@instances[model.name] ||= {}
+          @@instances[model.name][attr] = new(model, attr)
+        end
+      end
+
+      delegate :scope, :where, :order, to: :@model
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/boolean.rb

@@ -0,0 +1,14 @@
+module MagicScopes
+  class BooleanScopesGenerator < ScopesGenerator::Base
+
+    include PresenceScopes
+
+    def is(name)
+      scope name || @attr, where("#{@key}" => true)
+    end
+
+    def not(name)
+      scope name || "not_#{@attr}", where("#{@key}" => [false, nil])
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/float.rb

@@ -0,0 +1,7 @@
+module MagicScopes
+  class FloatScopesGenerator < ScopesGenerator::Base
+    include OrderScopes
+    include ComparisonScopes
+    include PresenceScopes
+  end
+end

data/lib/magic_scopes/scopes_generators/integer.rb

@@ -0,0 +1,27 @@
+module MagicScopes
+  class IntegerScopesGenerator < ScopesGenerator::Base
+
+    include EqualityScopes
+    include OrderScopes
+    include ComparisonScopes
+
+    def gte(name)
+      scope name || "#{@attr}_gte", ->(val) { where("#{@key} >= ?", val) }
+    end
+
+    def lte(name)
+      scope name || "#{@attr}_lte", ->(val) { where("#{@key} <= ?", val) }
+    end
+
+  end
+
+  # TODO
+  # make something like:
+  # %w(integer decimal time datetime date).each do |type|
+  #   send("#{type.classify}=", NumScopesGenerator)
+  # end
+  DecimalScopesGenerator  = IntegerScopesGenerator
+  TimeScopesGenerator     = IntegerScopesGenerator
+  DatetimeScopesGenerator = IntegerScopesGenerator
+  DateScopesGenerator     = IntegerScopesGenerator
+end

data/lib/magic_scopes/scopes_generators/mixins/comparison_scopes.rb

@@ -0,0 +1,11 @@
+module MagicScopes
+  module ComparisonScopes
+    def gt(name)
+      scope name || "#{@attr}_gt", ->(val){ where("#{@key} > ?", val) }
+    end
+
+    def lt(name)
+      scope name || "#{@attr}_lt", ->(val){ where("#{@key} < ?", val) }
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/mixins/equality_scopes.rb

@@ -0,0 +1,30 @@
+module MagicScopes
+  module EqualityScopes
+    def with(name)
+      scope name || "with_#{@attr}", eq_scope
+    end
+
+    def eq(name)
+      scope name || "#{@attr}_eq", eq_scope
+    end
+
+    def without(name)
+      scope name || "without_#{@attr}", where("#{@key} IS NULL")
+    end
+
+    def ne(name)
+      scope name || "#{@attr}_ne", ->(*vals) {
+        raise ArgumentError, "No argument for for_#{@attr} scope" if vals.empty?
+        sql = "#{@key} " << (vals.size == 1 && !vals[0].is_a?(Array) ? '!= ?' : 'NOT IN (?)') << " OR #{@key} IS NULL"
+        where(sql, vals.flatten)
+      }
+    end
+
+    private
+
+    def eq_scope
+      @eq_scope ||= ->(*vals) { vals.empty? ? where("#{@key} IS NOT NULL") : where(@key => vals.flatten) }
+    end
+
+  end
+end

data/lib/magic_scopes/scopes_generators/mixins/order_scopes.rb

@@ -0,0 +1,11 @@
+module MagicScopes
+  module OrderScopes
+    def by(name)
+      scope name || "by_#{@attr}", order("#{@attr} ASC")
+    end
+
+    def by_desc(name)
+      scope name || "by_#{@attr}_desc", order("#{@attr} DESC")
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/mixins/presence_scopes.rb

@@ -0,0 +1,11 @@
+module MagicScopes
+  module PresenceScopes
+    def with(name)
+      scope name || "with_#{@attr}", where("#{@key} IS NOT NULL")
+    end
+
+    def without(name)
+      scope name || "without_#{@attr}", where("#{@key} IS NULL")
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/state.rb

@@ -0,0 +1,35 @@
+if defined?(StateMachine)
+  module MagicScopes
+    class StateScopesGenerator < ScopesGenerator::Base
+      def initialize(model, state)
+        @model = model
+        @state = state
+        @key   = "#{model.table_name}.#{attr}"
+      end
+
+      def is(name)
+        scope name || @state, where("#{@key}" => @state)
+      end
+
+      def not(name)
+        scope name || "not_#{@state}", where("#{@key} != ? OR #{@key} IS NULL", @state)
+      end
+
+      def with(name)
+        @model.instance_eval("undef :with_#{attr}")
+        scope name || "with_#{@attr}", ->(*vals) { where(vals.empty? ? "#{@key} IS NOT NULL" : ["#{@key} IN (?)", vals]) }
+      end
+
+      def without(name)
+        @model.instance_eval("undef :without_#{attr}")
+        scope name || "without_#{@attr}", ->(*vals) { where(vals.empty? ? "#{@key} IS NULL" : ["#{@key} NOT IN (?)", vals]) }
+      end
+
+      private
+
+      def attr
+        @attr ||= @model.state_machines.find { |_, sm| sm.states.map(&:name).include?(@state) }[0]
+      end
+    end
+  end
+end

data/lib/magic_scopes/scopes_generators/string.rb

@@ -0,0 +1,40 @@
+module MagicScopes
+  class StringScopesGenerator < ScopesGenerator::Base
+
+    include EqualityScopes
+    include OrderScopes
+
+    def like(name)
+      scope name || "#{@attr}_like", ->(*vals) { where(build_query(*vals, "#{@key} LIKE ?", 'OR')) }
+    end
+
+    def not_like(name)
+      scope name || "#{@attr}_not_like", ->(*vals) { where(build_query(*vals, "#{@key} NOT LIKE ?", 'AND')) }
+    end
+
+    def ilike(name)
+      scope name || "#{@attr}_ilike", ilike_scope
+    end
+
+    def not_ilike(name)
+      scope name || "#{@attr}_not_ilike", ilike_scope('NOT')
+    end
+
+    private
+
+    def build_query(*vals, condition, operator)
+      [Array.new(vals.size, condition).join(" #{operator} "), *vals.map { |val| "%#{val}%" }]
+    end
+
+    def ilike_scope(operator = nil)
+      conditions = ilike_supported? ? "#{@key} #{operator} ILIKE ?" : "LOWER(#{@key}) #{operator} LIKE ?"
+      ->(*vals){ where(build_query(*vals, conditions, operator != 'NOT' ? 'OR' : 'AND')) }
+    end
+
+    def ilike_supported?
+      @model.connection.adapter_name == 'PostgreSQL'
+    end
+  end
+
+  TextScopesGenerator = StringScopesGenerator
+end

data/lib/magic_scopes/standard_scopes.rb

@@ -0,0 +1,31 @@
+module MagicScopes
+  module StandardScopes
+    extend ActiveSupport::Concern
+
+    included do
+      self::STANDARD_SCOPES = [:asc, :sorted, :desc, :recent, :random]
+    end
+
+    private
+
+    def asc_scope
+      scope :asc, order(:id)
+    end
+
+    def sorted_scope
+      scope :sorted, order(:id)
+    end
+
+    def desc_scope
+      scope :desc,  order('id DESC')
+    end
+
+    def recent_scope
+      scope :recent, order('id DESC')
+    end
+
+    def random_scope
+      scope :random, order('RANDOM()')
+    end
+  end
+end

data/lib/magic_scopes/version.rb

@@ -0,0 +1,3 @@
+module MagicScopes
+  VERSION = "1.1.0"
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: magic_scopes
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dmitry Afanasyev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !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: state_machine
+  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-rails
+  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: pry-debugger
+  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'
+description: ActiveRecord scopes generators
+email:
+- dimarzio1986@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/magic_scopes/railtie.rb
+- lib/magic_scopes/scopes_builder.rb
+- lib/magic_scopes/scopes_generators/association.rb
+- lib/magic_scopes/scopes_generators/base.rb
+- lib/magic_scopes/scopes_generators/boolean.rb
+- lib/magic_scopes/scopes_generators/float.rb
+- lib/magic_scopes/scopes_generators/integer.rb
+- lib/magic_scopes/scopes_generators/mixins/comparison_scopes.rb
+- lib/magic_scopes/scopes_generators/mixins/equality_scopes.rb
+- lib/magic_scopes/scopes_generators/mixins/order_scopes.rb
+- lib/magic_scopes/scopes_generators/mixins/presence_scopes.rb
+- lib/magic_scopes/scopes_generators/state.rb
+- lib/magic_scopes/scopes_generators/string.rb
+- lib/magic_scopes/standard_scopes.rb
+- lib/magic_scopes/version.rb
+- lib/magic_scopes.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: http://github.com/icrowley
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ActiveRecord scopes generators
+test_files: []
+has_rdoc: