rschema 2.4.0 → 3.0.1.pre1

data/lib/rschema/error.rb

@@ -0,0 +1,46 @@
+module RSchema
+  class Error
+    attr_reader :schema, :value, :symbolic_name, :vars
+
+    def initialize(schema:, value:, symbolic_name:, vars: nil)
+      @schema = schema
+      @value = value
+      @symbolic_name = symbolic_name
+      @vars = vars
+      freeze
+    end
+
+    def to_s(detailed=false)
+      if detailed
+        <<~EOS
+          Error: #{symbolic_name}
+          Schema: #{schema.class.name}
+          Value: #{value.inspect}
+          Vars: #{vars.inspect}
+        EOS
+      else
+        "Error #{schema.class}/#{symbolic_name} for value: #{value.inspect}"
+      end
+    end
+
+    def to_json
+      {
+        schema: schema.class.name,
+        error: symbolic_name.to_s,
+        value: jsonify(value),
+        vars: jsonify(vars),
+      }
+    end
+
+    private
+
+      def jsonify(value)
+        case value
+        when String, Symbol, Numeric, TrueClass, FalseClass, NilClass then value
+        when Array then value.map{ |element| jsonify(element) }
+        when Hash then value.map{ |k, v| [jsonify(k), jsonify(v)] }.to_h
+        else String(value)
+        end
+      end
+  end
+end

data/lib/rschema/http_coercer.rb

@@ -0,0 +1,177 @@
+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)
+        raise CanNotBeWrappedError, <<~EOS
+          This schema has already been wrapped by RSchema::HTTPCoercer.
+          Wrapping the schema again will most likely result in a schema that
+          crashes when it is called.
+        EOS
+      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
+      def coerce(value)
+        default_bools_to_false(symbolize_keys(value))
+      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)
+        # these could be cached if we know for sure that the subschema is immutable
+        symbol_keys = subschema.attributes
+          .map(&:key)
+          .select{ |k| k.is_a?(Symbol) }
+          .map(&:to_s)
+
+        string_keys = subschema.attributes
+          .map(&:key)
+          .select{ |k| k.is_a?(String) }
+
+        hash.keys.select do |k|
+          k.is_a?(String) && symbol_keys.include?(k) && !string_keys.include?(k)
+        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`.
+
+        # some of this could be cached if we know for sure that the subschema is immutable
+        keys_to_default = subschema.attributes
+          .select { |attr| attr.value_schema.is_a?(BoolCoercer) }
+          .map(&:key)
+          .reject { |key| hash.has_key?(key) }
+
+        if keys_to_default.any?
+          defaults = keys_to_default.map{ |k| [k, false] }.to_h
+          hash.merge(defaults)
+        else
+          hash # no coercion necessary
+        end
+      end
+    end
+
+    TYPE_COERCERS = {
+      Symbol => SymbolCoercer,
+      Integer => IntegerCoercer,
+      Float => FloatCoercer,
+      Time => TimeCoercer,
+      Date => DateCoercer,
+    }
+  end
+end

data/lib/rschema/options.rb

@@ -0,0 +1,15 @@
+module RSchema
+  class Options
+    def self.default
+      @default ||= new
+    end
+
+    def initialize(vars={})
+      @fail_fast = vars.fetch(:fail_fast, false)
+    end
+
+    def fail_fast?
+      @fail_fast
+    end
+  end
+end

data/lib/rschema/result.rb

@@ -0,0 +1,39 @@
+module RSchema
+  class Result
+    def self.success(value)
+      new(true, value, nil)
+    end
+
+    def self.failure(error)
+      new(false, nil, error)
+    end
+
+    def initialize(valid, value, error)
+      @valid = valid
+      @value = value
+      @error = error
+    end
+
+    def valid?
+      @valid
+    end
+
+    def invalid?
+      not valid?
+    end
+
+    def value
+      if valid?
+        @value
+      else
+        raise InvalidError
+      end
+    end
+
+    def error
+      @error
+    end
+
+    class InvalidError < StandardError; end
+  end
+end

data/lib/rschema/schemas/anything.rb

@@ -0,0 +1,17 @@
+module RSchema
+  module Schemas
+    class Anything
+      def self.instance
+        @instance ||= new
+      end
+
+      def call(value, options=Options.default)
+        Result.success(value)
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self
+      end
+    end
+  end
+end

data/lib/rschema/schemas/boolean.rb

@@ -0,0 +1,27 @@
+module RSchema
+  module Schemas
+
+    class Boolean
+      def self.instance
+        @instance ||= new
+      end
+
+      def call(value, options=Options.default)
+        if value.equal?(true) || value.equal?(false)
+          Result.success(value)
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :not_a_boolean,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self
+      end
+    end
+
+  end
+end

data/lib/rschema/schemas/enum.rb

@@ -0,0 +1,31 @@
+module RSchema
+  module Schemas
+    class Enum
+      attr_reader :members, :subschema
+
+      def initialize(members, subschema)
+        @members = members
+        @subschema = subschema
+      end
+
+      def call(value, options=Options.default)
+        subresult = subschema.call(value, options)
+        if subresult.invalid?
+          subresult
+        elsif members.include?(subresult.value)
+          subresult
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: subresult.value,
+            symbolic_name: :not_a_member,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(members, wrapper.wrap(subschema))
+      end
+    end
+  end
+end

data/lib/rschema/schemas/fixed_hash.rb

@@ -0,0 +1,118 @@
+module RSchema
+  module Schemas
+
+    class FixedHash
+      attr_reader :attributes
+
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def call(value, options=Options.default)
+        return not_a_hash_result(value) unless value.is_a?(Hash)
+        return missing_attrs_result(value) if missing_keys(value).any?
+        return extraneous_attrs_result(value) if extraneous_keys(value).any?
+
+        subresults = attr_subresults(value, options)
+        if subresults.values.any?(&:invalid?)
+          Result.failure(failure_error(subresults))
+        else
+          Result.success(success_value(subresults))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        wrapped_attributes = attributes.map do |attr|
+          attr.with_wrapped_value_schema(wrapper)
+        end
+
+        self.class.new(wrapped_attributes)
+      end
+
+      def [](attr_key)
+        attributes.find{ |attr| attr.key == attr_key }
+      end
+
+      Attribute = Struct.new(:key, :value_schema, :optional) do
+        def with_wrapped_value_schema(wrapper)
+          self.class.new(key, wrapper.wrap(value_schema), optional)
+        end
+      end
+
+      private
+
+      def missing_keys(value)
+        attributes
+          .reject(&:optional)
+          .map(&:key)
+          .reject{ |k| value.has_key?(k) }
+      end
+
+      def missing_attrs_result(value)
+        Result.failure(Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :missing_attributes,
+          vars: missing_keys(value),
+        ))
+      end
+
+      def extraneous_keys(value)
+        allowed_keys = attributes.map(&:key)
+        value.keys.reject{ |k| allowed_keys.include?(k) }
+      end
+
+      def extraneous_attrs_result(value)
+        Result.failure(Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :extraneous_attributes,
+          vars: extraneous_keys(value),
+        ))
+      end
+
+      def attr_subresults(value, options)
+        subresults_by_key = {}
+
+        @attributes.map do |attr|
+          if value.has_key?(attr.key)
+            subresult = attr.value_schema.call(value[attr.key], options)
+            subresults_by_key[attr.key] = subresult
+            break if subresult.invalid? && options.fail_fast?
+          end
+        end
+
+        subresults_by_key
+      end
+
+      def failure_error(results)
+        error = {}
+
+        results.each do |key, attr_result|
+          if attr_result.invalid?
+            error[key] = attr_result.error
+          end
+        end
+
+        error
+      end
+
+      def success_value(subresults)
+        subresults
+          .map{ |key, attr_result| [key, attr_result.value] }
+          .to_h
+      end
+
+      def not_a_hash_result(value)
+        Result.failure(
+          Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :not_a_hash,
+          )
+        )
+      end
+    end
+
+  end
+end