rschema 3.0.1.pre3 → 3.0.1.pre4

data/lib/rschema/schemas/variable_hash.rb

@@ -1,67 +1,68 @@
 module RSchema
-  module Schemas
-    class VariableHash
-      attr_reader :key_schema, :value_schema
+module Schemas
+class VariableHash
+  attr_reader :key_schema, :value_schema
 
-      def initialize(key_schema, value_schema)
-        @key_schema = key_schema
-        @value_schema = value_schema
-      end
-
-      def call(value, options=Options.default)
-        return not_a_hash_result(value) unless value.is_a?(Hash)
+  def initialize(key_schema, value_schema)
+    @key_schema = key_schema
+    @value_schema = value_schema
+  end
 
-        result, key_errors, value_errors = apply_subschemas(value, options)
+  def call(value, options)
+    return not_a_hash_result(value) unless value.is_a?(Hash)
 
-        if key_errors.empty? && value_errors.empty?
-          Result.success(result)
-        else
-          Result.failure(keys: key_errors, values: value_errors)
-        end
-      end
+    result, key_errors, value_errors = apply_subschemas(value, options)
 
-      def with_wrapped_subschemas(wrapper)
-        self.class.new(
-          wrapper.wrap(key_schema),
-          wrapper.wrap(value_schema),
-        )
-      end
+    if key_errors.empty? && value_errors.empty?
+      Result.success(result)
+    else
+      Result.failure(keys: key_errors, values: value_errors)
+    end
+  end
 
-      private
+  def with_wrapped_subschemas(wrapper)
+    self.class.new(
+      wrapper.wrap(key_schema),
+      wrapper.wrap(value_schema),
+    )
+  end
 
-        def not_a_hash_result(value)
-          Result.failure(Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :not_a_hash,
-          ))
-        end
+  private
 
-        def apply_subschemas(value, options)
-          result = {}
-          key_errors = {}
-          value_errors = {}
+    def not_a_hash_result(value)
+      Result.failure(Error.new(
+        schema: self,
+        value: value,
+        symbolic_name: :not_a_hash,
+      ))
+    end
 
-          value.each do |key, subvalue|
-            key_result = key_schema.call(key, options)
-            if key_result.invalid?
-              key_errors[key] = key_result.error
-              break if options.fail_fast?
-            end
+    def apply_subschemas(value, options)
+      result = {}
+      key_errors = {}
+      value_errors = {}
 
-            subvalue_result = value_schema.call(subvalue, options)
-            if subvalue_result.invalid?
-              value_errors[key] = subvalue_result.error
-              break if options.fail_fast?
-            end
+      value.each do |key, subvalue|
+        key_result = key_schema.call(key, options)
+        if key_result.invalid?
+          key_errors[key] = key_result.error
+          break if options.fail_fast?
+        end
 
-            if key_result.valid? && subvalue_result.valid?
-              result[key_result.value] = subvalue_result.value
-            end
-          end
+        subvalue_result = value_schema.call(subvalue, options)
+        if subvalue_result.invalid?
+          value_errors[key] = subvalue_result.error
+          break if options.fail_fast?
+        end
 
-          return result, key_errors, value_errors
+        if key_result.valid? && subvalue_result.valid?
+          result[key_result.value] = subvalue_result.value
         end
+      end
+
+      return result, key_errors, value_errors
     end
-  end
+
+end
+end
 end

data/lib/rschema/schemas/variable_length_array.rb

@@ -1,49 +1,50 @@
 module RSchema
-  module Schemas
-    class VariableLengthArray
-      attr_accessor :element_schema
+module Schemas
+class VariableLengthArray
+  attr_accessor :element_schema
 
-      def initialize(element_schema)
-        @element_schema = element_schema
-      end
-
-      def call(value, options = RSchema::Options.default)
-        if value.kind_of?(Array)
-          validated_values, errors = validate_elements(value, options)
-          if errors.empty?
-            Result.success(validated_values)
-          else
-            Result.failure(errors)
-          end
-        else
-          Result.failure(Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :not_an_array,
-          ))
-        end
-      end
+  def initialize(element_schema)
+    @element_schema = element_schema
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self.class.new(wrapper.wrap(element_schema))
+  def call(value, options)
+    if value.kind_of?(Array)
+      validated_values, errors = validate_elements(value, options)
+      if errors.empty?
+        Result.success(validated_values)
+      else
+        Result.failure(errors)
       end
+    else
+      Result.failure(Error.new(
+        schema: self,
+        value: value,
+        symbolic_name: :not_an_array,
+      ))
+    end
+  end
 
-      def validate_elements(array, options)
-        errors = {}
-        validated_values = []
+  def with_wrapped_subschemas(wrapper)
+    self.class.new(wrapper.wrap(element_schema))
+  end
 
-        array.each_with_index do |subvalue, idx|
-          result = @element_schema.call(subvalue, options)
-          if result.valid?
-            validated_values[idx] = result.value
-          else
-            errors[idx] = result.error
-            break if options.fail_fast?
-          end
-        end
+  def validate_elements(array, options)
+    errors = {}
+    validated_values = []
 
-        [validated_values, errors]
+    array.each_with_index do |subvalue, idx|
+      result = @element_schema.call(subvalue, options)
+      if result.valid?
+        validated_values[idx] = result.value
+      else
+        errors[idx] = result.error
+        break if options.fail_fast?
       end
     end
+
+    [validated_values, errors]
   end
+
+end
+end
 end

data/lib/rschema/version.rb

@@ -1,3 +1,3 @@
 module RSchema
-  VERSION = '3.0.1.pre3'
+  VERSION = '3.0.1.pre4'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rschema
 version: !ruby/object:Gem::Version
-  version: 3.0.1.pre3
+  version: 3.0.1.pre4
 platform: ruby
 authors:
 - Tom Dalling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-02 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -56,14 +70,28 @@ dependencies:
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |2
@@ -78,13 +106,29 @@ files:
 - LICENSE.txt
 - README.md
 - lib/rschema.rb
+- lib/rschema/coercers.rb
+- lib/rschema/coercers/any.rb
+- lib/rschema/coercers/boolean.rb
+- lib/rschema/coercers/chain.rb
+- lib/rschema/coercers/date.rb
+- lib/rschema/coercers/fixed_hash/default_booleans_to_false.rb
+- lib/rschema/coercers/fixed_hash/remove_extraneous_attributes.rb
+- lib/rschema/coercers/fixed_hash/symbolize_keys.rb
+- lib/rschema/coercers/float.rb
+- lib/rschema/coercers/integer.rb
+- lib/rschema/coercers/symbol.rb
+- lib/rschema/coercers/time.rb
+- lib/rschema/coercion_wrapper.rb
+- lib/rschema/coercion_wrapper/rack_params.rb
 - lib/rschema/dsl.rb
 - lib/rschema/error.rb
-- lib/rschema/http_coercer.rb
 - lib/rschema/options.rb
 - lib/rschema/result.rb
+- lib/rschema/schemas.rb
 - lib/rschema/schemas/anything.rb
 - lib/rschema/schemas/boolean.rb
+- lib/rschema/schemas/coercer.rb
+- lib/rschema/schemas/convenience.rb
 - lib/rschema/schemas/enum.rb
 - lib/rschema/schemas/fixed_hash.rb
 - lib/rschema/schemas/fixed_length_array.rb

data/lib/rschema/http_coercer.rb

@@ -1,218 +0,0 @@
-module RSchema
-  module HTTPCoercer
-    class CanNotBeWrappedError < StandardError; end
-
-    def self.wrap(schema)
-      coercer_klass = begin
-        case schema
-        when Schemas::Type then TYPE_COERCERS[schema.type]
-        when Schemas::Boolean then BoolCoercer
-        when Schemas::FixedHash then FixedHashCoercer
-        end
-      end
-
-      wrapped_schema = schema.with_wrapped_subschemas(self)
-      coercer_klass ? coercer_klass.new(wrapped_schema) : wrapped_schema
-    end
-
-    class Coercer
-      attr_reader :subschema
-
-      def initialize(subschema)
-        @subschema = subschema
-      end
-
-      def call(value, options=RSchema::Options.default)
-        @subschema.call(coerce(value), options)
-      rescue CoercionFailedError
-        return Result.failure(Error.new(
-          schema: self,
-          value: value,
-          symbolic_name: :coercion_failure,
-        ))
-      end
-
-      def with_wrapped_subschemas(wrapper)
-        # Double wrapping is potentially a problem. Coercers expect their
-        # subschemas to be a particular type. If their subschema gets wrapped
-        # again, the type changes, so if the coercer tries to use its subschema
-        # during coercion, it will crash.
-        #
-        # For this reason, coercers must not rely upon the type of their
-        # subschemas within `#call`. Coercer schemas should store any required
-        # info from their subschemas within `#initialize`.
-
-        self.class.new(wrapper.wrap(subschema))
-      end
-
-      def invalid!
-        raise CoercionFailedError
-      end
-
-      class CoercionFailedError < StandardError; end
-    end
-
-    class TimeCoercer < Coercer
-      def coerce(value)
-        case value
-        when Time then value
-        when String then Time.iso8601(value) rescue invalid!
-        else invalid!
-        end
-      end
-    end
-
-    class DateCoercer < Coercer
-      def coerce(value)
-        case value
-        when Date then value
-        when String then Date.iso8601(value) rescue invalid!
-        else invalid!
-        end
-      end
-    end
-
-    class SymbolCoercer < Coercer
-      def coerce(value)
-        case value
-        when Symbol then value
-        when String then value.to_sym
-        else invalid!
-        end
-      end
-    end
-
-    class IntegerCoercer < Coercer
-      def coerce(value)
-        Integer(value)
-      rescue ArgumentError
-        invalid!
-      end
-    end
-
-    class FloatCoercer < Coercer
-      def coerce(value)
-        Float(value)
-      rescue ArgumentError
-        invalid!
-      end
-    end
-
-    class BoolCoercer < Coercer
-      TRUTHY_STRINGS = ['on', '1', 'true']
-      FALSEY_STRINGS = ['off', '0', 'false']
-
-      def coerce(value)
-        case value
-        when true, false then value
-        when nil then false
-        when String
-          case
-          when TRUTHY_STRINGS.include?(value.downcase) then true
-          when FALSEY_STRINGS.include?(value.downcase) then false
-          else invalid!
-          end
-        else invalid!
-        end
-      end
-    end
-
-    class FixedHashCoercer < Coercer
-      attr_reader :hash_attributes
-
-      def initialize(fixed_hash_schema, attributes = nil)
-        super(fixed_hash_schema)
-
-        @hash_attributes = attributes || fixed_hash_schema.attributes.map(&:dup)
-      end
-
-      def coerce(value)
-        [value]
-          .map(&method(:symbolize_keys))
-          .map(&method(:remove_extraneous_elements))
-          .map(&method(:default_bools_to_false))
-          .last
-      end
-
-      def symbolize_keys(hash)
-        keys = keys_to_symbolize(hash)
-        if keys.any?
-          hash.dup.tap do |new_hash|
-            keys.each { |k| new_hash[k.to_sym] = new_hash.delete(k) }
-          end
-        else
-          hash
-        end
-      end
-
-      def keys_to_symbolize(hash)
-        # some of this could be memoized
-        symbol_keys = hash_attributes
-          .map(&:key)
-          .select{ |k| k.is_a?(Symbol) }
-          .map(&:to_s)
-
-        string_keys = hash_attributes
-          .map(&:key)
-          .select{ |k| k.is_a?(String) }
-
-        hash.keys.select do |k|
-          symbol_keys.include?(k) && !string_keys.include?(k)
-        end
-      end
-
-      def remove_extraneous_elements(hash)
-        valid_keys = hash_attributes.map(&:key)
-        keys_to_remove = hash.keys - valid_keys
-
-        if keys_to_remove.any?
-          hash.dup.tap do |stripped_hash|
-            keys_to_remove.each { |k| stripped_hash.delete(k) }
-          end
-        else
-          hash
-        end
-      end
-
-      def default_bools_to_false(hash)
-        # The HTTP standard says that when a form is submitted, all unchecked
-        # check boxes will _not_ be sent to the server. That is, they will not
-        # be present at all in the params hash.
-        #
-        # This method coerces these missing values into `false`.
-
-        missing_keys = keys_for_bool_defaulting
-          .reject { |key| hash.has_key?(key) }
-
-        if missing_keys.any?
-          defaults = missing_keys.map{ |k| [k, false] }.to_h
-          hash.merge(defaults)
-        else
-          hash # no coercion necessary
-        end
-      end
-
-      def with_wrapped_subschemas(wrapper)
-        self.class.new(wrapper.wrap(subschema), hash_attributes)
-      end
-
-      private
-
-        def keys_for_bool_defaulting
-          # this could be memoized
-          hash_attributes
-            .reject(&:optional)
-            .select { |attr| attr.value_schema.is_a?(BoolCoercer) }
-            .map(&:key)
-        end
-    end
-
-    TYPE_COERCERS = {
-      Symbol => SymbolCoercer,
-      Integer => IntegerCoercer,
-      Float => FloatCoercer,
-      Time => TimeCoercer,
-      Date => DateCoercer,
-    }
-  end
-end