objective 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07f72b29c73d8dc130b6aad5d85b508d3cb3e574
+  data.tar.gz: '09adcd4a2daa8733a07dfd011cdb9aedeb0d5f41'
+SHA512:
+  metadata.gz: 549dc86b4ae3352c525da82fb706a5f939d3e27a719638a54356439adf4e3fdbb8d4bb6708cfcfee1e42edfab614dcf0b09007bcc695ecab96c64fe619a2baab
+  data.tar.gz: e7fe8fe0504f224627566395b1aaad7ed17301d7a540b5017463850889cc8396e478ef1bf25b04cadac9f3eb23f7cd53734373bcc4e038ca1a30bde5ac9e05ca

data/lib/objective/allow.rb

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

data/lib/objective/deny.rb

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

data/lib/objective/discard.rb

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

data/lib/objective/errors/error_array.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Objective
+  module Errors
+    class ErrorArray < Array
+      def codes
+        map { |e| e&.codes }
+      end
+
+      def message(parent_key = nil, _index = nil)
+        each_with_index.map { |e, i| e&.message(parent_key, i) }
+      end
+
+      def message_list(parent_key = nil, _index = nil)
+        each_with_index.map do |e, i|
+          next if e.nil?
+          e.message_list(parent_key, i)
+        end.flatten.compact
+      end
+    end
+  end
+end

data/lib/objective/errors/error_atom.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Objective
+  module Errors
+    class ErrorAtom
+      attr_reader :key, :codes, :type, :datum, :bound
+
+      # ErrorAtom.new(:name, :too_short)
+      # ErrorAtom.new(:name, :too_short, message: "is too short")
+      def initialize(key, codes, options = {})
+        @key = key # attribute
+        @codes = codes
+        @message = options[:message]
+        @type = options[:type] # target class/filter of coercion
+        @value = options[:value] # value given
+        @bound = options[:bound] # value of validator
+      end
+
+      def message(parent_key = nil, index = nil)
+        @message ||= Objective.error_message_creator.message(self, parent_key, index)
+      end
+
+      def message_list(parent_key = nil, index = nil)
+        Array.wrap(message(parent_key, index))
+      end
+    end
+  end
+end

data/lib/objective/errors/error_hash.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module Objective
+  module Errors
+    class ErrorHash < HashWithIndifferentAccess
+      # objective.errors is an ErrorHash instance like this:
+      # {
+      #   email: ErrorAtom(:matches),
+      #   name: ErrorAtom(:too_weird, message: "is too weird"),
+      #   adddress: { # Nested ErrorHash object
+      #     city: ErrorAtom(:not_found, message: "That's not a city, silly!"),
+      #     state: ErrorAtom(:in)
+      #   }
+      # }
+
+      # Returns a nested HashWithIndifferentAccess where the values are symbols.  Eg:
+      # {
+      #   email: :matches,
+      #   name: :too_weird,
+      #   adddress: {
+      #     city: :not_found,
+      #     state: :in
+      #   }
+      # }
+      def codes
+        HashWithIndifferentAccess.new.tap do |hash|
+          each do |k, v|
+            hash[k] = v.codes
+          end
+        end
+      end
+
+      # Returns a nested HashWithIndifferentAccess where the values are messages. Eg:
+      # {
+      #   email: "isn't in the right format",
+      #   name: "is too weird",
+      #   adddress: {
+      #     city: "is not a city",
+      #     state: "isn't a valid option"
+      #   }
+      # }
+      def message(_parent_key = nil, _index = nil)
+        HashWithIndifferentAccess.new.tap do |hash|
+          each do |k, v|
+            hash[k] = v.message(k)
+          end
+        end
+      end
+
+      # Returns a flat array where each element is a full sentence. Eg:
+      # [
+      #   "Email isn't in the right format.",
+      #   "Name is too weird",
+      #   "That's not a city, silly!",
+      #   "State isn't a valid option."
+      # ]
+      def message_list(_parent_key = nil, _index = nil)
+        list = []
+        each do |k, v|
+          list.concat(v.message_list(k))
+        end
+        list
+      end
+    end
+  end
+end

data/lib/objective/errors/error_message_creator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Objective
+  module Errors
+    class ErrorMessageCreator
+      MESSAGES = Hash.new('is invalid').tap do |h|
+        h.merge!(
+          nils: 'cannot be nil',
+          required: 'is required',
+
+          string: 'must be a string',
+          integer: 'must be an integer',
+          decimal: 'must be a number',
+          boolean: 'must be a boolean',
+          hash: 'must be a hash',
+          array: 'must be an array',
+          model: 'must be the right class',
+          date: 'date does non exist',
+
+          before: 'must be before given date',
+          after: 'must be after given date',
+          empty: 'cannot be empty',
+          matches: 'has an incorrect format',
+          in: 'is not an available option',
+          min: 'is too small',
+          max: 'is too big',
+
+          new_records: 'model must be saved'
+        )
+      end
+
+      def message(atom, parent_key, index)
+        [
+          index_ordinal(index),
+          (atom.key || parent_key || 'item').to_s.titleize,
+          MESSAGES[atom.codes]
+        ]
+          .compact
+          .join(' ')
+      end
+
+      def index_ordinal(index)
+        index&.+(1)&.ordinalize
+      end
+    end
+  end
+end

data/lib/objective/errors/validation_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Objective
+  class ValidationError < StandardError
+    attr_accessor :errors
+
+    def initialize(errors)
+      self.errors = errors
+    end
+
+    def to_s
+      errors.message_list.join('; ').to_s
+    end
+  end
+end

data/lib/objective/filter.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+module Objective
+  class Filter
+    def self.inherited(child_class)
+      method_name = filter_name(child_class)
+
+      define_method(method_name) do |*args, &block|
+        args.unshift(nil) if args[0].is_a?(Hash)
+        new_filter = child_class.new(*args, &block)
+        sub_filters.push(new_filter)
+      end
+    end
+
+    def self.filter_name(klass = self)
+      filter_name = klass.name.match(/\AObjective::Filters::(.*)Filter\z/)&.[](1)&.underscore
+      raise 'filename error in filters folder' unless filter_name
+      filter_name
+    end
+
+    attr_reader :key
+    attr_reader :sub_filters
+
+    def initialize(key = nil, opts = {}, &block)
+      @key = key
+      @given_options = opts
+      @sub_filters ||= []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def options
+      @options ||= OpenStruct.new(type_specific_options_hash.merge(@given_options))
+    end
+
+    def type_specific_options_hash
+      Objective::Filters::Config[self.class.filter_name].to_h
+    end
+
+    def sub_filters_hash
+      sub_filters.each_with_object({}) { |sf, result| result[sf.key] = sf }
+    end
+
+    def dup
+      dupped = self.class.new
+      sub_filters.each { |sf| dupped.sub_filters.push(sf) }
+      dupped
+    end
+
+    def default?
+      options.to_h.key?(:default)
+    end
+
+    def default
+      options.default
+    end
+
+    def feed(raw)
+      return feed_none if raw == Objective::NONE
+      return feed_nil if raw.nil?
+
+      coerced = options.strict == true ? raw : coerce(raw)
+      errors = coerce_error(coerced)
+      return feed_invalid(errors, raw, raw) if errors
+
+      errors = validate(coerced)
+      return feed_empty(raw, coerced) if errors == :empty
+
+      feed_result(errors, raw, coerced)
+    end
+
+    def feed_none
+      case options.none
+      when Objective::ALLOW
+        return Objective::DISCARD
+      when Objective::DENY
+        coerced = Objective::NONE
+        errors = :required
+      when Objective::DISCARD
+        raise 'the none option cannot be discarded — did you mean to use allow instead?'
+      else
+        coerced = options.none
+      end
+
+      feed_result(errors, Objective::NONE, coerced)
+    end
+
+    def feed_nil
+      case options.nils
+      when Objective::ALLOW
+        coerced = nil
+        errors = nil
+      when Objective::DENY
+        coerced = nil
+        errors = :nils
+      when Objective::DISCARD
+        return Objective::DISCARD
+      else
+        coerced = options.nils
+      end
+
+      feed_result(errors, nil, coerced)
+    end
+
+    def feed_invalid(errors, raw, coerced)
+      case options.invalid
+      when Objective::DENY
+        # nothing
+      when Objective::DISCARD
+        return Objective::DISCARD
+      else
+        coerced = options.invalid
+      end
+
+      feed_result(errors, raw, coerced)
+    end
+
+    def feed_empty(raw, coerced)
+      case options.empty
+      when Objective::ALLOW
+        errors = nil
+      when Objective::DENY
+        errors = :empty
+      when Objective::DISCARD
+        return Objective::DISCARD
+      else
+        coerced = options.empty
+      end
+
+      feed_result(errors, raw, coerced)
+    end
+
+    def feed_result(errors, raw, coerced)
+      OpenStruct.new(
+        errors: errors,
+        raw: raw,
+        coerced: coerced,
+        inputs: coerced
+      )
+    end
+
+    def coerce(raw)
+      raw
+    end
+
+    def coerce_error(coerced)
+    end
+
+    def validate(coerced)
+    end
+
+    def handle_errors(given_error)
+      return if given_error.nil?
+
+      case given_error
+      when Objective::Errors::ErrorHash
+        given_error
+      when Objective::Errors::ErrorArray
+        given_error
+      when Objective::Errors::ErrorAtom
+        given_error
+      else
+        Objective::Errors::ErrorAtom.new(key, given_error)
+      end
+    end
+  end
+end

data/lib/objective/filters/any_filter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class AnyFilter < Objective::Filter
+    end
+  end
+end

data/lib/objective/filters/array_filter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class ArrayFilter < Objective::Filter
+      def feed(raw)
+        result = super(raw)
+        return result if result == Objective::DISCARD || result.errors || result.inputs.nil?
+
+        inputs = []
+        errors = Objective::Errors::ErrorArray.new
+
+        sub_filter = sub_filters.first
+
+        index_shift = 0
+
+        data = result.coerced
+        data.each_with_index do |sub_data, index|
+          sub_result = sub_filter.feed(sub_data)
+          if sub_result == Objective::DISCARD
+            index_shift += 1
+            next
+          end
+
+          sub_data = sub_result.inputs
+          sub_error = sub_result.errors
+
+          unless sub_error.nil?
+            errors[index - index_shift] = sub_filter.handle_errors(sub_error)
+          end
+
+          inputs[index - index_shift] = sub_data
+        end
+
+        result.inputs = inputs
+        result.errors = errors.present? ? errors : nil
+        result
+      end
+
+      def coerce(raw)
+        return Array.wrap(raw) if options.wrap
+        raw
+      end
+
+      def coerce_error(coerced)
+        return :array unless coerced.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/objective/filters/boolean_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class BooleanFilter < Objective::Filter
+      private
+
+      def coerce(raw)
+        return raw if boolean?(raw)
+        options.coercion_map[raw.to_s.downcase] if raw.respond_to?(:to_s)
+      end
+
+      def coerce_error(coerced)
+        return :boolean unless boolean?(coerced)
+      end
+
+      def boolean?(datum)
+        datum == true || datum == false
+      end
+    end
+  end
+end

data/lib/objective/filters/date_filter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class DateFilter < Objective::Filter
+      private
+
+      def coerce(raw)
+        return raw if raw.is_a?(Date) # Date and DateTime
+        return raw.to_date if raw.respond_to?(:to_date)
+        parse(raw) if raw.is_a?(String)
+      end
+
+      def parse(data)
+        options.format ? Date.strptime(data, options.format) : Date.parse(data)
+      rescue ArgumentError
+        nil
+      end
+
+      def coerce_error(coerced)
+        return :date unless coerced.is_a?(Date)
+      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/decimal_filter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class DecimalFilter < Objective::Filter
+      private
+
+      # TODO: the Rational class should be coerced - it requires a precision argument
+      def coerce(datum)
+        return datum if datum.blank?
+
+        return datum.to_d if datum.is_a?(Integer) || datum.is_a?(Float)
+
+        return datum unless datum.is_a?(String)
+
+        clean_str = datum.tr(options.delimiter, '').tr(options.decimal_mark, '.')
+        return datum unless clean_str =~ /\A[-+]?\d*\.?\d*\z/
+        clean_str.to_d
+      end
+
+      def coerce_error(coerced)
+        return :decimal unless coerced.is_a?(BigDecimal)
+      end
+
+      def validate(datum)
+        return :min unless above_min?(datum)
+        return :max unless below_max?(datum)
+        return :scale unless within_scale?(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/duck_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class DuckFilter < Objective::Filter
+      private
+
+      def coerce_error(coerced)
+        return :duck unless respond_to_all?(coerced)
+      end
+
+      def respond_to_all?(coerced)
+        Array.wrap(options[:methods]).map do |method|
+          coerced.respond_to?(method)
+        end.all?
+      end
+    end
+  end
+end

data/lib/objective/filters/file_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class FileFilter < Objective::Filter
+      private
+
+      def coerce_error(coerced)
+        return :file unless respond_to_all?(coerced)
+      end
+
+      def respond_to_all?(coerced)
+        methods = %i(read size)
+        methods.concat(%i(original_filename content_type)) if options.upload
+        methods.map { |method| coerced.respond_to?(method) }.all?
+      end
+
+      def validate(coerced)
+        return :size if options.size && coerced.size > options.size
+      end
+    end
+  end
+end

data/lib/objective/filters/float_filter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class FloatFilter < Objective::Filter
+      private
+
+      def coerce(datum)
+        return datum if datum.blank?
+
+        return datum.to_f if datum.is_a?(Integer) || datum.is_a?(BigDecimal)
+
+        return datum unless datum.is_a?(String)
+
+        clean_str = datum.tr(options.delimiter, '').tr(options.decimal_mark, '.')
+        return datum unless clean_str =~ /\A[-+]?\d*\.?\d*\z/
+        clean_str.to_f
+      end
+
+      def coerce_error(coerced)
+        return :float unless coerced.is_a?(Float)
+      end
+
+      def validate(coerced)
+        return :min unless above_min?(coerced)
+        return :max unless below_max?(coerced)
+        return :scale unless within_scale?(coerced)
+      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/hash_filter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Objective
+  module Filters
+    class HashFilter < Objective::Filter
+      def feed(raw)
+        result = super(raw)
+        return result if result == Objective::DISCARD || result.errors || result.inputs.nil?
+
+        errors = Objective::Errors::ErrorHash.new
+        inputs = HashWithIndifferentAccess.new
+
+        data = result.coerced
+        sub_filters_hash.each_pair do |key, key_filter|
+          datum = data.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.try(:with_indifferent_access)
+      end
+
+      def coerce_error(coerced)
+        return :hash unless coerced.is_a?(Hash)
+      end
+    end
+  end
+end