rschema 3.1.1 → 3.2.0

data/lib/rschema/schemas.rb

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

data/lib/rschema/schemas/anything.rb

@@ -1,29 +1,28 @@
-module RSchema
-module Schemas
-
-#
-# A schema that matches literally any value
-#
-# @example The anything schema
-#   schema = RSchema.define { anything }
-#   schema.valid?(nil) #=> true
-#   schema.valid?(6.2) #=> true
-#   schema.valid?({ hello: Time.now }) #=> true
-#
-class Anything
+# frozen_string_literal: true
 
-  def self.instance
-    @instance ||= new
-  end
+module RSchema
+  module Schemas
+    #
+    # A schema that matches literally any value
+    #
+    # @example The anything schema
+    #   schema = RSchema.define { anything }
+    #   schema.valid?(nil) #=> true
+    #   schema.valid?(6.2) #=> true
+    #   schema.valid?({ hello: Time.now }) #=> true
+    #
+    class Anything
+      def self.instance
+        @instance ||= new
+      end
 
-  def call(value, options)
-    Result.success(value)
-  end
+      def call(value, _options)
+        Result.success(value)
+      end
 
-  def with_wrapped_subschemas(wrapper)
-    self
+      def with_wrapped_subschemas(_wrapper)
+        self
+      end
+    end
   end
-
-end
-end
 end

data/lib/rschema/schemas/boolean.rb

@@ -1,36 +1,42 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that matches only `true` and `false`
+    #
+    # @example The boolean schema
+    #     schema = RSchema.define { boolean }
+    #     schema.valid?(true)  #=> true
+    #     schema.valid?(false) #=> true
+    #     schema.valid?(nil)   #=> false
+    #
+    class Boolean
+      def self.instance
+        @instance ||= new
+      end
 
-#
-# A schema that matches only `true` and `false`
-#
-# @example The boolean schema
-#     schema = RSchema.define { boolean }
-#     schema.valid?(true)  #=> true
-#     schema.valid?(false) #=> true
-#     schema.valid?(nil)   #=> false
-#
-class Boolean
-  def self.instance
-    @instance ||= new
-  end
+      def call(value, _options)
+        if value.equal?(true) || value.equal?(false)
+          Result.success(value)
+        else
+          Result.failure(error(value))
+        end
+      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
 
-  def with_wrapped_subschemas(wrapper)
-    self
-  end
+      private
 
-end
-end
+      def error(value)
+        Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :not_a_boolean,
+        )
+      end
+    end
+  end
 end

data/lib/rschema/schemas/coercer.rb

@@ -1,50 +1,51 @@
-module RSchema
-module Schemas
-
-#
-# A schema that applies a coercer to a value, before passing the coerced
-# value to a subschema.
-#
-# This is not a type of schema that you would typically create yourself.
-# It is used internally to implement RSchema's coercion functionality.
-#
-class Coercer
-  attr_reader :coercer, :subschema
-
-  def initialize(coercer, subschema)
-    byebug if coercer.is_a?(Array)
-    @coercer = coercer
-    @subschema = subschema
-  end
+# frozen_string_literal: true
 
-  def call(value, options)
-    unless coercer.will_affect?(value)
-      # short-circuit the coercer
-      return @subschema.call(value, options)
-    end
-
-    result = coercer.call(value)
-    if result.valid?
-      @subschema.call(result.value, options)
-    else
-      failure(value, result.error)
+module RSchema
+  module Schemas
+    #
+    # A schema that applies a coercer to a value, before passing the coerced
+    # value to a subschema.
+    #
+    # This is not a type of schema that you would typically create yourself.
+    # It is used internally to implement RSchema's coercion functionality.
+    #
+    class Coercer
+      attr_reader :coercer, :subschema
+
+      def initialize(coercer, subschema)
+        @coercer = coercer
+        @subschema = subschema
+      end
+
+      def call(value, options)
+        unless coercer.will_affect?(value)
+          # short-circuit the coercer
+          return @subschema.call(value, options)
+        end
+
+        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)
+        Result.failure(
+          Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: name || :coercion_failure,
+          ),
+        )
+      end
     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

@@ -1,138 +1,137 @@
+# frozen_string_literal: true
+
 require 'delegate'
 
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A wrapper that provides convenience methods for schema objects.
+    #
+    # Because this class inherits from `SimpleDelegator`, convenience wrappers
+    # behave like their underlying schemas. That is, you can call methods on the
+    # underlying schema object through the convenience wrapper.
+    #
+    # Schema objects only need to implement the `call` method to validate
+    # values. This small interface is simple for schema classes to implement,
+    # but not very descriptive when actually using the schema objects. So, to
+    # make schema objects nicer to use, this class provides a variety of
+    # more-descriptive methods like {#validate}, {#validate!}, {#valid?}, and
+    # {#invalid?}.
+    #
+    class Convenience < SimpleDelegator
+      def initialize(underlying_schema)
+        super
+      end
 
-#
-# A wrapper that provides convenience methods for schema objects.
-#
-# Because this class inherits from `SimpleDelegator`, convenience wrappers
-# behave like their underlying schemas. That is, you can call methods on the
-# underlying schema object through the convenience wrapper.
-#
-# Schema objects only need to implement the `call` method to validate values.
-# This small interface is simple for schema classes to implement, but not
-# very descriptive when actually using the schema objects. So, to make
-# schema objects nicer to use, this class provides a variety of
-# more-descriptive methods like {#validate}, {#validate!}, {#valid?}, and
-# {#invalid?}.
-#
-class Convenience < SimpleDelegator
-  def initialize(underlying_schema)
-    super
-  end
+      # @return [schema] the underlying schema object
+      def underlying_schema
+        __getobj__
+      end
 
-  # @return [schema] the underlying schema object
-  def underlying_schema
-    __getobj__
-  end
+      #
+      # Applies the schema to a value
+      #
+      # This is that same as the `call` method available on all schema objects,
+      # except that the `options` param is optional.
+      #
+      # @param value [Object] The value to validate
+      # @param options [RSchema::Options]
+      #
+      # @return [RSchema::Result]
+      #
+      def validate(value, options = Options.default)
+        call(value, options)
+      end
 
-  #
-  # Applies the schema to a value
-  #
-  # This is that same as the `call` method available on all schema objects,
-  # except that the `options` param is optional.
-  #
-  # @param value [Object] The value to validate
-  # @param options [RSchema::Options]
-  #
-  # @return [RSchema::Result]
-  #
-  def validate(value, options=Options.default)
-    call(value, options)
-  end
+      #
+      # Returns the validation error for the given value
+      #
+      # @param value [Object] The value to validate
+      # @param options [RSchema::Options]
+      #
+      # @return The error object if `value` is invalid, otherwise `nil`.
+      #
+      # @see Result#error
+      #
+      def error_for(value, options = Options.default)
+        result = underlying_schema.call(value, options)
+        if result.valid?
+          nil
+        else
+          result.error
+        end
+      end
 
-  #
-  # Returns the validation error for the given value
-  #
-  # @param value [Object] The value to validate
-  # @param options [RSchema::Options]
-  #
-  # @return The error object if `value` is invalid, otherwise `nil`.
-  #
-  # @see Result#error
-  #
-  def error_for(value, options=Options.default)
-    result = underlying_schema.call(value, options)
-    if result.valid?
-      nil
-    else
-      result.error
-    end
-  end
+      #
+      # Applies the schema to a value, raising an exception if the value is
+      # invalid
+      #
+      # @param value [Object] The value to validate
+      # @param options [RSchema::Options]
+      #
+      # @raise [RSchema::Invalid] If the value is not valid
+      # @return [Object] The validated value
+      #
+      # @see Result#value
+      #
+      def validate!(value, options = Options.default)
+        result = underlying_schema.call(value, options)
+        if result.valid?
+          result.value
+        else
+          raise RSchema::Invalid, result.error
+        end
+      end
 
-  #
-  # Applies the schema to a value, raising an exception if the value is invalid
-  #
-  # @param value [Object] The value to validate
-  # @param options [RSchema::Options]
-  #
-  # @raise [RSchema::Invalid] If the value is not valid
-  # @return [Object] The validated value
-  #
-  # @see Result#value
-  #
-  def validate!(value, options=Options.default)
-    result = underlying_schema.call(value, options)
-    if result.valid?
-      result.value
-    else
-      raise RSchema::Invalid.new(result.error)
-    end
-  end
+      #
+      # Checks whether a value is valid or not
+      #
+      # @param value [Object] The value to validate
+      # @return [Boolean] `true` if the value is valid, otherwise `false`
+      #
+      def valid?(value)
+        result = underlying_schema.call(value, Options.fail_fast)
+        result.valid?
+      end
 
-  #
-  # Checks whether a value is valid or not
-  #
-  # @param value [Object] The value to validate
-  # @return [Boolean] `true` if the value is valid, otherwise `false`
-  #
-  def valid?(value)
-    result = underlying_schema.call(value, Options.fail_fast)
-    result.valid?
-  end
+      #
+      # The opposite of {#valid?}
+      #
+      # @see #valid?
+      #
+      def invalid?(value)
+        !valid?(value)
+      end
 
-  #
-  # The opposite of {#valid?}
-  #
-  # @see #valid?
-  #
-  def invalid?(value)
-    not valid?(value)
-  end
+      #
+      # Wraps the given schema in a {Convenience}, if it isn't already wrapped.
+      #
+      # @param schema [schema] The schema to wrap
+      # @return {Convenience}
+      #
+      def self.wrap(schema)
+        if schema.is_a?(self)
+          schema
+        else
+          new(schema)
+        end
+      end
 
-  #
-  # Wraps the given schema in a {Convenience}, if it isn't already wrapped.
-  #
-  # @param schema [schema] The schema to wrap
-  # @return {Convenience}
-  #
-  def self.wrap(schema)
-    if schema.is_a?(self)
-      schema
-    else
-      new(schema)
-    end
-  end
+      #
+      # Removes any {Convenience} wrappers from a schema
+      #
+      # @param schema [schema] The schema to unwrap
+      # @return [schema] The underlying schema, with all {Convenience} wrappers
+      #   removed
+      def self.unwrap(schema)
+        schema = schema.underlying_schema while schema.is_a?(self)
+        schema
+      end
 
-  #
-  # Removes any {Convenience} wrappers from a schema
-  #
-  # @param schema [schema] The schema to unwrap
-  # @return [schema] The underlying schema, with all {Convenience} wrappers
-  #   removed
-  def self.unwrap(schema)
-    while schema.is_a?(self)
-      schema = schema.underlying_schema
+      # @!visibility private
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(wrapper.wrap(underlying_schema))
+      end
     end
-    schema
-  end
-
-  # @!visibility private
-  def with_wrapped_subschemas(wrapper)
-    self.class.new(wrapper.wrap(underlying_schema))
   end
-
-end
-end
 end