attribute_sanitizer 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    attribute_sanitizer (0.0.1)
+      activesupport
+      i18n
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.9)
+    i18n (0.6.0)
+    mocha (0.9.12)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  attribute_sanitizer!
+  mocha
+  shoulda

data/README.md

@@ -0,0 +1,57 @@
+AttributeSanitizer - DSL for specifiying steps to sanitize input.
+=================================================================
+
+Example
+-------
+
+    class Foo
+      include AttributeSanitizer::Helpers
+
+      sanitize_attributes do
+        remap :bagel => :bagels
+        remap :bagels => :bagels_attributes
+        ensure_array :bagels_attributes
+      end
+    end
+
+Subsequently calling this method with a hash will apply the sanitization
+steps, in the order declared, sanitizing the hash.
+
+    attrs = { :bagel => { :flavor => "blueberry" } }
+
+    Foo.sanitize_attributes(attrs)
+
+    attrs # => { :bagels_attributes => [ { :flavor => "blueberry" } ] }
+
+You can also pass a non-hash value.  The steps for sanitization must know
+what to do with whatever you pass in.  Here's an example using a custom
+defined step:
+
+    class Foo
+      sanitize_attributes do
+        add_step :split_on_commas # bad example
+      end
+
+      def self.split_on_commas(val)
+        if val.is_a?(String)
+          val.split(",")
+        else
+          val
+        end
+      end
+    end
+
+    Foo.sanitize_attributes("1,2,3") # => ["1", "2", "3"]
+
+Why?
+----
+
+I created this for a project where I had to deal with input that didn't
+quite conform to my models, and I didn't want to change the API of my
+application to facilitate non-conforming inputs.
+
+License
+-------
+
+AttributeSanitizer is Copyright © 2011 Jim Garvin. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.
+

data/lib/attribute_sanitizer.rb

@@ -0,0 +1,23 @@
+require 'active_support'
+require "attribute_sanitizer_helpers"
+require "attribute_sanitizer_dsl"
+
+class AttributeSanitizer
+  attr_accessor :sanitization_steps, :method_delegate
+  include DSL
+
+  def initialize(method_delegate)
+    self.sanitization_steps = []
+    self.method_delegate = method_delegate
+  end
+
+  # Applies sanitization steps to provided ata.
+  #
+  # @param [Object] the data to be sanitized
+  #
+  # @return [Object] the sanitized data
+  def sanitize(attrs)
+    sanitization_steps.inject(attrs) { |new_attrs, step| step.call(new_attrs) }
+  end
+end
+

data/lib/attribute_sanitizer_dsl.rb

@@ -0,0 +1,93 @@
+require 'active_support/inflector'
+require "active_support/core_ext/string"
+
+class AttributeSanitizer
+  module DSL
+
+    # Adds a step to the sanitization routine.
+    #
+    # If passed a block, that block is added as a step.
+    #
+    # If passed a symbol or string, then a custom step will be added that calls
+    # that method on the method_delegate (typically your class).
+    def add_step(method=nil, &block)
+      if block_given?
+        sanitization_steps << block
+      elsif method
+        add_step { |attrs| method_delegate.send(method, attrs) }
+      end
+    end
+
+    # Adds a step that renames a hash key.
+    #
+    # @parameter [Hash] describing the remap action
+    #
+    # @example
+    #   remap :foo => :bar
+    def remap(mapping)
+      from = mapping.keys.first
+      to   = mapping[from]
+      add_step do |attrs|
+        attrs[to] = attrs.delete(from) if attrs.has_key?(from)
+        attrs
+      end
+    end
+
+    # Adds a step that ensures that a hash value is an array
+    #
+    # @parameter [Object] the key whose value we want to be an array
+    #
+    # @example
+    #   ensure_array :bagels_attributes
+    def ensure_array(field)
+      add_step do |attrs|
+        if attrs.has_key?(field) && !attrs[field].is_a?(Array)
+          attrs[field] = [attrs[field]]
+        end
+        attrs
+      end
+    end
+
+    # Adds a step that iterates over items in array and calls sanitize_attributes
+    # using the specified class.
+    #
+    # @parameter [Hash] descriping the field and class
+    #
+    # @example
+    #   sanitize_nested_attributes :bagels_attributes => Bagel
+    def sanitize_nested_attributes(mapping)
+      key   = mapping.keys.first
+      klass = mapping[key]
+      add_step do |attrs|
+        if attrs.has_key?(key)
+          attrs[key].compact.map! { |h| klass.sanitize_attributes(h) }
+        end
+        attrs
+      end
+    end
+
+    # Adds several steps that can be useful when dealing with
+    # accepts_nested_attributes_for in Rails projects.
+    #
+    # @parameter [Object] association name
+    #
+    # @example
+    #   sanitize_has_many :bagels
+    #
+    # This is equivalent to:
+    #   remap :bagel => :bagels_attributes
+    #   remap :bagels => :bagels_attributes
+    #   ensure_array :bagels_attributes
+    #   sanitize_nested_attributes :bagels_attributes => Bagel
+    def sanitize_has_many(association_name)
+      association_name = association_name.to_s
+      singular_name    = association_name.singularize
+      nested_name      = "#{association_name}_attributes"
+      klass            = association_name.singularize.camelize.constantize
+      remap singular_name    => nested_name
+      remap association_name => nested_name
+      ensure_array nested_name
+      sanitize_nested_attributes nested_name => klass
+    end
+  end
+end

data/lib/attribute_sanitizer_helpers.rb

@@ -0,0 +1,61 @@
+class AttributeSanitizer
+  module Helpers
+
+    # When called with a block this will instantiate a new AttributeSanitizer and
+    # call the block using instance_eval.  The DSL methods for sanitizing
+    # attributes may be called inside of the block.
+    #
+    # Example:
+    #
+    # class Foo
+    #   include AttributeSanitizer::Helpers
+    #
+    #   sanitize_attributes do
+    #     remap :bagel => :bagels
+    #     remap :bagels => :bagels_attributes
+    #     ensure_array :bagels_attributes
+    #   end
+    # end
+    #
+    # Subsequently calling this method with a hash will apply the sanitization
+    # steps, in the order declared, sanitizing the hash.
+    #
+    # attrs = { :bagel => { :flavor => "blueberry" } }
+    #
+    # Foo.sanitize_attributes(attrs)
+    #
+    # attrs # => { :bagels_attributes => [ { :flavor => "blueberry" } ] }
+    #
+    # You can also pass a non-hash value.  The steps for sanitization must know
+    # what to do with whatever you pass in.  Here's an example using a custom
+    # defined step:
+    #
+    # class Foo
+    #   sanitize_attributes do
+    #     add_step :split_on_commas # bad example
+    #   end
+    #
+    #   def self.split_on_commas(val)
+    #     if val.is_a?(String)
+    #       val.split(",")
+    #     else
+    #       val
+    #     end
+    #   end
+    # end
+    #
+    # Foo.sanitize_attributes("1,2,3") # => ["1", "2", "3"]
+    def sanitize_attributes(attrs=nil, &block)
+      if attrs
+        return attrs unless @_attribute_sanitizer
+        @_attribute_sanitizer.sanitize(attrs)
+      elsif block_given?
+        @_attribute_sanitizer = AttributeSanitizer.new(self)
+        @_attribute_sanitizer.instance_eval(&block)
+      else
+        raise "sanitize_attributes needs an argument"
+      end
+    end
+
+  end
+end

data/test/attribute_sanitizer_test.rb

@@ -0,0 +1,100 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'attribute_sanitizer'
+
+class Bagel
+  extend AttributeSanitizer::Helpers
+end
+
+class TestAttributeSanitizer < Test::Unit::TestCase
+  def setup
+    @sanitizer = AttributeSanitizer.new(self)
+  end
+
+  context "#sanitize with no steps" do
+    should "do nothing" do
+      sanitized = @sanitizer.sanitize("foo")
+      assert_equal "foo", sanitized
+    end
+  end
+
+  context "#add_steps with a block" do
+  end
+
+  context "#add_steps" do
+    should "add named method as a step" do
+      @sanitizer.add_step :stringify
+      assert_equal "1", @sanitizer.sanitize(1)
+    end
+
+    should "add block as a step" do
+      @sanitizer.add_step { |val| val.to_i }
+      assert_equal 1, @sanitizer.sanitize("1")
+    end
+  end
+
+  context "#remap" do
+    should "rename a hash key" do
+      @sanitizer.remap :foo => :bar
+      assert_equal({ bar: 1 }, @sanitizer.sanitize(foo: 1))
+    end
+  end
+
+  context "#ensure_array" do
+    setup do
+      @sanitizer.ensure_array :foo
+    end
+
+    should "wrap a non-array value in array" do
+      assert_equal({ foo: [1] }, @sanitizer.sanitize(foo: 1))
+    end
+
+    should "not wrap array value in array" do
+      assert_equal({ foo: [1] }, @sanitizer.sanitize(foo: [1]))
+    end
+
+    should "not mess with nested arrays" do
+      assert_equal({ foo: [[1,2], [3, 4]] }, @sanitizer.sanitize(foo: [[1,2], [3,4]]))
+    end
+  end
+
+  context "#sanitize_nested_attributes" do
+    setup do
+      @sanitizer.sanitize_nested_attributes :foos_attributes => Bagel
+    end
+
+    should "iterate over elements and call sanitize_attributes on each one with given class" do
+      Bagel.expects(:sanitize_attributes).times(3)
+      @sanitizer.sanitize(foos_attributes: [1,2,3])
+    end
+  end
+
+  context "#sanitize_has_many" do
+    setup do
+      @sanitizer = AttributeSanitizer.new(Bagel)
+    end
+    should "add steps to for sanitizing nested attributes for the typical has many association" do
+      @sanitizer.expects(:remap).with("bagel"  => "bagels_attributes")
+      @sanitizer.expects(:remap).with("bagels" => "bagels_attributes")
+      @sanitizer.expects(:ensure_array).with("bagels_attributes")
+      @sanitizer.expects(:sanitize_nested_attributes).with("bagels_attributes" => Bagel)
+      @sanitizer.sanitize_has_many :bagels
+    end
+  end
+
+  context "#sanitize_attributes" do
+    should "let us add sanitization steps and also run sanitization steps on input" do
+      Bagel.sanitize_attributes do
+        remap :foo => :bar
+      end
+      assert_equal({bar: 1}, Bagel.sanitize_attributes(foo: 1))
+    end
+  end
+
+  def stringify(val)
+    val.to_s
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: attribute_sanitizer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Garvin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: DSL for sanitizing inputs.
+email: jim@thegarvin.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/attribute_sanitizer.rb
+- lib/attribute_sanitizer_dsl.rb
+- lib/attribute_sanitizer_helpers.rb
+- test/attribute_sanitizer_test.rb
+homepage: 
+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.5
+signing_key: 
+specification_version: 3
+summary: DSL for sanitizing inputs.
+test_files: []
+