mutations 0.5.0

data/lib/mutations/input_filter.rb

@@ -0,0 +1,29 @@
+module Mutations
+  class InputFilter
+    @default_options = {}
+    
+    def self.default_options
+      @default_options
+    end
+    
+    attr_accessor :options
+    
+    def initialize(opts = {})
+      self.options = (self.class.default_options || {}).merge(opts)
+    end
+    
+    # returns -> [sanitized data, error]
+    # If an error is returned, then data will be nil
+    def filter(data)
+      [data, nil]
+    end
+    
+    def has_default?
+      self.options.has_key?(:default)
+    end
+    
+    def default
+      self.options[:default]
+    end
+  end
+end

data/lib/mutations/integer_filter.rb

@@ -0,0 +1,34 @@
+module Mutations
+  class IntegerFilter < InputFilter
+    @default_options = {
+      nils: false,       # true allows an explicit nil to be valid. Overrides any other options
+      # TODO: add strict
+      min: nil,          # lowest value, inclusive
+      max: nil           # highest value, inclusive
+    }
+    
+    def filter(data)
+      
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+      
+      # Ensure it's the correct data type (Fixnum)
+      if !data.is_a?(Fixnum)
+        if data.is_a?(String) && data =~ /^-?\d/
+          data = data.to_i
+        else
+          return [data, :integer]
+        end
+      end
+      
+      return [data, :min] if options[:min] && data < options[:min]
+      return [data, :max] if options[:max] && data > options[:max]
+      
+      # We win, it's valid!
+      [data, nil]
+    end
+  end
+end

data/lib/mutations/model_filter.rb

@@ -0,0 +1,52 @@
+module Mutations
+  class ModelFilter < InputFilter
+    @default_options = {
+      nils: false,        # true allows an explicit nil to be valid. Overrides any other options
+      class: nil,         # default is the attribute name.to_s.camelize.constantize.  This overrides it with class or class.constantize
+      builder: nil,       # Could be a class or a string which will be constantized. If present, and a hash is passed, then we use that to construct a model
+      new_records: false, # If false, unsaved AR records are not valid. Things that don't respond to new_record? are valid.  true: anything is valid
+    }
+    
+    def initialize(name, opts = {})
+      super(opts)
+      @name = name
+      
+      class_const = options[:class] || @name.to_s.camelize
+      class_const = class_const.constantize if class_const.is_a?(String)
+      self.options[:class] = class_const
+      
+      if options[:builder]
+        options[:builder] = options[:builder].constantize if options[:builder].is_a?(String)
+      end
+    end
+    
+    def filter(data)
+      
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+      
+      # Passing in attributes.  Let's see if we have a builder
+      if data.is_a?(Hash) && options[:builder]
+        ret = options[:builder].run(data)
+        
+        if ret.success?
+          data = ret.result
+        else
+          return [data, ret.errors]
+        end
+      end
+      
+      # We have a winner, someone passed in the correct data type!
+      if data.is_a?(options[:class])
+        return [data, :new_records] if !options[:new_records] && (data.respond_to?(:new_record?) && data.new_record?)
+        return [data, nil]
+      end
+      
+      return [data, :model]
+    end
+    
+  end
+end

data/lib/mutations/outcome.rb

@@ -0,0 +1,19 @@
+module Mutations
+  class Outcome
+    def initialize(is_success, result, errors)
+      @success, @result, @errors = is_success, result, errors
+    end
+    
+    def success?
+      @success
+    end
+
+    def result
+      @result
+    end
+
+    def errors
+      @errors
+    end
+  end
+end

data/lib/mutations/string_filter.rb

@@ -0,0 +1,54 @@
+module Mutations
+  class StringFilter < InputFilter
+    @default_options = {
+      strip: true,       # true calls data.strip if data is a string
+      strict: false,     # If false, then symbols, numbers, and booleans are converted to a string with to_s. # TODO: TEST
+      nils: false,       # true allows an explicit nil to be valid. Overrides any other options
+      empty: false,      # false disallows "".  true allows "" and overrides any other validations (b/c they couldn't be true if it's empty)
+      min_length: nil,   # Can be a number like 5, meaning that 5 codepoints are required
+      max_length: nil,   # Can be a number like 10, meaning that at most 10 codepoints are permitted
+      matches: nil,      # Can be a regexp
+      in: nil            # Can be an array like %w(red blue green)
+    }
+    
+    def filter(data)
+      
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+      
+      # At this point, data is not nil. If it's not a string, convert it to a string for some standard classes
+      data = data.to_s if !options[:strict] && [TrueClass, FalseClass, Fixnum, Symbol].include?(data.class)
+      
+      # Now ensure it's a string:
+      return [data, :string] unless data.is_a?(String)
+      
+      # At this point, data is a string.  Now transform it using strip:
+      data = data.strip if options[:strip]
+      
+      # Now check if it's blank:
+      if data == ""
+        if options[:empty]
+          return [data, nil]
+        else
+          return [data, :empty]
+        end
+      end
+      
+      # Now check to see if it's the correct size:
+      return [data, :min_length] if options[:min_length] && data.length < options[:min_length]
+      return [data, :max_length] if options[:max_length] && data.length > options[:max_length]
+      
+      # Ensure it match
+      return [data, :in] if options[:in] && !options[:in].include?(data)
+      
+      # Ensure it matches the regexp
+      return [data, :matches] if options[:matches] && (options[:matches] !~ data)
+      
+      # We win, it's valid!
+      [data, nil]
+    end
+  end
+end

data/lib/mutations/version.rb

@@ -0,0 +1,3 @@
+module Mutations
+  VERSION = "0.5.0"
+end

data/mutations.gemspec

@@ -0,0 +1,19 @@
+require './lib/mutations/version'
+
+Gem::Specification.new do |s|
+  s.name = 'mutations'
+  s.version = Mutations::VERSION
+  s.author = 'Jonathan Novak'
+  s.email = 'jnovak@gmail.com'
+  s.homepage = 'http://github.com/cypriss/mutations'
+  s.summary = s.description = 'Compose your business logic into commands that sanitize and validate input.'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files test`.split("\n")
+  s.require_path = 'lib'
+
+  s.add_dependency 'activesupport'
+  s.add_development_dependency 'minitest', '~> 4'
+  
+  s.required_ruby_version = '>= 1.9.2'
+end

data/spec/array_filter_spec.rb

@@ -0,0 +1,150 @@
+require_relative 'spec_helper'
+
+describe "Mutations::ArrayFilter" do
+  
+  it "allows arrays" do
+    f = Mutations::ArrayFilter.new(:arr)
+    filtered, errors = f.filter([1])
+    assert_equal [1], filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers non-arrays to be invalid" do
+    f = Mutations::ArrayFilter.new(:arr)
+    ['hi', true, 1, {a: "1"}, Object.new].each do |thing|
+      filtered, errors = f.filter(thing)
+      assert_equal :array, errors
+    end
+  end
+  
+  it "considers nil to be invalid" do
+    f = Mutations::ArrayFilter.new(:arr, nils: false)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+  
+  it "considers nil to be valid" do
+    f = Mutations::ArrayFilter.new(:arr, nils: true)
+    filtered, errors = f.filter(nil)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, errors
+  end
+  
+  it "lets you specify a class, and has valid elements" do
+    f = Mutations::ArrayFilter.new(:arr, class: Fixnum)
+    filtered, errors = f.filter([1,2,3])
+    assert_equal nil, errors
+    assert_equal [1,2,3], filtered
+  end
+  
+  it "lets you specify a class as a string, and has valid elements" do
+    f = Mutations::ArrayFilter.new(:arr, class: 'Fixnum')
+    filtered, errors = f.filter([1,2,3])
+    assert_equal nil, errors
+    assert_equal [1,2,3], filtered
+  end
+  
+  it "lets you specify a class, and has invalid elements" do
+    f = Mutations::ArrayFilter.new(:arr, class: Fixnum)
+    filtered, errors = f.filter([1, "bob"])
+    assert_equal [nil, :class], errors.symbolic
+    assert_equal [1,"bob"], filtered
+  end
+  
+  it "lets you use a block to supply an element filter" do
+    f = Mutations::ArrayFilter.new(:arr) { string }
+    
+    filtered, errors = f.filter(["hi", {stuff: "ok"}])
+    assert_nil errors[0]
+    assert_equal :string, errors[1].symbolic
+  end
+  
+  it "lets you array-ize everything" do
+    f = Mutations::ArrayFilter.new(:arr, arrayize: true) { string }
+    
+    filtered, errors = f.filter("foo")
+    assert_equal ["foo"], filtered
+    assert_nil errors
+  end
+  
+  it "lets you array-ize an empty string" do
+    f = Mutations::ArrayFilter.new(:arr, arrayize: true) { string }
+    
+    filtered, errors = f.filter("")
+    assert_equal [], filtered
+    assert_nil errors
+  end
+  
+  it "lets you pass integers in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) { integer min: 4 }
+    
+    filtered, errors = f.filter([5,6,1,"bob"])
+    assert_equal [5,6,1,"bob"], filtered
+    assert_equal [nil, nil, :min, :integer], errors.symbolic
+  end
+  
+  it "lets you pass booleans in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) { boolean }
+    
+    filtered, errors = f.filter([true, false, "1"])
+    assert_equal [true, false, true], filtered
+    assert_equal nil, errors
+  end
+  
+  it "lets you pass model in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) { model :string }
+    
+    filtered, errors = f.filter(["hey"])
+    assert_equal ["hey"], filtered
+    assert_equal nil, errors
+  end
+  
+  it "lets you pass hashes in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) do
+      hash do
+        required do
+          string :foo
+          integer :bar
+        end
+        
+        optional do
+          boolean :baz
+        end
+      end
+    end
+    
+    filtered, errors = f.filter([{foo: "f", bar: 3, baz: true}, {foo: "f", bar: 3}, {foo: "f"}])
+    assert_equal [{:foo=>"f", :bar=>3, :baz=>true}, {:foo=>"f", :bar=>3}, {:foo=>"f"}], filtered
+    
+    assert_equal nil, errors[0]
+    assert_equal nil, errors[1]
+    assert_equal ({"bar"=>:required}), errors[2].symbolic
+  end
+  
+  it "lets you pass arrays of arrays" do
+    f = Mutations::ArrayFilter.new(:arr) do
+      array do
+        string
+      end
+    end
+    
+    filtered, errors = f.filter([["h", "e"], ["l"], [], ["lo"]])
+    assert_equal filtered, [["h", "e"], ["l"], [], ["lo"]]
+    assert_equal nil, errors
+  end
+  
+  it "handles errors for arrays of arrays" do
+    f = Mutations::ArrayFilter.new(:arr) do
+      array do
+        string
+      end
+    end
+    
+    filtered, errors = f.filter([["h", "e", {}], ["l"], [], [""]])
+    assert_equal [[nil, nil, :string], nil, nil, [:empty]], errors.symbolic
+    assert_equal [[nil, nil, "Array[2] isn't a string"], nil, nil, ["Array[0] can't be blank"]], errors.message
+    assert_equal ["Array[2] isn't a string", "Array[0] can't be blank"], errors.message_list
+  end
+  
+end

data/spec/boolean_filter_spec.rb

@@ -0,0 +1,55 @@
+require_relative 'spec_helper'
+
+describe "Mutations::BooleanFilter" do
+  
+  it "allows booleans" do
+    f = Mutations::BooleanFilter.new
+    filtered, errors = f.filter(true)
+    assert_equal true, filtered
+    assert_equal nil, errors
+    
+    filtered, errors = f.filter(false)
+    assert_equal false, filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers non-booleans to be invalid" do
+    f = Mutations::BooleanFilter.new
+    [[true], {a: "1"}, Object.new].each do |thing|
+      filtered, errors = f.filter(thing)
+      assert_equal :boolean, errors
+    end
+  end
+  
+  it "considers nil to be invalid" do
+    f = Mutations::BooleanFilter.new(nils: false)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+  
+  it "considers nil to be valid" do
+    f = Mutations::BooleanFilter.new(nils: true)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+  
+  it "considers certain strings to be valid booleans" do
+    f = Mutations::BooleanFilter.new
+    [["true", true], ["TRUE", true], ["TrUe", true], ["1", true], ["false", false], ["FALSE", false], ["FalSe", false], ["0", false], [0, false], [1, true]].each do |(str, v)|
+      filtered, errors = f.filter(str)
+      assert_equal v, filtered
+      assert_equal nil, errors
+    end
+  end
+  
+  it "considers other string to be invalid" do
+    f = Mutations::BooleanFilter.new
+    ["", "truely", "2"].each do |str|
+      filtered, errors = f.filter(str)
+      assert_equal str, filtered
+      assert_equal :boolean, errors
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,183 @@
+require_relative 'spec_helper'
+require 'simple_command'
+
+describe "Command" do
+  
+  describe "SimpleCommand" do
+    it "should allow valid in put in" do
+      outcome = SimpleCommand.run(name: "John", email: "john@gmail.com", amount: 5)
+
+      assert outcome.success?
+      assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.result
+      assert_equal nil, outcome.errors
+    end
+    
+    it "should filter out spurious params" do
+      outcome = SimpleCommand.run(name: "John", email: "john@gmail.com", amount: 5, buggers: true)
+      
+      assert outcome.success?
+      assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.result
+      assert_equal nil, outcome.errors
+    end
+    
+    it "should discover errors in inputs" do
+      outcome = SimpleCommand.run(name: "JohnTooLong", email: "john@gmail.com")
+      
+      assert !outcome.success?
+      assert :length, outcome.errors.symbolic[:name]
+    end
+    
+    it "shouldn't throw an exception with run!" do
+      result = SimpleCommand.run!(name: "John", email: "john@gmail.com", amount: 5)
+      assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, result
+    end
+    
+    it "should throw an exception with run!" do
+      assert_raises Mutations::ValidationException do
+        result = SimpleCommand.run!(name: "John", email: "john@gmail.com", amount: "bob")
+      end
+    end
+    
+    it "should merge multiple hashes" do
+      outcome = SimpleCommand.run({name: "John", email: "john@gmail.com"}, {email: "bob@jones.com", amount: 5})
+      
+      assert outcome.success?
+      assert_equal ({name: "John", email: "bob@jones.com", amount: 5}).stringify_keys, outcome.result
+    end
+    
+    it "should merge hashes indifferently" do
+      outcome = SimpleCommand.run({name: "John", email: "john@gmail.com"}, {"email" => "bob@jones.com", "amount" => 5})
+      
+      assert outcome.success?
+      assert_equal ({name: "John", email: "bob@jones.com", amount: 5}).stringify_keys, outcome.result
+    end
+    
+    it "shouldn't accept non-hashes" do
+      assert_raises ArgumentError do
+        outcome = SimpleCommand.run(nil)
+      end
+      
+      assert_raises ArgumentError do
+        outcome = SimpleCommand.run(1)
+      end
+    end
+    
+    it "should accept nothing at all" do
+      SimpleCommand.run # make sure nothing is raised
+    end
+  end
+  
+  describe "EigenCommand" do
+    class EigenCommand < Mutations::Command
+  
+      required { string :name }
+      optional { string :email }
+  
+      def execute
+        {name: name, email: email}
+      end
+    end
+  
+    it "should define getter methods on params" do
+      mutation = EigenCommand.run(name: "John", email: "john@gmail.com")
+      assert_equal ({name: "John", email: "john@gmail.com"}), mutation.result
+    end
+  end
+  
+  describe "MutatatedCommand" do
+    class MutatatedCommand < Mutations::Command
+  
+      required { string :name }
+      optional { string :email }
+  
+      def execute
+        self.name, self.email = "bob", "bob@jones.com"
+        {name: inputs[:name], email: inputs[:email]}
+      end
+    end
+  
+    it "should define setter methods on params" do
+      mutation = MutatatedCommand.run(name: "John", email: "john@gmail.com")
+      assert_equal ({name: "bob", email: "bob@jones.com"}), mutation.result
+    end
+  end
+  
+  describe "ErrorfulCommand" do
+    class ErrorfulCommand < Mutations::Command
+  
+      required { string :name }
+      optional { string :email }
+  
+      def execute
+        add_error("bob", :is_a_bob)
+        
+        1
+      end
+    end
+  
+    it "should let you add errors" do
+      outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
+      
+      assert !outcome.success?
+      assert_nil outcome.result
+      assert :is_a_bob, outcome.errors.symbolic[:bob]
+    end
+  end
+  
+  describe "MultiErrorCommand" do
+    class ErrorfulCommand < Mutations::Command
+  
+      required { string :name }
+      optional { string :email }
+  
+      def execute
+        moar_errors = Mutations::ErrorHash.new
+        moar_errors[:bob] = Mutations::ErrorAtom.new(:bob, :is_short)
+        moar_errors[:sally] = Mutations::ErrorAtom.new(:sally, :is_fat)
+        
+        merge_errors(moar_errors)
+        
+        1
+      end
+    end
+  
+    it "should let you merge errors" do
+      outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
+      
+      assert !outcome.success?
+      assert_nil outcome.result
+      assert :is_short, outcome.errors.symbolic[:bob]
+      assert :is_fat, outcome.errors.symbolic[:sally]
+    end
+  end
+  
+  describe "PresentCommand" do
+    class PresentCommand < Mutations::Command
+  
+      optional do
+        string :email
+        string :name
+      end
+  
+      def execute
+        if name_present? && email_present?
+          1
+        elsif !name_present? && email_present?
+          2
+        elsif name_present? && !email_present?
+          3
+        else
+          4
+        end
+      end
+    end
+  
+    it "should handle *_present? methods" do
+      assert_equal 1, PresentCommand.run!(name: "John", email: "john@gmail.com")
+      assert_equal 2, PresentCommand.run!(email: "john@gmail.com")
+      assert_equal 3, PresentCommand.run!(name: "John")
+      assert_equal 4, PresentCommand.run!
+    end
+  end
+  
+end