objective 0.1.0

data/lib/objective/filters/integer_filter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class IntegerFilter < Objective::Filter
+      private
+
+      def coerce(datum)
+        return datum if datum.blank?
+
+        datum_str = raw_to_string(datum)
+        return datum unless datum_str
+
+        clean_str = datum_str.tr(options.delimiter, '').tr(options.decimal_mark, '.')
+        return datum unless clean_str =~ /\A[-+]?\d*\.?0*\z/
+        clean_str.to_i
+      end
+
+      def raw_to_string(raw)
+        if raw.is_a?(Float)
+          raw.to_s
+        elsif raw.is_a?(BigDecimal)
+          raw.to_s('F')
+        elsif raw.is_a?(String)
+          raw
+        end
+      end
+
+      def coerce_error(coerced)
+        return :integer unless coerced.is_a?(Integer)
+      end
+
+      def validate(coerced)
+        return :in unless included?(coerced)
+        return :min unless above_min?(coerced)
+        return :max unless below_max?(coerced)
+        return :scale unless within_scale?(coerced)
+      end
+
+      def included?(datum)
+        return true if options.in.nil?
+        options.in.include?(datum)
+      end
+
+      def above_min?(datum)
+        return true if options.min.nil?
+        datum >= options.min
+      end
+
+      def below_max?(datum)
+        return true if options.max.nil?
+        datum <= options.max
+      end
+
+      def within_scale?(datum)
+        return true if options.scale.nil?
+        (datum - datum.round(options.scale)).zero?
+      end
+    end
+  end
+end

data/lib/objective/filters/model_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class ModelFilter < Objective::Filter
+      private
+
+      def coerce_error(coerced)
+        return :model unless coerced.is_a?(class_constant)
+      end
+
+      def validate(coerced)
+        return :new_records if !options.new_records && (coerced.respond_to?(:new_record?) && coerced.new_record?)
+      end
+
+      def class_constant
+        klass = options[:class]
+        return key.to_s.camelize.constantize if klass.nil?
+        return klass if klass.instance_of? Class
+        klass.to_s.constantize
+      end
+    end
+  end
+end

data/lib/objective/filters/root_filter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class RootFilter < Objective::Filter
+      def filter(&block)
+        instance_eval(&block)
+      end
+
+      def keys
+        sub_filters.map(&:key)
+      end
+
+      def feed(*raw)
+        result = OpenStruct.new
+        result.raw = raw
+        result.coerced = coerce(raw)
+
+        inputs = OpenStruct.new
+        errors = Objective::Errors::ErrorHash.new
+
+        data = result.coerced
+        sub_filters_hash.each_pair do |key, key_filter|
+          datum = data.to_h.key?(key) ? data[key] : Objective::NONE
+          key_filter_result = key_filter.feed(datum)
+          next if key_filter_result == Objective::DISCARD
+
+          sub_data = key_filter_result.inputs
+          sub_error = key_filter_result.errors
+
+          if sub_error.nil?
+            inputs[key] = sub_data
+          else
+            errors[key] = key_filter.handle_errors(sub_error)
+          end
+        end
+
+        result.inputs = inputs
+        result.errors = errors.present? ? errors : nil
+        result
+      end
+
+      def coerce(raw)
+        raw.each_with_object(OpenStruct.new) do |datum, result|
+          raise_argument_error unless datum.respond_to?(:each_pair)
+          datum.each_pair { |key, value| result[key] = value }
+        end
+      end
+
+      def raise_argument_error
+        raise(ArgumentError, 'All Objective arguments must be a Hash or OpenStruct')
+      end
+    end
+  end
+end

data/lib/objective/filters/string_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class StringFilter < Objective::Filter
+      def coerce(raw)
+        return raw unless raw.is_a?(String) || coercable?(raw)
+        tmp = raw.is_a?(BigDecimal) ? raw.to_s(options.decimal_format) : raw.to_s
+        tmp = tmp.gsub(/[^[:print:]\t\r\n]+/, ' ') unless options.allow_control_characters
+        tmp = tmp.strip if options.strip
+        tmp
+      end
+
+      def coercable?(raw)
+        options.coercable_classes.map { |klass| raw.is_a?(klass) }.any?
+      end
+
+      def coerce_error(coerced)
+        return :string unless coerced.is_a?(String)
+      end
+
+      def validate(coerced)
+        return :empty if coerced.empty?
+        return :min if options.min && coerced.length < options.min
+        return :max if options.max && coerced.length > options.max
+        return :in if options.in && !options.in.include?(coerced)
+        return :matches if options.matches && (options.matches !~ coerced)
+      end
+    end
+  end
+end

data/lib/objective/filters/time_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class TimeFilter < Objective::Filter
+      private
+
+      def coerce(raw)
+        return raw if raw.is_a?(Time)
+        return parse(raw) if raw.is_a?(String)
+        return raw.to_time if raw.respond_to?(:to_time)
+        raw
+      end
+
+      def parse(raw)
+        options.format ? Time.strptime(raw, options.format) : Time.parse(raw)
+      rescue ArgumentError
+        nil
+      end
+
+      def coerce_error(coerced)
+        return :time unless coerced.is_a?(Time)
+      end
+
+      def validate(coerced)
+        return :after if options.after && coerced <= options.after
+        return :before if options.before && coerced >= options.before
+      end
+    end
+  end
+end

data/lib/objective/filters.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    Config = OpenStruct.new
+
+    Config.any = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::ALLOW,
+      invalid: Objective::DENY
+    )
+
+    Config.array = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      wrap: false
+    )
+
+    Config.boolean = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      coercion_map: {
+        'true' => true,
+        'false' => false,
+        '1' => true,
+        '0' => false
+      }.freeze
+    )
+
+    Config.date = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      format: nil, # If nil, Date.parse will be used for coercion. If something like "%Y-%m-%d", Date.strptime is used
+      after: nil,  # A date object, representing the minimum date allowed, inclusive
+      before: nil  # A date object, representing the maximum date allowed, inclusive
+    )
+
+    Config.decimal = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      delimiter: ', ',
+      decimal_mark: '.',
+      min: nil,
+      max: nil,
+      scale: nil
+    )
+
+    Config.duck = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      methods: nil
+    )
+
+    Config.file = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      upload: false,
+      size: nil
+    )
+
+    Config.float = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      delimiter: ', ',
+      decimal_mark: '.',
+      min: nil,
+      max: nil,
+      scale: nil
+    )
+
+    Config.hash = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY
+    )
+
+    Config.integer = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      delimiter: ', ',
+      decimal_mark: '.',
+      min: nil,
+      max: nil,
+      scale: nil,
+      in: nil
+    )
+
+    Config.model = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      class: nil,
+      new_records: false
+    )
+
+    Config.root = OpenStruct.new
+
+    Config.string = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      allow_control_characters: false,
+      strip: true,
+      empty: Objective::DENY,
+      min: nil,
+      max: nil,
+      in: nil,
+      matches: nil,
+      decimal_format: 'F',
+      coercable_classes: [
+        Symbol,
+        TrueClass,
+        FalseClass,
+        Integer,
+        Float,
+        BigDecimal
+      ].freeze
+    )
+
+    Config.time = OpenStruct.new(
+      none: Objective::DENY,
+      nils: Objective::DENY,
+      invalid: Objective::DENY,
+      format: nil,
+      after: nil,
+      before: nil
+    )
+
+    def self.config
+      yield Config
+    end
+  end
+end

data/lib/objective/none.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'singleton'
+
+module Objective
+  class None
+    include Singleton
+  end
+end
+
+Objective::NONE = Objective::None.instance.freeze

data/lib/objective/outcome.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Objective
+  class Outcome < OpenStruct
+  end
+end

data/lib/objective/unit.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+module Objective
+  module Unit
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :inputs, :raw_inputs, :built
+      const_set('ALLOW', Objective::ALLOW)
+      const_set('DENY', Objective::DENY)
+      const_set('DISCARD', Objective::DISCARD)
+    end
+
+    class_methods do
+      def filter(&block)
+        root_filter.filter(&block)
+        root_filter.keys.each do |key|
+          define_method(key) { inputs[key] }
+        end
+      end
+
+      def root_filter
+        @root_filter ||=
+          superclass.try(:root_filter).try(:dup) ||
+          Objective::Filters::RootFilter.new
+      end
+
+      def build(*args)
+        new.build(*args)
+      end
+
+      def build!(*args)
+        outcome = build(*args)
+        return outcome.result if outcome.success
+        raise Objective::ValidationError, outcome.errors
+      end
+
+      def run(*args)
+        new.run(*args)
+      end
+
+      def run!(*args)
+        outcome = run(*args)
+        return outcome.result if outcome.success
+        raise Objective::ValidationError, outcome.errors
+      end
+    end
+
+    # INSTANCE METHODS
+
+    def build(*args)
+      filter_result = self.class.root_filter.feed(*args)
+      @raw_inputs = filter_result.coerced
+      @inputs = filter_result.inputs
+      @errors = filter_result.errors
+      @built = true
+      try('validate') if valid?
+      outcome
+    end
+
+    def run(*args)
+      build(*args) unless built
+      result = valid? ? try('execute') : nil
+      outcome(result)
+    end
+
+    def valid?
+      @errors.nil?
+    end
+
+    def outcome(result = nil)
+      Objective::Outcome.new(
+        success: valid?,
+        result: result,
+        errors: @errors,
+        inputs: inputs
+      )
+    end
+
+    protected
+
+    def add_error(key, kind, message = nil)
+      raise(ArgumentError, 'Invalid kind') unless kind.is_a?(Symbol)
+
+      @errors ||= Objective::Errors::ErrorHash.new
+      @errors.tap do |root_error_hash|
+        path = key.to_s.split('.')
+        last = path.pop
+
+        inner = path.inject(root_error_hash) do |current_error_hash, path_key|
+          current_error_hash[path_key] ||= Objective::Errors::ErrorHash.new
+        end
+
+        inner[last] = Objective::Errors::ErrorAtom.new(key, kind, message: message)
+      end
+    end
+
+    def merge_errors(hash)
+      return unless hash.any?
+      @errors ||= Objective::Errors::ErrorHash.new
+      @errors.merge!(hash)
+    end
+  end
+end

data/lib/objective.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require 'ostruct'
+require 'date'
+require 'time'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/integer/inflections'
+
+require 'objective/allow'
+require 'objective/deny'
+require 'objective/discard'
+require 'objective/invalid'
+require 'objective/none'
+
+require 'objective/errors/error_atom'
+require 'objective/errors/error_hash'
+require 'objective/errors/error_array'
+require 'objective/errors/error_message_creator'
+require 'objective/errors/validation_error'
+
+require 'objective/filter'
+require 'objective/filters'
+require 'objective/filters/any_filter'
+require 'objective/filters/array_filter'
+require 'objective/filters/boolean_filter'
+require 'objective/filters/date_filter'
+require 'objective/filters/decimal_filter'
+require 'objective/filters/duck_filter'
+require 'objective/filters/file_filter'
+require 'objective/filters/float_filter'
+require 'objective/filters/hash_filter'
+require 'objective/filters/integer_filter'
+require 'objective/filters/model_filter'
+require 'objective/filters/root_filter'
+require 'objective/filters/string_filter'
+require 'objective/filters/time_filter'
+
+require 'objective/unit'
+require 'objective/outcome'
+
+module Objective
+  mattr_accessor :error_message_creator
+  self.error_message_creator = Errors::ErrorMessageCreator.new
+end

data/spec/default_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'simple_unit'
+
+describe 'Objective - defaults' do
+  class DefaultUnit
+    include Objective::Unit
+    filter do
+      string :name, none: 'Bob Jones'
+    end
+
+    def execute
+      inputs.to_h
+    end
+  end
+
+  it 'should have a default if no value is passed' do
+    outcome = DefaultUnit.run
+    assert_equal({ name: 'Bob Jones' }, outcome.result)
+    assert_equal true, outcome.success
+  end
+
+  it 'should have the passed value if a value is passed' do
+    outcome = DefaultUnit.run(name: 'Fred')
+    assert_equal true, outcome.success
+    assert_equal({ name: 'Fred' }, outcome.result)
+  end
+
+  it 'should be an error if nil is passed on a required field with a default' do
+    outcome = DefaultUnit.run(name: nil)
+    assert_equal false, outcome.success
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'Objective - errors' do
+  class GivesErrors
+    include Objective::Unit
+    filter do
+      string :str1
+      string :str2, in: %w(opt1 opt2 opt3)
+      integer :int1, none: ALLOW
+
+      hash :hash1, none: ALLOW do
+        boolean :bool1
+        boolean :bool2
+      end
+
+      array :arr1, none: ALLOW do
+        integer
+      end
+    end
+
+    def execute
+      inputs
+    end
+  end
+
+  it 'returns an ErrorHash as the top level error object, and ErrorAtom\'s inside' do
+    o = GivesErrors.run(hash1: 1, arr1: 'bob')
+    assert !o.success
+    assert o.errors.is_a?(Objective::Errors::ErrorHash)
+    assert o.errors[:str1].is_a?(Objective::Errors::ErrorAtom)
+    assert o.errors[:str2].is_a?(Objective::Errors::ErrorAtom)
+    assert_nil o.errors[:int1]
+    assert o.errors[:hash1].is_a?(Objective::Errors::ErrorAtom)
+    assert o.errors[:arr1].is_a?(Objective::Errors::ErrorAtom)
+  end
+
+  it 'returns an ErrorHash for nested hashes' do
+    o = GivesErrors.run(hash1: { bool1: 'ooooo' })
+
+    assert !o.success
+    assert o.errors.is_a?(Objective::Errors::ErrorHash)
+    assert o.errors[:hash1].is_a?(Objective::Errors::ErrorHash)
+    assert o.errors[:hash1][:bool1].is_a?(Objective::Errors::ErrorAtom)
+    assert o.errors[:hash1][:bool2].is_a?(Objective::Errors::ErrorAtom)
+  end
+
+  it 'returns an ErrorArray for errors in arrays' do
+    o = GivesErrors.run(str1: 'a', str2: 'opt1', arr1: ['bob', 1, 'sally'])
+
+    assert !o.success
+    assert o.errors.is_a?(Objective::Errors::ErrorHash)
+    assert o.errors[:arr1].is_a?(Objective::Errors::ErrorArray)
+    assert o.errors[:arr1][0].is_a?(Objective::Errors::ErrorAtom)
+    assert_nil o.errors[:arr1][1]
+    assert o.errors[:arr1][2].is_a?(Objective::Errors::ErrorAtom)
+  end
+
+  it 'titleizes keys' do
+    atom = Objective::Errors::ErrorAtom.new(:newsletter_subscription, :boolean)
+    assert_equal 'Newsletter Subscription must be a boolean', atom.message
+  end
+
+  describe 'Bunch o errors' do
+    before do
+      @outcome = GivesErrors.run(
+        str1: '', str2: 'opt9', int1: 'zero', hash1: { bool1: 'bob' }, arr1: ['bob', 1, 'sally']
+      )
+    end
+
+    it 'gives coded errors' do
+      expected = {
+        'str1' => :empty,
+        'str2' => :in,
+        'int1' => :integer,
+        'hash1' => { 'bool1' => :boolean, 'bool2' => :required },
+        'arr1' => [:integer, nil, :integer]
+      }
+
+      assert_equal expected, @outcome.errors.codes
+    end
+
+    it 'gives messages' do
+      expected = {
+        'str1' => 'Str1 cannot be empty',
+        'str2' => 'Str2 is not an available option',
+        'int1' => 'Int1 must be an integer',
+        'hash1' => {
+          'bool1' => 'Bool1 must be a boolean',
+          'bool2' => 'Bool2 is required'
+        },
+        'arr1' => ['1st Arr1 must be an integer', nil, '3rd Arr1 must be an integer']
+      }
+
+      assert_equal expected, @outcome.errors.message
+    end
+
+    it 'can flatten those messages' do
+      expected = [
+        'Str1 cannot be empty',
+        'Str2 is not an available option',
+        'Int1 must be an integer',
+        'Bool1 must be a boolean',
+        'Bool2 is required',
+        '1st Arr1 must be an integer',
+        '3rd Arr1 must be an integer'
+      ]
+
+      assert_equal expected, @outcome.errors.message_list
+      expected.each { |e| assert @outcome.errors.message_list.include?(e) }
+
+      assert_equal expected.size, @outcome.errors.message_list.size
+      expected.each { |e| assert @outcome.errors.message_list.include?(e) }
+    end
+  end
+
+  class WithShrinkingArray
+    include Objective::Unit
+    filter do
+      array :arr_one do
+        integer nils: DISCARD
+      end
+    end
+  end
+
+  it 'returns an ErrorArray for errors in arrays' do
+    o = WithShrinkingArray.run(arr_one: [nil, 1, 'sally'])
+
+    assert !o.success
+    assert o.errors.is_a?(Objective::Errors::ErrorHash)
+    assert o.errors[:arr_one].is_a?(Objective::Errors::ErrorArray)
+    assert_nil o.errors[:arr_one][0]
+    assert o.errors[:arr_one][1].is_a?(Objective::Errors::ErrorAtom)
+  end
+end