rschema 3.0.1.pre3 → 3.0.1.pre4

data/lib/rschema/error.rb

@@ -2,45 +2,27 @@ module RSchema
   class Error
     attr_reader :schema, :value, :symbolic_name, :vars
 
-    def initialize(schema:, value:, symbolic_name:, vars: nil)
+    def initialize(schema:, value:, symbolic_name:, vars: {})
+      raise ArgumentError.new("vars must be a hash") unless vars.is_a?(Hash)
+
       @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
+      freeze
     end
 
-    def to_json
-      {
-        schema: schema.class.name,
-        error: symbolic_name.to_s,
-        value: jsonify(value),
-        vars: jsonify(vars),
-      }
+    def to_s
+      "#{schema.class}/#{symbolic_name}"
     end
 
-    private
+    def inspect
+      attrs = vars.merge(value: value)
+        .map{ |k, v| "#{k}=#{v.inspect}" }
+        .join(' ')
 
-      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
+      "<#{self.class} #{to_s} #{attrs}>"
+    end
   end
 end

data/lib/rschema/options.rb

@@ -4,8 +4,8 @@ module RSchema
       @default ||= new
     end
 
-    def initialize(vars={})
-      @fail_fast = vars.fetch(:fail_fast, false)
+    def initialize(fail_fast: false)
+      @fail_fast = fail_fast
     end
 
     def fail_fast?

data/lib/rschema/result.rb

@@ -1,17 +1,26 @@
 module RSchema
   class Result
-    def self.success(value)
-      new(true, value, nil)
+    def self.success(value = nil)
+      if value.nil?
+        NIL_SUCCESS
+      else
+        new(true, value, nil)
+      end
     end
 
-    def self.failure(error)
-      new(false, nil, error)
+    def self.failure(error = nil)
+      if error.nil?
+        NIL_FAILURE
+      else
+        new(false, nil, error)
+      end
     end
 
     def initialize(valid, value, error)
       @valid = valid
       @value = value
       @error = error
+      freeze
     end
 
     def valid?
@@ -35,5 +44,10 @@ module RSchema
     end
 
     class InvalidError < StandardError; end
+
+    # @!visibility private
+    NIL_SUCCESS = new(true, nil, nil)
+    # @!visibility private
+    NIL_FAILURE = new(false, nil, nil)
   end
 end

data/lib/rschema/schemas.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.join(__dir__, 'schemas/**/*.rb')).each do |path|
+  require path
+end

data/lib/rschema/schemas/anything.rb

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

data/lib/rschema/schemas/boolean.rb

@@ -1,27 +1,26 @@
 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
+module Schemas
+class Boolean
+  def self.instance
+    @instance ||= new
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self
-      end
+  def call(value, options)
+    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/coercer.rb

@@ -0,0 +1,37 @@
+module RSchema
+module Schemas
+class Coercer
+  attr_reader :coercer, :subschema
+
+  def initialize(coercer, subschema)
+    byebug if coercer.is_a?(Array)
+    @coercer = coercer
+    @subschema = subschema
+  end
+
+  def call(value, options)
+    result = coercer.call(value)
+    if result.valid?
+      @subschema.call(result.value, options)
+    else
+      failure(value, result.error)
+    end
+  end
+
+  def with_wrapped_subschemas(wrapper)
+    self.class.new(coercer, wrapper.wrap(subschema))
+  end
+
+  private
+
+    def failure(value, name)
+      return Result.failure(Error.new(
+        schema: self,
+        value: value,
+        symbolic_name: name || :coercion_failure,
+      ))
+    end
+
+end
+end
+end

data/lib/rschema/schemas/convenience.rb

@@ -0,0 +1,53 @@
+require 'delegate'
+
+module RSchema
+module Schemas
+class Convenience < SimpleDelegator
+  def initialize(raw_schema)
+    super
+  end
+
+  def raw_schema
+    __getobj__
+  end
+
+  def validate(value, options=Options.default)
+    call(value, options)
+  end
+
+  def validate!(value, options=Options.default)
+    result = call(value, options)
+    if result.valid?
+      result.value
+    else
+      raise RSchema::Invalid.new(result.error)
+    end
+  end
+
+  def valid?(value)
+    result = call(value, Options.new(fail_fast: true))
+    result.valid?
+  end
+
+  def self.wrap(schema)
+    if schema.is_a?(self)
+      schema
+    else
+      new(schema)
+    end
+  end
+
+  def self.unwrap(schema)
+    while schema.is_a?(self)
+      schema = schema.raw_schema
+    end
+    schema
+  end
+
+  def with_wrapped_subschemas(wrapper)
+    self.class.new(wrapper.wrap(raw_schema))
+  end
+
+end
+end
+end

data/lib/rschema/schemas/enum.rb

@@ -1,31 +1,31 @@
 module RSchema
-  module Schemas
-    class Enum
-      attr_reader :members, :subschema
+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 initialize(members, subschema)
+    @members = members
+    @subschema = subschema
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self.class.new(members, wrapper.wrap(subschema))
-      end
+  def call(value, options)
+    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

@@ -1,118 +1,137 @@
 module RSchema
-  module Schemas
+module Schemas
+class FixedHash
+  attr_reader :attributes
 
-    class FixedHash
-      attr_reader :attributes
+  def initialize(attributes)
+    @attributes = attributes
+  end
 
-      def initialize(attributes)
-        @attributes = attributes
-      end
+  def call(value, options)
+    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?
 
-      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
+    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
+  def with_wrapped_subschemas(wrapper)
+    wrapped_attributes = attributes.map do |attr|
+      attr.with_wrapped_value_schema(wrapper)
+    end
 
-        self.class.new(wrapped_attributes)
-      end
+    self.class.new(wrapped_attributes)
+  end
 
-      def [](attr_key)
-        attributes.find{ |attr| attr.key == attr_key }
-      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
+  def merge(new_attributes)
+    merged_attrs = (attributes + new_attributes)
+      .map { |attr| [attr.key, attr] }
+      .to_h
+      .values
 
-      private
+    self.class.new(merged_attrs)
+  end
 
-      def missing_keys(value)
-        attributes
-          .reject(&:optional)
-          .map(&:key)
-          .reject{ |k| value.has_key?(k) }
-      end
+  def without(attribute_keys)
+    filtered_attrs = attributes
+      .reject { |attr| attribute_keys.include?(attr.key) }
 
-      def missing_attrs_result(value)
-        Result.failure(Error.new(
-          schema: self,
-          value: value,
-          symbolic_name: :missing_attributes,
-          vars: missing_keys(value),
-        ))
-      end
+    self.class.new(filtered_attrs)
+  end
 
-      def extraneous_keys(value)
-        allowed_keys = attributes.map(&:key)
-        value.keys.reject{ |k| allowed_keys.include?(k) }
-      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
 
-      def extraneous_attrs_result(value)
-        Result.failure(Error.new(
-          schema: self,
-          value: value,
-          symbolic_name: :extraneous_attributes,
-          vars: extraneous_keys(value),
-        ))
-      end
+  private
 
-      def attr_subresults(value, options)
-        subresults_by_key = {}
+  def missing_keys(value)
+    attributes
+      .reject(&:optional)
+      .map(&:key)
+      .reject{ |k| value.has_key?(k) }
+  end
 
-        @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
+  def missing_attrs_result(value)
+    Result.failure(Error.new(
+      schema: self,
+      value: value,
+      symbolic_name: :missing_attributes,
+      vars: {
+        missing_keys: missing_keys(value),
+      }
+    ))
+  end
 
-        subresults_by_key
-      end
+  def extraneous_keys(value)
+    allowed_keys = attributes.map(&:key)
+    value.keys.reject{ |k| allowed_keys.include?(k) }
+  end
 
-      def failure_error(results)
-        error = {}
+  def extraneous_attrs_result(value)
+    Result.failure(Error.new(
+      schema: self,
+      value: value,
+      symbolic_name: :extraneous_attributes,
+      vars: {
+        extraneous_keys: extraneous_keys(value),
+      },
+    ))
+  end
 
-        results.each do |key, attr_result|
-          if attr_result.invalid?
-            error[key] = attr_result.error
-          end
-        end
+  def attr_subresults(value, options)
+    subresults_by_key = {}
 
-        error
+    @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
 
-      def success_value(subresults)
-        subresults
-          .map{ |key, attr_result| [key, attr_result.value] }
-          .to_h
-      end
+    subresults_by_key
+  end
 
-      def not_a_hash_result(value)
-        Result.failure(
-          Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :not_a_hash,
-          )
-        )
+  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