rschema 3.1.1 → 3.2.0

data/lib/rschema/schemas/maybe.rb

@@ -1,35 +1,35 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema representing that a value may be `nil`
+    #
+    # If the value is not `nil`, it must conform to the subschema
+    #
+    # @example A nil-able Integer
+    #     schema = RSchema.define{ maybe(_Integer) }
+    #     schema.valid?(5) #=> true
+    #     schema.valid?(nil) #=> true
+    #
+    class Maybe
+      attr_reader :subschema
 
-#
-# A schema representing that a value may be `nil`
-#
-# If the value is not `nil`, it must conform to the subschema
-#
-# @example A nil-able Integer
-#     schema = RSchema.define{ maybe(_Integer) }
-#     schema.valid?(5) #=> true
-#     schema.valid?(nil) #=> true
-#
-class Maybe
-  attr_reader :subschema
+      def initialize(subschema)
+        @subschema = subschema
+      end
 
-  def initialize(subschema)
-    @subschema = subschema
-  end
+      def call(value, options)
+        if value.nil?
+          Result.success(value)
+        else
+          @subschema.call(value, options)
+        end
+      end
 
-  def call(value, options)
-    if nil == value
-      Result.success(value)
-    else
-      @subschema.call(value, options)
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(wrapper.wrap(subschema))
+      end
     end
   end
-
-  def with_wrapped_subschemas(wrapper)
-    self.class.new(wrapper.wrap(subschema))
-  end
-
-end
-end
 end

data/lib/rschema/schemas/pipeline.rb

@@ -1,43 +1,43 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that chains together an ordered list of other schemas
+    #
+    # @example A schema for positive floats
+    #     schema = RSchema.define do
+    #       pipeline(
+    #         _Float,
+    #         predicate{ |f| f > 0.0 },
+    #       )
+    #     end
+    #     schema.valid?(6.2) #=> true
+    #     schema.valid?('hi') #=> false (because it's not a Float)
+    #     schema.valid?(-6.2) #=> false (because predicate failed)
+    #
+    class Pipeline
+      attr_reader :subschemas
 
-#
-# A schema that chains together an ordered list of other schemas
-#
-# @example A schema for positive floats
-#     schema = RSchema.define do
-#       pipeline(
-#         _Float,
-#         predicate{ |f| f > 0.0 },
-#       )
-#     end
-#     schema.valid?(6.2) #=> true
-#     schema.valid?('hi') #=> false (because it's not a Float)
-#     schema.valid?(-6.2) #=> false (because predicate failed)
-#
-class Pipeline
-  attr_reader :subschemas
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
 
-  def initialize(subschemas)
-    @subschemas = subschemas
-  end
+      def call(value, options)
+        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)
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map { |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
+    end
   end
-
-end
-end
 end

data/lib/rschema/schemas/predicate.rb

@@ -1,41 +1,47 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that uses a given block to determine whether a value is valid
+    #
+    # @example A predicate that checks if numbers are odd
+    #     schema = RSchema.define do
+    #       predicate('odd'){ |x| x.odd? }
+    #     end
+    #     schema.valid?(5) #=> true
+    #     schema.valid?(6) #=> false
+    #
+    class Predicate
+      attr_reader :block, :name
 
-#
-# A schema that uses a given block to determine whether a value is valid
-#
-# @example A predicate that checks if numbers are odd
-#     schema = RSchema.define do
-#       predicate('odd'){ |x| x.odd? }
-#     end
-#     schema.valid?(5) #=> true
-#     schema.valid?(6) #=> false
-#
-class Predicate
-  attr_reader :block, :name
+      def initialize(name = nil, &block)
+        @block = block
+        @name = name
+      end
 
-  def initialize(name = nil, &block)
-    @block = block
-    @name = name
-  end
+      def call(value, _options)
+        if block.call(value)
+          Result.success(value)
+        else
+          Result.failure(error(value))
+        end
+      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
 
-  def with_wrapped_subschemas(wrapper)
-    self
-  end
+      private
 
-end
-end
+      def error(value)
+        Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :false,
+          vars: { predicate_name: name },
+        )
+      end
+    end
+  end
 end

data/lib/rschema/schemas/set.rb

@@ -1,61 +1,70 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module RSchema
-module Schemas
-
-#
-# A schema that matches `Set` objects (from the Ruby standard library)
-#
-# @example A set of integers
-#     require 'set'
-#     schema = RSchema.define { set(_Integer) }
-#     schema.valid?(Set[1, 2, 3]) #=> true
-#     schema.valid?(Set[:a, :b, :c]) #=> false
-#
-class Set
-  attr_reader :subschema
-
-  def initialize(subschema)
-    @subschema = subschema
-  end
+  module Schemas
+    #
+    # A schema that matches `Set` objects (from the Ruby standard library)
+    #
+    # @example A set of integers
+    #     require 'set'
+    #     schema = RSchema.define { set(_Integer) }
+    #     schema.valid?(Set[1, 2, 3]) #=> true
+    #     schema.valid?(Set[:a, :b, :c]) #=> false
+    #
+    class Set
+      attr_reader :subschema
+
+      def initialize(subschema)
+        @subschema = subschema
+      end
 
-  def call(value, options)
-    return not_a_set_result(value) unless value.is_a?(::Set)
+      def call(value, options)
+        return not_a_set_result(value) unless value.is_a?(::Set)
 
-    result_value = ::Set.new
-    result_errors = {}
+        validated_set, errors = apply_subschema(value, options)
 
-    value.each do |subvalue|
-      subresult = subschema.call(subvalue, options)
-      if subresult.valid?
-        result_value << subresult.value
-      else
-        result_errors[subvalue] = subresult.error
+        if errors.empty?
+          Result.success(validated_set)
+        else
+          Result.failure(errors)
+        end
       end
 
-      break if options.fail_fast?
-    end
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschema = wrapper.wrap(subschema)
+        self.class.new(wrapped_subschema)
+      end
 
-    if result_errors.empty?
-      Result.success(result_value)
-    else
-      Result.failure(result_errors)
-    end
-  end
+      private
 
-  def with_wrapped_subschemas(wrapper)
-    wrapped_subschema = wrapper.wrap(subschema)
-    self.class.new(wrapped_subschema)
-  end
+      def apply_subschema(set, options)
+        validated_set = ::Set.new
+        errors = {}
+
+        set.each do |subvalue|
+          subresult = subschema.call(subvalue, options)
+          if subresult.valid?
+            validated_set << subresult.value
+          else
+            errors[subvalue] = subresult.error
+            break if options.fail_fast?
+          end
+        end
+
+        [validated_set, errors]
+      end
 
-  private
-    def not_a_set_result(value)
-      Result.failure(Error.new(
-        schema: self,
-        symbolic_name: :not_a_set,
-        value: value,
-      ))
+      def not_a_set_result(value)
+        Result.failure(
+          Error.new(
+            schema: self,
+            symbolic_name: :not_a_set,
+            value: value,
+          ),
+        )
+      end
     end
-end
-end
+  end
 end

data/lib/rschema/schemas/sum.rb

@@ -1,43 +1,40 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that represents a "sum type"
+    #
+    # Values must conform to one of the subschemas.
+    #
+    # @example A schema that matches both Integers and Strings
+    #     schema = RSchema.define { either(_String, _Integer) }
+    #     schema.valid?("hello") #=> true
+    #     schema.valid?(5) #=> true
+    #
+    class Sum
+      attr_reader :subschemas
 
-#
-# A schema that represents a "sum type"
-#
-# Values must conform to one of the subschemas.
-#
-# @example A schema that matches both Integers and Strings
-#     schema = RSchema.define { either(_String, _Integer) }
-#     schema.valid?("hello") #=> true
-#     schema.valid?(5) #=> true
-#
-class Sum
-  attr_reader :subschemas
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
 
-  def initialize(subschemas)
-    @subschemas = subschemas
-  end
+      def call(value, options)
+        suberrors = []
 
-  def call(value, options)
-    suberrors = []
+        @subschemas.each do |ss|
+          result = ss.call(value, options)
+          return result if result.valid?
+          suberrors << result.error
+        end
 
-    @subschemas.each do |subsch|
-      result = subsch.call(value, options)
-      if result.valid?
-        return result
-      else
-        suberrors << result.error
+        Result.failure(suberrors)
       end
-    end
-
-    Result.failure(suberrors)
-  end
 
-  def with_wrapped_subschemas(wrapper)
-    wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
-    self.class.new(wrapped_subschemas)
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map { |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
+    end
   end
-
-end
-end
 end

data/lib/rschema/schemas/type.rb

@@ -1,45 +1,51 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that matches values of a given type (i.e. `value.is_a?(type)`)
+    #
+    # @example An Integer schema
+    #     schema = RSchema.define { _Integer }
+    #     schema.valid?(5) #=> true
+    #
+    # @example A namespaced type
+    #     schema = RSchema.define do
+    #       # This will not work:
+    #       # _ActiveWhatever::Thing
+    #
+    #       # This will work:
+    #       type(ActiveWhatever::Thing)
+    #     end
+    #
+    class Type
+      attr_reader :type
 
-#
-# A schema that matches values of a given type (i.e. `value.is_a?(type)`)
-#
-# @example An Integer schema
-#     schema = RSchema.define { _Integer }
-#     schema.valid?(5) #=> true
-#
-# @example A namespaced type
-#     schema = RSchema.define do
-#       # This will not work:
-#       # _ActiveWhatever::Thing
-#
-#       # This will work:
-#       type(ActiveWhatever::Thing)
-#     end
-#
-class Type
-  attr_reader :type
+      def initialize(type)
+        @type = type
+      end
 
-  def initialize(type)
-    @type = type
-  end
+      def call(value, _options)
+        if value.is_a?(@type)
+          Result.success(value)
+        else
+          Result.failure(error(value))
+        end
+      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
 
-  def with_wrapped_subschemas(wrapper)
-    self
-  end
+      private
 
-end
-end
+      def error(value)
+        Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :wrong_type,
+        )
+      end
+    end
+  end
 end