simple_params 0.0.2.pre1 → 0.0.2.pre2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzEzZDlkYmYyYWJmZjI3NWI4OTg3ZTFhMjJiYmQzYjAwYjIwNmY1YQ==
+    MTYwZjZjZDIzZTBhYzk1OTljYWFmMzdmMWUzYjk0YmM1YWVjYWY2Mg==
   data.tar.gz: !binary |-
-    MzViNGIyYmIxY2EyMDU4MzY0MmU1NTA3N2FiYzY1MWIxODJhYzNmNA==
+    NDJjZDI0YzI5ZTRjNTZmMjAzZmQ3MjZmODg1OGI1NzZhNzI2ODFiYQ==
 SHA512:
   metadata.gz: !binary |-
-    MTlhMzg1OTVlZTE2YjQ0YzcxOWY5YTYzZjg5NDQzYmJkZTU1YjY5Y2NlM2Vm
-    NjgwMzEyYjA2Mjg5ZTQ0MTJjYTgyN2JkOWNlMDI2MDgxMTc2ZjMzNzI5ZTMz
-    YTg5MzUyMmRmYzc2N2RmODk2MDZlOWM5NzcyZGViZTUzMGRmMmQ=
+    MTE2MDAzNGUwNTg0MGVmZmJhMzdkZjVlMjE1M2RhODc1NGZjOTVkNTA2Zjhm
+    MDY5ZWNhMTZmYTAzMGQ3NTY3YjZjNjQwYjE2MmI5NGI5YWNkNjdhODY1ZDBl
+    NzIxNzUzNTQ5NzA3NmQwZmJlYzIzYzhiMjllMjJkYzJmOTk2NTM=
   data.tar.gz: !binary |-
-    NDZmZmUzMWI4NGRhZmFjM2IxZTczOTNhMWVkODBhZTFkM2Y3Y2ZkMjU3YThi
-    NWQxOWNkYzQwYjhhZGFhMDYwMjM3MWNmMTU1ZmIxNTJiOTUwM2FlM2I0NWJm
-    ZDVlMjIzMGYyN2UyYTc0Y2FkZjI3ZDcxZmJkMjYxYmU2NWM4MDQ=
+    M2FjMTdhYTQ0NTM4M2E1MGIzZjZhMDcwNzI0MTBiNDY3NGM3YTYwOTcyMmM1
+    YjdiYmM2MjAyYTM2ODlmYTdmZTFiY2U2MDhmYTQ2OTdlYTMyZTI4MzZkOGZh
+    MWQ1YWMwMWIwODQ3NzdjNWY2MzFkODg3ZmM1ZjgzYmU0NDA1NTM=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_params (0.0.1pre2)
+    simple_params (0.0.2.pre1)
       activemodel (>= 3.0, < 5.0)
       virtus (>= 1.0.0)
 

data/README.md

@@ -29,8 +29,8 @@ All you need to do is create a class to specify accepted parameters and validati
 ```ruby
 class MyParams < SimpleParams::Params
   param :name
-  param :age, type: Integer
-  param :date_of_birth, type: Date, optional: true
+  param :age, type: :integer
+  param :date_of_birth, type: :date, optional: true
   param :hair_color, default: "brown", validations: { inclusion: { in: ["brown", "red", "blonde", "white"] }}
 
   nested_hash :address do
@@ -128,9 +128,9 @@ By default, params are assumed to be strings, so there is no need to specify Str
 ```ruby
 class CoercionParams < SimpleParams::Params
   param :name
-  param :age, type: Integer
-  param :date_of_birth, type: Date
-  param :pocket_change, type: BigDecimal
+  param :age, type: :integer
+  param :date_of_birth, type: :date
+  param :pocket_change, type: :decimal
 end
 
 params = CoercionParams.new(name: "Bob", age: "21", date_of_birth: "June 1st, 1980", pocket_change: "2.35")
@@ -152,6 +152,47 @@ class CoercionParams < SimpleParams::Params
 end
 ```
 
+# Formatters
+
+SimpleParams also provides a way to define a formatter for your attributes.  You can use either  Proc, or a method name.  If you do the latter, the method must accept an input value, which will be the un-formatted value of your attribute.
+
+```ruby
+class FormattedParams < SimpleParams::Params
+  param :name, formatter: :first_ten
+  param :age, formatter: lambda { |params, age| [age, 100].min }
+
+  def first_ten(val)
+    val.first(10)
+  end
+end
+
+params = FormattedParams.new(name: "Thomas Paine", age: 500)
+
+params.name #=> "Thomas Pai"
+params.age #=> 100
+```
+
+# Strict/Flexible Parameter Enforcement
+
+By default, SimpleParams will throw an error if you try to assign a parameter not defined within your class.  However, you can override this setting to allow for flexible parameter assignment.
+
+```ruby
+class FlexibleParams < SimpleParams::Params
+  allow_undefined_params
+  param :name
+  param :age
+end
+
+params = FlexibleParams.new(name: "Bryce", age: 30, weight: 160, dog: { name: "Bailey", breed: "Shiba Inu" })
+
+params.name #=> "Bryce"
+params.age #=> 30
+params.weight #=> 160
+params.dog.name #=> "Bailey"
+params.dog.breed #=> "Shiba Inu"
+```
+
+
 ## Contributing
 
 1. Fork it

data/lib/simple_params/attribute.rb

@@ -0,0 +1,62 @@
+require "active_model"
+require "virtus"
+
+module SimpleParams
+  class Attribute
+    TYPE_MAPPINGS = {
+      integer: Integer,
+      string: String,
+      decimal: BigDecimal,
+      datetime: DateTime,
+      date: Date,
+      time: Time,
+      float: Float,
+      boolean: Axiom::Types::Boolean, # See note on Virtus
+      array: Array,
+      hash: Hash
+    }
+
+    attr_reader :parent
+    attr_reader :name
+
+    def initialize(parent, name, opts={})
+      @parent = parent
+      @name = name.to_sym
+      @type = TYPE_MAPPINGS[opts[:type]]
+      @value = nil
+      @default = opts[:default]
+      @formatter = opts[:formatter]
+    end
+
+    def raw_value
+      @value.blank? ? default : @value
+    end
+
+    def value
+      return raw_value if raw_value.blank?
+      if @formatter.present?
+        Formatter.new(@parent, @formatter).format(raw_value)
+      else
+        raw_value
+      end
+    end
+
+    def value=(val)
+      @value = if @type.present?
+        virtus_attr = Virtus::Attribute.build(@type)
+        virtus_attr.coerce(val)
+      else
+        val
+      end
+    end
+
+  private
+    def default
+      if @default.is_a?(Proc)
+        @default.call(parent, self)
+      else
+        @default
+      end
+    end
+  end
+end

data/lib/simple_params/formatter.rb

@@ -0,0 +1,20 @@
+require "active_model"
+
+module SimpleParams
+  class Formatter
+    extend ActiveSupport::Concern
+
+    def initialize(attribute, formatter)
+      @attribute = attribute
+      @formatter = formatter
+    end
+
+    def format(value)
+      if @formatter.is_a?(Proc)
+        @formatter.call(@attribute, value)
+      else
+        @attribute.send(@formatter, value)
+      end
+    end
+  end
+end

data/lib/simple_params/params.rb

@@ -6,32 +6,40 @@ module SimpleParams
     include Virtus.model
     include ActiveModel::Validations
     include SimpleParams::Validations
-    include SimpleParams::Formatters
 
     class << self
-      TYPE_MAPPINGS = {
-        integer: Integer,
-        string: String,
-        decimal: BigDecimal,
-        datetime: DateTime,
-        date: Time,
-        time: DateTime,
-        float: Float,
-        boolean: Axiom::Types::Boolean, # See note on Virtus
-        array: Array,
-        hash: Hash
-      }
-
-      TYPE_MAPPINGS.each_pair do |sym, klass|
+      TYPES = [
+        :integer,
+        :string,
+        :decimal,
+        :datetime,
+        :date,
+        :time,
+        :float,
+        :boolean,
+        :array,
+        :hash
+      ]
+
+      TYPES.each do |sym|
         define_method("#{sym}_param") do |name, opts={}|
-          param(name, opts.merge(type: klass))
+          param(name, opts.merge(type: sym))
         end
       end
 
+      attr_accessor :strict_enforcement
+
+      def strict
+        @strict_enforcement = true
+      end
+
+      def allow_undefined_params
+        @strict_enforcement = false
+      end
+
       def param(name, opts={})
         define_attribute(name, opts)
         add_validations(name, opts)
-        add_formatters(name, opts)
       end
 
       def nested_hash(name, opts={}, &block)
@@ -47,14 +55,24 @@ module SimpleParams
         @nested_hashes || {}
       end
 
+      def defined_attributes
+        @define_attributes ||= {}
+      end
       private
+
       def define_attribute(name, opts = {})
-        type = opts[:type] || String
-        default = opts[:default]
-        if default.present?
-          attribute name, type, default: default
-        else
-          attribute name, type
+        opts[:type] ||= :string
+        defined_attributes[name.to_sym] = opts
+        attr_accessor "#{name}_attribute"
+
+        define_method("#{name}") do
+          attribute = send("#{name}_attribute")
+          attribute.send("value")
+        end
+
+        define_method("#{name}=") do |val|
+          attribute = send("#{name}_attribute")
+          attribute.send("value=", val)
         end
       end
 
@@ -64,13 +82,6 @@ module SimpleParams
         validates name, validations unless validations.empty?
       end
 
-      def add_formatters(name, opts = {})
-        formatter = opts[:format]
-        unless formatter.nil?
-          format name, formatter
-        end
-      end
-
       def define_nested_class(&block)
         Class.new(Params).tap do |klass|
           name_function = Proc.new {
@@ -85,41 +96,69 @@ module SimpleParams
     end
 
     def initialize(params={}, parent = nil)
+      # Set default strict params
+      if self.class.strict_enforcement.nil?
+        self.class.strict_enforcement = true
+      end
+
       @parent = parent
+      # Initializing Params
       @original_params = hash_to_symbolized_hash(params)
+      define_attributes(@original_params)
+
+      # Errors
       @nested_params = nested_hashes.keys
       @errors = SimpleParams::Errors.new(self, @nested_params)
-      initialize_nested_classes
+
+      # Nested Classes
       set_accessors(params)
-      run_formatters
-      # This method comes from Virtus
-      # virtus/lib/virtus/instance_methods.rb
-      set_default_attributes
+      initialize_nested_classes
+    end
+
+    def define_attributes(params)
+      self.class.defined_attributes.each_pair do |key, opts|
+        send("#{key}_attribute=", Attribute.new(self, key, opts))
+      end
+    end
+
+    # Overriding this method to allow for non-strict enforcement!
+    def method_missing(method_name, *arguments, &block)
+      if strict_enforcement?
+        raise SimpleParamsError, "parameter #{method_name} is not defined."
+      else
+        if @original_params.include?(method_name.to_sym)
+          value = @original_params[method_name.to_sym]
+          if value.is_a?(Hash)
+            define_anonymous_class(value)
+          else
+            Attribute.new(self, method_name).value = value
+          end
+        end
+      end
+    end
+
+    def respond_to?(method_name, include_private = false)
+      if strict_enforcement?
+        super
+      else
+        @original_params.include?(method_name.to_sym) || super
+      end
+    end
+
+    private
+    def strict_enforcement?
+      self.class.strict_enforcement
     end
 
-    protected
     def set_accessors(params={})
       params.each do |attribute_name, value| 
         # Don't set accessors for nested classes
         unless value.is_a?(Hash)
           send("#{attribute_name}=", value)
-          reset_blank_attributes
-        end
-      end
-    end
-
-    def reset_blank_attributes
-      # Reset to the default value for blank attributes
-      attributes.each do |attribute_name, value|
-        if send(attribute_name).blank?
-          # This method comes from Virtus
-          # virtus/lib/virtus/instance_methods.rb
-          reset_attribute(attribute_name)
         end
       end
     end
 
-    private
     def hash_to_symbolized_hash(hash)
       hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
     end
@@ -134,5 +173,18 @@ module SimpleParams
         send("#{key}=", klass.new(initialization_params, self))
       end
     end
+
+    def define_anonymous_class(hash)
+      klass = Class.new(Params).tap do |klass|
+        name_function = Proc.new {
+          def self.model_name
+            ActiveModel::Name.new(self, nil, "temp")
+          end
+        }
+        klass.class_eval(&name_function)
+      end
+      klass.allow_undefined_params
+      klass.new(hash)
+    end
   end
 end

data/lib/simple_params/simple_params_error.rb

@@ -0,0 +1,8 @@
+class SimpleParamsError < StandardError
+  attr_reader :original
+
+  def initialize(msg, original=nil)
+    super(msg)
+    @original = original
+  end
+end

data/lib/simple_params/version.rb

@@ -1,3 +1,3 @@
 module SimpleParams
-  VERSION = "0.0.2.pre1"
+  VERSION = "0.0.2.pre2"
 end

data/lib/simple_params.rb

@@ -1,5 +1,7 @@
 require 'simple_params/version'
-require 'simple_params/formatters'
+require 'simple_params/attribute'
+require 'simple_params/formatter'
 require 'simple_params/errors'
 require 'simple_params/validations'
 require 'simple_params/params'
+require 'simple_params/simple_params_error'

data/spec/attribute_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe SimpleParams::Attribute do
+  class House
+    def initialize(params={})
+      params.each { |k,v| send("#{k}=",v) }
+    end
+
+    attr_accessor :rooms, :rent
+
+    def name
+      "My house"
+    end
+
+    def capitalize(val)
+      val.upcase
+    end
+  end
+
+  let(:house) { House.new }
+
+  describe "attributes" do
+    let(:model) { described_class.new(house, "color")}
+
+    it "has correct parent attribute" do
+      model.parent.should eq(house)
+    end
+
+    it "has correct name attribute" do
+      model.name.should eq(:color)
+    end
+
+    describe "setting and getting value" do
+      let(:model) { described_class.new(house, "color")}
+
+      it "has nil value" do
+        model.value.should be_nil
+      end
+
+      it "can set value" do
+        model.value = "Dummy"
+        model.value.should eq("Dummy")
+      end
+    end
+  end
+
+  describe "coercion" do
+    context "without type" do
+      let(:model) { described_class.new(house, "color")}
+
+      it "does not coerce value" do
+        model.value = 1
+        model.value.should eq(1)
+      end
+    end
+
+    context "with :integer type" do
+      let(:model) { described_class.new(house, "color", { type: :integer })}
+
+      it "coerces values into Integer" do
+        model.value = "1"
+        model.value.should eq(1)
+      end
+    end
+
+    context "with :decimal type" do
+      let(:model) { described_class.new(house, "color", { type: :decimal })}
+
+      it "coerces values into BigDecimal" do
+        model.value = "1"
+        model.value.should eq(BigDecimal.new("1.0"))
+      end
+    end
+
+    context "with :float type" do
+      let(:model) { described_class.new(house, "color", { type: :float })}
+
+      it "coerces values into Float" do
+        model.value = "1"
+        model.value.should eq(1.0)
+      end
+    end
+
+    context "with :boolean type" do
+      let(:model) { described_class.new(house, "color", { type: :boolean })}
+
+      it "coerces values into Boolean" do
+        model.value = "0"
+        model.value.should be_falsey
+      end
+    end
+  end
+
+  describe "defaults" do
+    context "with static default" do
+      let(:model) { described_class.new(house, "color", { default: "something" })}
+
+      it "uses default when value not set" do
+        model.value.should eq("something")
+      end
+    end
+
+    context "with Proc default" do
+      let(:default) do
+        lambda { |parent, param| parent.name + " " + "rocks!" }
+      end
+      let(:model) { described_class.new(house, "color", { default: default })}
+
+      it "uses default when value not set" do
+        model.value.should eq("My house rocks!")
+      end
+    end
+  end
+
+  describe "formatter" do
+    context "with function reference" do
+      let(:model) { described_class.new(house, "color", { formatter: :capitalize })}
+
+      it "uses method formatter from parent" do
+        model.value = "lower"
+        model.value.should eq("LOWER")
+      end
+    end
+
+    context "with Proc formatter" do
+      let(:formatter) do
+        lambda { |parent, param| parent.name + " " + param.upcase }
+      end
+
+      let(:model) { described_class.new(house, "color", { formatter: formatter })}
+
+      it "uses Proc formatter on value" do
+        model.value = "rocks"
+        model.value.should eq("My house ROCKS")
+      end
+    end
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe SimpleParams::Formatter do
+  class MyAttribute
+    def some_function(value)
+      "dummy value = " + value
+    end
+  end
+
+  let(:attribute) { MyAttribute.new }
+
+  describe "formatting" do
+    context "with method name formatter" do
+      let(:formatter) { described_class.new(attribute, :some_function) }
+
+      it "calls the method on the attribute" do
+        formatter.format("myval").should eq("dummy value = myval")
+      end
+    end
+
+    context "with Proc default" do
+      let(:default) do
+        lambda { |attribute, value| attribute.some_function("other") + ", not #{value}" }
+      end
+
+      let(:formatter) { described_class.new(attribute, default) }
+
+      it "calls the Proc with attribute and value" do
+        formatter.format("myval").should eq("dummy value = other, not myval")
+      end
+    end
+  end
+end

data/spec/params_spec.rb

@@ -4,23 +4,23 @@ class DummyParams < SimpleParams::Params
   string_param :name
   integer_param :age, optional: true
   string_param :first_initial, default: lambda { |params, param| params.name[0] if params.name.present? }
-  decimal_param :amount, optional: true, default: 0.10, format: lambda { |params, param| param.round(2) }
-  param :color, default: "red", validations: { inclusion: { in: ["red", "green"] }}, format: :lower_case_colors
+  decimal_param :amount, optional: true, default: 0.10, formatter: lambda { |params, param| param.round(2) }
+  param :color, default: "red", validations: { inclusion: { in: ["red", "green"] }}, formatter: :lower_case_colors
 
   nested_hash :address do
     string_param :street
     string_param :city, validations: { length: { in: 4..40 } }
     string_param :zip_code, optional: true, validations: { length: { in: 5..9 } }
-    param :state, default: "North Carolina", format: :transform_state_code
+    param :state, default: "North Carolina", formatter: :transform_state_code
 
-    def transform_state_code
-      state == "SC" ? "South Carolina" : state
+    def transform_state_code(val)
+      val == "SC" ? "South Carolina" : val
     end
   end
 
   nested_hash :phone do
     boolean_param :cell_phone, default: true
-    string_param :phone_number, validations: { length: { in: 7..10 } }, format: lambda { |params, attribute| attribute.gsub(/\D/, "") }
+    string_param :phone_number, validations: { length: { in: 7..10 } }, formatter: lambda { |params, attribute| attribute.gsub(/\D/, "") }
     string_param :area_code, default: lambda { |params, param| 
       if params.phone_number.present? 
         params.phone_number[0..2] 
@@ -28,12 +28,45 @@ class DummyParams < SimpleParams::Params
     }
   end
 
-  def lower_case_colors
-    color.downcase
+  def lower_case_colors(val)
+    val.downcase
   end
 end
 
 describe SimpleParams::Params do
+  describe "strict parameter enforcement" do
+    context "with default handling (strict enforcement)" do
+      it "raises error on expected param" do
+        expect { DummyParams.new(other_param: 1) }.to raise_error(SimpleParamsError)
+      end
+    end
+
+    context "with strict enforcement" do
+      before(:each) do
+        DummyParams.strict
+      end
+
+      it "raises error on expected param" do
+        expect { DummyParams.new(other_param: 1) }.to raise_error(SimpleParamsError)
+      end
+    end
+
+    context "with allow_undefined_params" do
+      before(:each) do
+        DummyParams.allow_undefined_params
+      end
+
+      it "does not raises error on expected param" do
+        expect { DummyParams.new(other_param: 1) }.to_not raise_error
+      end
+
+      it "can access original value through accessor" do
+        model = DummyParams.new(other_param: 1)
+        model.other_param.should eq(1)
+      end
+    end
+  end
+
   describe "accessors", accessors: true do
     let(:params) { DummyParams.new }
 
@@ -250,4 +283,33 @@ describe SimpleParams::Params do
       end
     end
   end
+
+  describe "undefined params", undefined_params: true do
+    before(:each) do
+      DummyParams.allow_undefined_params
+    end
+
+    it "allows undefined params, and responds with their values" do
+      model = DummyParams.new(other_param: 1)
+      model.other_param.should eq(1)
+    end
+
+    describe "nested params" do
+      it "allows undefined nested params, and creates an anonymous Params class for them" do
+        model = DummyParams.new(nested: { some_value: 1 } )
+        model.nested.should be_a(SimpleParams::Params)
+      end
+
+      it "allows accessors for nested attributes" do
+        model = DummyParams.new(nested: { some_value: 1 } )
+        model.nested.some_value.should eq(1)
+      end
+
+      it "allows multilevel nested params, and creates an anonymous Params class for them" do
+        model = DummyParams.new(nested: { other_nested: { some_value: 1 } } )
+        model.nested.other_nested.should be_a(SimpleParams::Params)
+        model.nested.other_nested.some_value.should eq(1)
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -2,9 +2,8 @@ require 'rubygems'
 require 'bundler/setup'
 require 'simple_params'
 
-spec = Gem::Specification.find_by_name("simple_params")
-gem_root = spec.gem_dir
-Dir[("#{gem_root}/spec/support/**/*.rb")].each {|f| require f}
+Dir[("../spec/support/**/*.rb")].each {|f| require f}
+
 I18n.config.enforce_available_locales = true
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_params
 version: !ruby/object:Gem::Version
-  version: 0.0.2.pre1
+  version: 0.0.2.pre2
 platform: ruby
 authors:
 - brycesenz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-24 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -100,15 +100,18 @@ files:
 - Gemfile.lock
 - README.md
 - lib/simple_params.rb
+- lib/simple_params/attribute.rb
 - lib/simple_params/errors.rb
-- lib/simple_params/formatters.rb
+- lib/simple_params/formatter.rb
 - lib/simple_params/params.rb
+- lib/simple_params/simple_params_error.rb
 - lib/simple_params/validations.rb
 - lib/simple_params/version.rb
 - simple_params.gemspec
 - spec/acceptance_spec.rb
+- spec/attribute_spec.rb
 - spec/errors_spec.rb
-- spec/formatters_spec.rb
+- spec/formatter_spec.rb
 - spec/params_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/brycesenz/simple_params
@@ -131,13 +134,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A DSL for specifying params, including type coercion and validation
 test_files:
 - spec/acceptance_spec.rb
+- spec/attribute_spec.rb
 - spec/errors_spec.rb
-- spec/formatters_spec.rb
+- spec/formatter_spec.rb
 - spec/params_spec.rb
 - spec/spec_helper.rb

data/lib/simple_params/formatters.rb

@@ -1,41 +0,0 @@
-require "active_model"
-
-module SimpleParams
-  module Formatters
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def _formatters
-        @_formatters || {}
-      end
-
-      def format(attribute, formatter)
-        @_formatters ||= {}
-        @_formatters[attribute.to_sym] = formatter
-      end
-    end
-
-    def run_formatters
-      _formatters.each do |attribute, method|
-        value = send(attribute.to_sym)
-        unless value.blank?
-          out = evaluate_proc_or_method(attribute, method, value)
-          send("#{attribute.to_sym}=", out)
-        end
-      end
-    end
-
-    private
-    def evaluate_proc_or_method(attribute, method, value)
-      if method.is_a?(Proc)
-        method.call(self, value)
-      else
-        self.send(method)
-      end
-    end
-
-    def _formatters
-      self.class._formatters || {}
-    end
-  end
-end

data/spec/formatters_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe SimpleParams::Formatters do
-  class Racecar
-    include SimpleParams::Formatters
-
-    def initialize(params={})
-      params.each { |k,v| send("#{k}=",v) }
-      run_formatters
-    end
-
-    attr_accessor :make, :model
-
-    format :make, :strip_make_whitespace
-    format :model, lambda { |car, model| model.upcase }
-
-    def strip_make_whitespace
-      self.make.strip
-    end
-  end
-
-  describe "formatting with Procs" do
-    it "does not break if initial attribute is nil" do
-      car = Racecar.new
-      car.model.should be_nil
-    end
-
-    it "formats attribute on initialize" do
-      car = Racecar.new(make: "porsche", model: "boxster")
-      car.model.should eq("BOXSTER")
-    end
-  end
-
-  describe "formatting with methods" do
-    it "does not break if initial attribute is nil" do
-      car = Racecar.new
-      car.make.should be_nil
-    end
-
-    it "formats attribute on initialize" do
-      car = Racecar.new(make: "  Porsche     ")
-      car.make.should eq("Porsche")
-    end
-  end
-end