attribute-filters 1.0.0

data/docs/LGPL-LICENSE

@@ -0,0 +1,166 @@
+
+= GNU LESSER GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. < http://fsf.org/ >
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+=== 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+=== 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+=== 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+a) under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+b) under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+=== 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+a) Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+
+b) Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+=== 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+a) Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+b) Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+c) For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+d) Do one of the following:
+
+0) Convey the Minimal Corresponding Source under the terms of this
+License, and the Corresponding Application Code in a form
+suitable for, and under terms that permit, the user to
+recombine or relink the Application with a modified version of
+the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying
+Corresponding Source.
+
+1) Use a suitable shared library mechanism for linking with the
+Library.  A suitable mechanism is one that (a) uses at run time
+a copy of the Library already present on the user's computer
+system, and (b) will operate properly with a modified version
+of the Library that is interface-compatible with the Linked
+Version.
+
+e) Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option 4d0, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option 4d1, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+=== 5. Combined Libraries.
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+a) Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+
+b) Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+=== 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

data/docs/TODO

@@ -0,0 +1,6 @@
+
+
+- test for methods changed_attributes and ... and if not then include ActiveModel...
+
+* add rspec tests
+

data/docs/rdoc.css

@@ -0,0 +1,20 @@
+@import "rdoc_base.css";
+
+#documentation > ul:first-of-type {
+  padding-bottom: 2em;
+  padding-top: 1.5em;
+  background-position: 20em 0%;
+  background-repeat: no-repeat;
+  }
+
+#documentation .method-description > p:first-of-type + p {
+  margin-top: 0.5em;
+}
+
+#documentation .method-description > ul {
+  margin-left: 1.2em;
+}
+
+#documentation .method-description > p + ul {
+  margin-left: 1.8em;
+}

data/init.rb

@@ -0,0 +1 @@
+require 'attribute-filters'

data/lib/attribute-filters/attribute_set.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains ActiveModel::AttributeSet class
+# used to interact with attribute sets.
+
+require 'set'
+
+# @abstract This namespace is shared with ActveModel.
+module ActiveModel
+  # This class is a data structure used to store
+  # sets of attributes.
+  class AttributeSet < ::Set
+  end
+end

data/lib/attribute-filters/attribute_set_query.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains ActiveModel::AttributeSet::Query class
+# used to interact with attribute sets.
+
+module ActiveModel
+  class AttributeSet
+    # This class contains proxy methods used to interact with
+    # AttributeSet instances. It's responsible for all of the DSL magic
+    # that allows sweet constructs like:
+    #   some_attribute_set.all.present?
+    class Query < BasicObject
+      # Creates new query object.
+      # 
+      # @param attribute_set_object [AttributeSet] attribute set for which the query will be made
+      # @param am_object [Object] model object which has access to attributes (may be an instance of ActiveRecord or similar)
+      def initialize(attribute_set_object, am_object)
+        @attribute_set = attribute_set_object
+        @am_object = am_object
+        @next_method = nil
+      end
+
+      # This is proxy method that causes some calls to be
+      # queued to for the next call. Is allows to create semi-natural
+      # syntax when querying attribute sets.
+      # 
+      # When +method_sym+ is set to +:all+ or +:any+ then new query is created
+      # and the next method given in chain is passed to each element of the set with
+      # question mark added to its name.
+      # 
+      # Example:
+      #   some_attribute_set.all.present?
+      # is converted to
+      #   some_attribute_set.all? { |atr| atr.present? }
+      # 
+      # When +method_sym+ is set to +list+ or +show+ then new query
+      # is constructed and the next method given in chain is passed to
+      # any element collected by applying +select+ to set.
+      # 
+      # Example:
+      #   some_attribute_set.list.present?
+      # is converted to
+      #   some_attribute_set.select { |atr| atr.present? }
+      # 
+      # @param method_sym [Symbol,String] name of method that will be queued or called on attribute set
+      # @param args [Array] optional arguments to be passed to a method call or to a queued method call
+      # @yield optional block to be passed to a method call or to a queued method call
+      def method_missing(method_sym, *args, &block)
+        case method_sym.to_sym
+        when :are, :is, :be, :should
+          return self
+        end
+        if @method_to_call.nil?
+          case method_sym.to_sym
+          when :all, :any
+            ::ActiveModel::AttributeSet::Query.new(@attribute_set, @am_object).   # new obj. == thread-safe
+              next_step(method_sym.to_s << "?", args, block)
+          when :list, :show
+            ::ActiveModel::AttributeSet::Query.new(@attribute_set, @am_object).
+              next_step(:select, args, block)
+          else
+            @attribute_set.method(method_sym).call(*args, &block)
+          end
+        else
+          method_sym, args, block = @next_method
+          @next_method = nil
+          @attribute_set.method(m).call { |a| @am_object[a].method(method_sym).call(*args, &block) }
+        end
+      end
+
+      protected
+
+      # Queues any method of the given name to be called when next
+      # query (method call) is made.
+      # 
+      # @param method_name [Symbol] name of a method to be called on next call to any query method
+      # @param args [Array] arguments to be passed to the called method
+      # @param block [Proc] code block to be passed to the called method
+      # @return [AttributeSet] current query object
+      def next_step(method_name, args, block)
+        @next_method = [method_name, args, block]
+        return self
+      end
+    end # class Query
+  end # class AttributeSet
+end # module ActiveModel

data/lib/attribute-filters/common_filters.rb

@@ -0,0 +1,4 @@
+
+
+# todo: manually included module with common filters
+

data/lib/attribute-filters/dsl_filters.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains modules with methods that create DSL for managing attribute filters.
+
+module ActiveModel
+  module AttributeFilters
+    # Gets names of attributes for which filters should be applied by
+    # selecting attributes that 1. have changed and 2. their names belong to
+    # the given set of attributes.
+    # 
+    # @param process_unchanged [Boolean] if set to +true+ then all accessible attributes will
+    #  be tested (which are also present in set o course), not just the changed ones
+    # @param set_name [AttributeSet] set of attributes used to select attributes
+    # @return [Hash{Symbol => Object}] list of attributes (attribute name => previous_value)
+    def attributes_to_filter(set_name, process_unchanged = false)
+      @__attr_op_apply ||= Array.new
+      if process_unchanged
+        @__attr_op_apply[0] ||= Hash.new
+        @__attr_op_apply[0][set_name] || begin
+          buf = @__attr_op_apply[0][set_name] = Hash.new
+          (attribute_set(set_name) & self.class.accessible_attributes.to_a).each do |a|
+            buf[a] = nil
+          end
+          buf
+        end
+      else
+        @__attr_op_apply[1] ||= Hash.new
+        @__attr_op_apply[1][set_name] ||= changed_attributes.select do |a,pv|
+          attribute_set(set_name).include?(a)
+        end
+      end
+    end
+
+    # This generic method applies a result of execution of the passed block
+    # to each of all changed attributes that are present in the given
+    # set of attributes. It is useful in creating filtering methods.
+    # The result of a block is used to set a new value for each processed attribute.
+    # 
+    # @param set_name [Symbol] name of the attributes set
+    # @param args [Array] optional additional arguments that will be passed to the block
+    # @yield [attribute_value, previous_value, set_name, attribute_name, *args] block that will be called for each attribute
+    # @yieldparam attribute_value [Object] current attribute value that should be altered
+    # @yieldparam previous_value [Object] the value of an attribute before change was made by ORM
+    # @yieldparam set_name [Symbol] a name of the processed attribute set
+    # @yieldparam attribute_name [Object] a name of currently processed attribute
+    # @yieldparam args [Array] optional arguments passed to the method
+    # @yieldreturn [Object] the result of calling the block 
+    # @return [void]
+    # 
+    # @example
+    #   class User < ActiveRecord::Base
+    #     
+    #     attributes_that :should_be_downcased => [ :username, :email ]
+    #     before_filter :downcase_names
+    #     
+    #     def downcase_names
+    #       filter_attributes_that :should_be_downcased do |atr|
+    #         atr.mb_chars.downcase.to_s
+    #       end
+    #     end
+    #   
+    #   end
+    def filter_attrs_from_set(set_name, *args, &block)
+      flags = attr_filter_process_flags(args)
+      pb = flags[:process_blank]
+      pu = flags[:process_unchanged]
+      attributes_to_filter(set_name, pu).each do |a, pv|
+        v = self[a]
+        pv = v if pu
+        self[a] = yield(v, pv, set_name, a, *args) if (pb || v.present?)
+      end
+    end
+    alias_method :attribute_filter_for_set,     :filter_attrs_from_set
+    alias_method :filter_attributes_which,      :filter_attrs_from_set
+    alias_method :filter_attributes_that,       :filter_attrs_from_set
+    alias_method :filter_attributes_that_are,   :filter_attrs_from_set
+    alias_method :filter_attributes_which_are,  :filter_attrs_from_set
+    alias_method :alter_attributes_which,       :filter_attrs_from_set
+    alias_method :alter_attributes_that,        :filter_attrs_from_set
+    alias_method :alter_attributes_that_are,    :filter_attrs_from_set
+    alias_method :alter_attributes_which_are,   :filter_attrs_from_set
+
+    # This generic method calls the passed block
+    # on each of all changed attributes that are present in the given
+    # set of attributes. It is useful in creating filtering methods.
+    # The result of a block is ignored, so the only effective way of
+    # altering attribute values is calling altering method on attributes
+    # (usually with bang methods).
+    # 
+    # @param set_name [Symbol] name of the attributes set
+    # @param args [Array] optional additional arguments that will be passed to the block
+    # @yield [attribute_value, previous_value, set_name, attribute_name, *args] block that will be called for each attribute
+    # @yieldparam attribute_value [Object] current attribute value that should be altered
+    # @yieldparam previous_value [Object] the value of an attribute before change was made by ORM
+    # @yieldparam set_name [Symbol] a name of the processed attribute set
+    # @yieldparam attribute_name [Object] a name of currently processed attribute
+    # @yieldparam args [Array] optional arguments passed to the method
+    # @yieldreturn [void]
+    # @return [void]
+    # 
+    # @example
+    #   class User < ActiveRecord::Base
+    #   
+    #     attributes_that :should_be_stripped => [ :username, :email ]
+    #     before_filter :strip_names
+    #     
+    #     def strip_names
+    #       for_attributes_that :should_be_stripped do |atr|
+    #         atr.strip!
+    #       end
+    #     end
+    #   
+    #   end
+    def call_attrs_from_set(set_name, *args, &block)
+      flags = attr_filter_process_flags(args)
+      pb = flags[:process_blank]
+      pu = flags[:process_unchanged]
+      attributes_to_filter(set_name, pu).each do |a, pv|
+        v = self[a]
+        pv = v if pu
+        yield(v, pv, set_name, a, *args) if (pb || v.present?)
+      end
+    end
+    alias_method :attribute_call_for_set,   :call_attrs_from_set
+    alias_method :for_attributes_which,     :call_attrs_from_set
+    alias_method :for_attributes_that,      :call_attrs_from_set
+    alias_method :for_attributes_that_are,  :call_attrs_from_set
+    alias_method :for_attributes_which_are, :call_attrs_from_set
+
+    private
+
+    def attr_filter_process_flags(args)
+      flags = { :process_blank => false, :process_unchanged => false }
+      while flags.key?(a=args[0]) do
+        flags[a] = !!args.shift
+      end
+      flags
+    end
+
+  end
+end

data/lib/attribute-filters/dsl_sets.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains modules defining methods that create DSL for managing attribute sets.
+
+module ActiveModel
+  # This module contains instance methods for getting and setting
+  # attricute sets established in classes (models).
+  module AttributeFilters
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Allows to access the given attribute set.
+    # 
+    # @param set_name [Symbol] name of attribute set
+    # @return [AttributeSet] attribute set
+    def attribute_set(set_name)
+      ActiveModel::AttributeSet::Query.new(self.class.attribute_set(set_name), self)
+    end
+    alias_method :attributes_that_are,        :attribute_set
+    alias_method :are_attributes_that_are,    :attribute_set
+    alias_method :from_attributes_that_are,   :attribute_set
+    alias_method :within_attributes_that_are, :attribute_set
+    alias_method :attributes_that,            :attribute_set
+    alias_method :attributes_are,             :attribute_set
+    alias_method :attributes_for,             :attribute_set
+    alias_method :are_attributes,             :attribute_set
+    alias_method :are_attributes_for,         :attribute_set
+    alias_method :attributes_set,             :attribute_set
+    alias_method :are_properties_that_are,    :attribute_set
+    alias_method :properties_that_are,        :attribute_set
+    alias_method :properties_that,            :attribute_set
+    alias_method :properties_are,             :attribute_set
+    alias_method :properties_for,             :attribute_set
+    alias_method :are_properties,             :attribute_set
+    alias_method :are_properties_for,         :attribute_set
+    alias_method :are_properties_that_are,    :attribute_set
+    alias_method :properties_set,             :attribute_set
+  
+    # This module contains class methods
+    # that create DSL for managing attribute sets.
+    module ClassMethods
+      # @overload attribute_set()
+      #   Gets all defined attribute sets.
+      #   @return [Hash{Symbol => AttributeSet}] the collection of attribute sets indexed by their names
+      # 
+      # @overload attribute_set(set_name)
+      #   Gets the contents of an attribute set of the given name.
+      #   @param set_name [Symbol,String] name of a set
+      #   @return [AttributeSet] the collection of attribute sets
+      # 
+      # @overload attribute_set(set_name, *attribute_names)
+      #   Creates new set of attributes of the given name.
+      #   @param set_name [Symbol,String] name of a set
+      #   @param attribute_names [Array<Symbol,String>] names of attributes to be stored in set
+      #   @return [nil]
+      # 
+      # @overload attribute_set(set_options)
+      #   Creates one new set or many new sets of attribute of the given name.
+      #   @param set_options [Hash{Symbol,String => Array<Symbol,String>}] hash containing set names and arrays of attributes
+      #   @return [nil]
+      def attribute_set(*args)
+        case args.size
+        when 0
+          attribute_sets
+        when 1
+          a = args.first
+          if a.is_a?(Hash)
+            a.each_pair { |k,v| attribute_set(k,v) }
+            nil
+          else
+            attribute_sets[a.to_sym] || ActiveModel::AttributeSet.new.freeze
+          end
+        else
+          set_name = args.shift.to_sym
+          attribute_sets[set_name] = ActiveModel::AttributeSet.new(args.flatten.compact.map{|x|x.to_s}).freeze
+          nil
+        end
+      end
+      alias_method :attributes_that_are,  :attribute_set
+      alias_method :attributes_that,      :attribute_set
+      alias_method :attributes_are,       :attribute_set
+      alias_method :attributes_for,       :attribute_set
+      alias_method :attributes_set,       :attribute_set
+      alias_method :properties_that_are,  :attribute_set
+      alias_method :properties_that,      :attribute_set
+      alias_method :properties_are,       :attribute_set
+      alias_method :properties_for,       :attribute_set
+      alias_method :properties_set,       :attribute_set
+
+      # Gets all defined attribute sets.
+      # @return [Hash{Symbol => AttributeSet}] the collection of attribute sets indexed by their names
+      def attribute_sets
+        @__attribute_sets ||= Hash.new
+      end
+      alias_method :attributes_sets, :attribute_sets
+      alias_method :properties_sets, :attribute_sets
+    end # module ClassMethods
+  end # module AttributeMethods
+end # module ActiveModel

data/lib/attribute-filters/railtie.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file loads Attribute Filters goodies into Rails.
+
+require 'attribute-filters'
+
+module AttributeFilters
+  require 'rails'
+  
+  # This class is a glue that allows us to integrate with Rails.
+  class Railtie < ::Rails::Railtie
+    # Alters ActiveModel::AttributeMethods.inluded method so
+    # when that module is included the ActiveModel::AttributeFilters
+    # module is also included.
+    def self.insert
+      require 'active_model'
+      if defined?(ActiveModel::AttributeMethods)
+
+        ActiveModel::AttributeMethods.class_eval do
+
+          def self.included_with_attribute_methods(base)
+            base.class_eval do
+              include ActiveModel::AttributeFilters
+              if method_defined?(:included_without_attribute_methods)
+                included_without_attribute_methods(base)
+              end
+            end
+          end
+          if singleton_class.method_defined?(:included)      
+            singleton_class.send(:alias_method_chain, :included, :attribute_methods)
+          end
+
+        end # ActiveModel::AttributeMethods.class_eval
+
+      end # if defined?(ActiveModel::AttributeMethods)
+    end # def self.insert
+  end # class Railtie
+
+  class Railtie
+    AttributeFilters::Railtie.insert
+  end # class Railtie
+end # module AttributeFilters

data/lib/attribute-filters/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains version information.
+
+module AttributeFilters
+      # @private
+      DEVELOPER   = 'Paweł Wilk'
+      # @private
+      EMAIL       = 'pw@gnu.org'
+      # @private
+      VERSION     = '1.0.0'
+      # @private
+      NAME        = 'attribute-filters'
+      # @private
+      SUMMARY     = 'Concise way of filtering model attributes in Rails'
+      # @private
+      URL         = 'https://rubygems.org/gems/attribute-filters/'
+      # @private
+      DESCRIPTION = 'Simple extension for Rails that adds some syntactic sugar (filters, attribute sets) to your models.'
+end

data/lib/attribute-filters.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'attribute-filters'
+require 'attribute-filters/version'
+require 'attribute-filters/attribute_set'
+require 'attribute-filters/attribute_set_query'
+
+require 'attribute-filters/dsl_sets'
+require 'attribute-filters/dsl_filters'
+
+require 'attribute-filters/railtie' if defined? ::Rails

data/spec/attribute-filters_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+class TestModel
+  include ActiveModel::AttributeMethods
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec/core'
+require 'attribute-filters'