rschema 3.0.1.pre3 → 3.0.1.pre4

data/lib/rschema/schemas/fixed_length_array.rb

@@ -1,60 +1,60 @@
 module RSchema
-  module Schemas
-    class FixedLengthArray
-      attr_reader :subschemas
+module Schemas
+class FixedLengthArray
+  attr_reader :subschemas
 
-      def initialize(subschemas)
-        @subschemas = subschemas
-      end
+  def initialize(subschemas)
+    @subschemas = subschemas
+  end
 
-      def call(value, options=RSchema::Options.default)
-        unless value.kind_of?(Array)
-          return Result.failure(Error.new(
-            symbolic_name: :not_an_array,
-            schema: self,
-            value: value,
-          ))
-        end
-
-        unless value.size == @subschemas.size
-          return Result.failure(Error.new(
-            symbolic_name: :incorrect_size,
-            schema: self,
-            value: value,
-          ))
-        end
-
-        validate_value, error = apply_subschemas(value, options)
-        if error.empty?
-          Result.success(validate_value)
-        else
-          Result.failure(error)
-        end
-      end
+  def call(value, options)
+    unless value.kind_of?(Array)
+      return Result.failure(Error.new(
+        symbolic_name: :not_an_array,
+        schema: self,
+        value: value,
+      ))
+    end
 
-      def with_wrapped_subschemas(wrapper)
-        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
-        self.class.new(wrapped_subschemas)
-      end
+    unless value.size == @subschemas.size
+      return Result.failure(Error.new(
+        symbolic_name: :incorrect_size,
+        schema: self,
+        value: value,
+      ))
+    end
 
-      private
+    validate_value, error = apply_subschemas(value, options)
+    if error.empty?
+      Result.success(validate_value)
+    else
+      Result.failure(error)
+    end
+  end
+
+  def with_wrapped_subschemas(wrapper)
+    wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+    self.class.new(wrapped_subschemas)
+  end
 
-      def apply_subschemas(array_value, options)
-        validate_value = []
-        errors = {}
+  private
 
-        array_value.zip(@subschemas).each_with_index do |(subvalue, subschema), idx|
-          result = subschema.call(subvalue, options)
-          if result.valid?
-            validate_value << result.value
-          else
-            errors[idx] = result.error
-            break if options.fail_fast?
-          end
-        end
+  def apply_subschemas(array_value, options)
+    validate_value = []
+    errors = {}
 
-        [validate_value, errors]
+    array_value.zip(@subschemas).each_with_index do |(subvalue, subschema), idx|
+      result = subschema.call(subvalue, options)
+      if result.valid?
+        validate_value << result.value
+      else
+        errors[idx] = result.error
+        break if options.fail_fast?
       end
     end
+
+    [validate_value, errors]
   end
 end
+end
+end

data/lib/rschema/schemas/maybe.rb

@@ -1,23 +1,24 @@
 module RSchema
-  module Schemas
-    class Maybe
-      attr_reader :subschema
+module Schemas
+class Maybe
+  attr_reader :subschema
 
-      def initialize(subschema)
-        @subschema = subschema
-      end
-
-      def call(value, options=Options.default)
-        if value == nil
-          Result.success(value)
-        else
-          @subschema.call(value, options)
-        end
-      end
+  def initialize(subschema)
+    @subschema = subschema
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self.class.new(wrapper.wrap(subschema))
-      end
+  def call(value, options)
+    if value == nil
+      Result.success(value)
+    else
+      @subschema.call(value, options)
     end
   end
+
+  def with_wrapped_subschemas(wrapper)
+    self.class.new(wrapper.wrap(subschema))
+  end
+
+end
+end
 end

data/lib/rschema/schemas/pipeline.rb

@@ -1,27 +1,28 @@
 module RSchema
-  module Schemas
-    class Pipeline
-      attr_reader :subschemas
+module Schemas
+class Pipeline
+  attr_reader :subschemas
 
-      def initialize(subschemas)
-        @subschemas = subschemas
-      end
+  def initialize(subschemas)
+    @subschemas = subschemas
+  end
 
-      def call(value, options=Options.default)
-        result = Result.success(value)
+  def call(value, options)
+    result = Result.success(value)
 
-        subschemas.each do |subsch|
-          result = subsch.call(result.value, options)
-          break if result.invalid?
-        end
+    subschemas.each do |subsch|
+      result = subsch.call(result.value, options)
+      break if result.invalid?
+    end
 
-        result
-      end
+    result
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
-        self.class.new(wrapped_subschemas)
-      end
-    end
+  def with_wrapped_subschemas(wrapper)
+    wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+    self.class.new(wrapped_subschemas)
   end
+
+end
+end
 end

data/lib/rschema/schemas/predicate.rb

@@ -1,27 +1,30 @@
 module RSchema
-  module Schemas
-    class Predicate
-      attr_reader :block
+module Schemas
+class Predicate
+  attr_reader :block, :name
 
-      def initialize(block)
-        @block = block
-      end
-
-      def call(value, options=Options.default)
-        if block.call(value)
-          Result.success(value)
-        else
-          Result.failure(Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :false,
-          ))
-        end
-      end
+  def initialize(name = nil, &block)
+    @block = block
+    @name = name
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self
-      end
+  def call(value, options)
+    if block.call(value)
+      Result.success(value)
+    else
+      Result.failure(Error.new(
+        schema: self,
+        value: value,
+        symbolic_name: :false,
+        vars: { predicate_name: name }
+      ))
     end
   end
+
+  def with_wrapped_subschemas(wrapper)
+    self
+  end
+
+end
+end
 end

data/lib/rschema/schemas/set.rb

@@ -1,56 +1,51 @@
 require 'set'
 
 module RSchema
-  module Schemas
-    class Set
-      attr_reader :subschema
+module Schemas
+class Set
+  attr_reader :subschema
 
-      def initialize(subschema)
-        @subschema = subschema
-      end
+  def initialize(subschema)
+    @subschema = subschema
+  end
 
-      def call(value, options=RSchema::Options.default)
-        return not_a_set_result(value) unless value.is_a?(::Set)
-
-        result_value = ::Set.new
-        result_errors = []
-
-        value.each do |subvalue|
-          subresult = subschema.call(subvalue, options)
-          if subresult.valid?
-            result_value << subresult.value
-          else
-            result_errors << subresult.error
-          end
-
-          break if options.fail_fast?
-        end
-
-        if result_errors.empty?
-          Result.success(result_value)
-        else
-          Result.failure(Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :contents_invalid,
-            vars: result_errors,
-          ))
-        end
-      end
+  def call(value, options)
+    return not_a_set_result(value) unless value.is_a?(::Set)
 
-      def with_wrapped_subschemas(wrapper)
-        wrapped_subschema = wrapper.wrap(subschema)
-        self.class.new(wrapped_subschema)
+    result_value = ::Set.new
+    result_errors = {}
+
+    value.each do |subvalue|
+      subresult = subschema.call(subvalue, options)
+      if subresult.valid?
+        result_value << subresult.value
+      else
+        result_errors[subvalue] = subresult.error
       end
 
-      private
-        def not_a_set_result(value)
-          Result.failure(Error.new(
-            schema: self,
-            symbolic_name: :not_a_set,
-            value: value,
-          ))
-        end
+      break if options.fail_fast?
+    end
+
+    if result_errors.empty?
+      Result.success(result_value)
+    else
+      Result.failure(result_errors)
     end
   end
+
+  def with_wrapped_subschemas(wrapper)
+    wrapped_subschema = wrapper.wrap(subschema)
+    self.class.new(wrapped_subschema)
+  end
+
+  private
+    def not_a_set_result(value)
+      Result.failure(Error.new(
+        schema: self,
+        symbolic_name: :not_a_set,
+        value: value,
+      ))
+    end
+end
+end
 end

data/lib/rschema/schemas/sum.rb

@@ -1,36 +1,32 @@
 module RSchema
-  module Schemas
-    class Sum
-      attr_reader :subschemas
+module Schemas
+class Sum
+  attr_reader :subschemas
 
-      def initialize(subschemas)
-        @subschemas = subschemas
-      end
-
-      def call(value, options=Options.default)
-        suberrors = []
-
-        @subschemas.each do |subsch|
-          result = subsch.call(value, options)
-          if result.valid?
-            return result
-          else
-            suberrors << result.error
-          end
-        end
+  def initialize(subschemas)
+    @subschemas = subschemas
+  end
 
-        Result.failure(Error.new(
-          schema: self,
-          value: value,
-          symbolic_name: :all_invalid,
-          vars: suberrors,
-        ))
-      end
+  def call(value, options)
+    suberrors = []
 
-      def with_wrapped_subschemas(wrapper)
-        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
-        self.class.new(wrapped_subschemas)
+    @subschemas.each do |subsch|
+      result = subsch.call(value, options)
+      if result.valid?
+        return result
+      else
+        suberrors << result.error
       end
     end
+
+    Result.failure(suberrors)
   end
+
+  def with_wrapped_subschemas(wrapper)
+    wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+    self.class.new(wrapped_subschemas)
+  end
+
+end
+end
 end

data/lib/rschema/schemas/type.rb

@@ -1,27 +1,28 @@
 module RSchema
-  module Schemas
-    class Type
-      attr_reader :type
+module Schemas
+class Type
+  attr_reader :type
 
-      def initialize(type)
-        @type = type
-      end
-
-      def call(value, options = RSchema::Options.default)
-        if value.is_a?(@type)
-          Result.success(value)
-        else
-          Result.failure(Error.new(
-            schema: self,
-            value: value,
-            symbolic_name: :wrong_type,
-          ))
-        end
-      end
+  def initialize(type)
+    @type = type
+  end
 
-      def with_wrapped_subschemas(wrapper)
-        self
-      end
+  def call(value, options)
+    if value.is_a?(@type)
+      Result.success(value)
+    else
+      Result.failure(Error.new(
+        schema: self,
+        value: value,
+        symbolic_name: :wrong_type,
+      ))
     end
   end
+
+  def with_wrapped_subschemas(wrapper)
+    self
+  end
+
+end
+end
 end