rschema 3.1.1 → 3.2.0

data/lib/rschema/schemas/enum.rb

@@ -1,41 +1,48 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that matches a values in a given set.
+    #
+    # @example Rock-Paper-Scissors values
+    #     schema = RSchema.define { enum([:rock, :paper, :scissors]) }
+    #     schema.valid?(:rock)  #=> true
+    #     schema.valid?(:paper) #=> true
+    #     schema.valid?(:gun)   #=> false
+    #
+    class Enum
+      attr_reader :members, :subschema
 
-#
-# A schema that matches a values in a given set.
-#
-# @example Rock-Paper-Scissors values
-#     schema = RSchema.define { enum([:rock, :paper, :scissors]) }
-#     schema.valid?(:rock)  #=> true
-#     schema.valid?(:paper) #=> true
-#     schema.valid?(:gun)   #=> false
-#
-class Enum
-  attr_reader :members, :subschema
+      def initialize(members, subschema)
+        @members = members
+        @subschema = subschema
+      end
 
-  def initialize(members, subschema)
-    @members = members
-    @subschema = 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(subresult.value))
+        end
+      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
 
-  def with_wrapped_subschemas(wrapper)
-    self.class.new(members, wrapper.wrap(subschema))
+      private
+
+      def error(value)
+        Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :not_a_member,
+        )
+      end
+    end
   end
 end
-end
-end

data/lib/rschema/schemas/fixed_hash.rb

@@ -1,184 +1,187 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
-
-#
-# A schema that matches `Hash` objects with known keys
-#
-# @example A typical fixed hash schema
-#     schema = RSchema.define do
-#       fixed_hash(
-#         name: _String,
-#         optional(:age) => _Integer,
-#       )
-#     end
-#     schema.valid?({ name: "Tom" }) #=> true
-#     schema.valid?({ name: "Dane", age: 55 }) #=> true
-#
-class FixedHash
-  attr_reader :attributes
-
-  def initialize(attributes)
-    @attributes = attributes
-  end
+  module Schemas
+    #
+    # A schema that matches `Hash` objects with known keys
+    #
+    # @example A typical fixed hash schema
+    #     schema = RSchema.define do
+    #       fixed_hash(
+    #         name: _String,
+    #         optional(:age) => _Integer,
+    #       )
+    #     end
+    #     schema.valid?({ name: "Tom" }) #=> true
+    #     schema.valid?({ name: "Dane", age: 55 }) #=> true
+    #
+    class FixedHash
+      attr_reader :attributes
+
+      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)
+        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
+      #
+      # Creates a new {FixedHash} schema with the given attributes merged in
+      #
+      # @param new_attributes [Array<Attribute>] The attributes to merge
+      # @return [FixedHash] A new schema with the given attributes merged in
+      #
+      # @example Merging new attributes into an existing {Schemas::FixedHash}
+      #     person_schema = RSchema.define_hash {{
+      #       name: _String,
+      #       age: _Integer,
+      #     }}
+      #     person_schema.valid?(name: "t", age: 5) #=> true
+      #     person_schema.valid?(name: "t", age: 5, id: 3) #=> false
+      #
+      #     person_with_id_schema = RSchema.define do
+      #       person_schema.merge(attributes(
+      #         id: _Integer,
+      #       ))
+      #     end
+      #     person_with_id_schema.valid?(name: "t", age: 5, id: 3) #=> true
+      #     person_with_id_schema.valid?(name: "t", age: 5) #=> false
+      #
+      def merge(new_attributes)
+        merged_attrs = (attributes + new_attributes)
+                       .map { |attr| [attr.key, attr] }
+                       .to_h
+                       .values
+
+        self.class.new(merged_attrs)
+      end
 
-  #
-  # Creates a new {FixedHash} schema with the given attributes merged in
-  #
-  # @param new_attributes [Array<Attribute>] The attributes to merge
-  # @return [FixedHash] A new schema with the given attributes merged in
-  #
-  # @example Merging new attributes into an existing {Schemas::FixedHash} schema
-  #     person_schema = RSchema.define_hash {{
-  #       name: _String,
-  #       age: _Integer,
-  #     }}
-  #     person_schema.valid?(name: "t", age: 5) #=> true
-  #     person_schema.valid?(name: "t", age: 5, id: 3) #=> false
-  #
-  #     person_with_id_schema = RSchema.define do
-  #       person_schema.merge(attributes(
-  #         id: _Integer,
-  #       ))
-  #     end
-  #     person_with_id_schema.valid?(name: "t", age: 5, id: 3) #=> true
-  #     person_with_id_schema.valid?(name: "t", age: 5) #=> false
-  #
-  def merge(new_attributes)
-    merged_attrs = (attributes + new_attributes)
-      .map { |attr| [attr.key, attr] }
-      .to_h
-      .values
-
-    self.class.new(merged_attrs)
-  end
+      #
+      # Creates a new {FixedHash} schema with the given attributes removed
+      #
+      # @param attribute_keys [Array<Object>] The keys to remove
+      # @return [FixedHash] A new schema with the given attributes removed
+      #
+      # @example Removing an attribute
+      #     cat_and_dog = RSchema.define_hash {{
+      #       dog: _String,
+      #       cat: _String,
+      #     }}
+      #
+      #     only_cat = RSchema.define { cat_and_dog.without(:dog) }
+      #     only_cat.valid?({ cat: 'meow' }) #=> true
+      #     only_cat.valid?({ cat: 'meow', dog: 'woof' }) #=> false
+      #
+      def without(attribute_keys)
+        filtered_attrs = attributes
+                         .reject { |attr| attribute_keys.include?(attr.key) }
+
+        self.class.new(filtered_attrs)
+      end
 
-  #
-  # Creates a new {FixedHash} schema with the given attributes removed
-  #
-  # @param attribute_keys [Array<Object>] The keys to remove
-  # @return [FixedHash] A new schema with the given attributes removed
-  #
-  # @example Removing an attribute
-  #     cat_and_dog = RSchema.define_hash {{
-  #       dog: _String,
-  #       cat: _String,
-  #     }}
-  #
-  #     only_cat = RSchema.define { cat_and_dog.without(:dog) }
-  #     only_cat.valid?({ cat: 'meow' }) #=> true
-  #     only_cat.valid?({ cat: 'meow', dog: 'woof' }) #=> false
-  #
-  def without(attribute_keys)
-    filtered_attrs = attributes
-      .reject { |attr| attribute_keys.include?(attr.key) }
-
-    self.class.new(filtered_attrs)
-  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
 
-  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
 
-  private
+      def missing_keys(value)
+        attributes
+          .reject(&:optional)
+          .map(&:key)
+          .reject { |k| value.key?(k) }
+      end
 
-  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: missing_keys(value)
+            },
+          ),
+        )
+      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
+      def extraneous_keys(value)
+        allowed_keys = attributes.map(&:key)
+        value.keys.reject { |k| allowed_keys.include?(k) }
+      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: extraneous_keys(value)
+            },
+          ),
+        )
+      end
 
-  def extraneous_attrs_result(value)
-    Result.failure(Error.new(
-      schema: self,
-      value: value,
-      symbolic_name: :extraneous_attributes,
-      vars: {
-        extraneous_keys: extraneous_keys(value),
-      },
-    ))
-  end
+      def attr_subresults(value, options)
+        subresults_by_key = {}
 
-  def attr_subresults(value, options)
-    subresults_by_key = {}
+        @attributes.map do |attr|
+          next unless value.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
 
-    @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?
+        subresults_by_key
       end
-    end
-
-    subresults_by_key
-  end
 
-  def failure_error(subresults)
-    subresults
-      .select{ |_, result| result.invalid? }
-      .map{ |key, result| [key, result.error] }
-      .to_h
-  end
+      def failure_error(subresults)
+        subresults
+          .select { |_, result| result.invalid? }
+          .map { |key, result| [key, result.error] }
+          .to_h
+      end
 
-  def success_value(subresults)
-    subresults
-      .map{ |key, attr_result| [key, attr_result.value] }
-      .to_h
-  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,
-      )
-    )
+      def not_a_hash_result(value)
+        Result.failure(
+          Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :not_a_hash,
+          ),
+        )
+      end
+    end
   end
 end
-
-end
-end

data/lib/rschema/schemas/fixed_length_array.rb

@@ -1,72 +1,80 @@
+# frozen_string_literal: true
+
 module RSchema
-module Schemas
+  module Schemas
+    #
+    # A schema that represents an array of fixed length
+    #
+    # Each element in the fixed-length array has its own subschema
+    #
+    # @example A fixed-length array schema
+    #     schema = RSchema.define { array(_Integer, _String) }
+    #     schema.valid?([5, "hello"]) #=> true
+    #     schema.valid?([5]) #=> false
+    #     schema.valid?([5, "hello", "world"]) #=> false
+    #
+    class FixedLengthArray
+      attr_reader :subschemas
 
-#
-# A schema that represents an array of fixed length
-#
-# Each element in the fixed-length array has its own subschema
-#
-# @example A fixed-length array schema
-#     schema = RSchema.define { array(_Integer, _String) }
-#     schema.valid?([5, "hello"]) #=> true
-#     schema.valid?([5]) #=> false
-#     schema.valid?([5, "hello", "world"]) #=> false
-#
-class FixedLengthArray
-  attr_reader :subschemas
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
 
-  def initialize(subschemas)
-    @subschemas = subschemas
-  end
+      def call(value, options)
+        return type_failure(value) unless value.is_a?(Array)
+        return size_failure(value) unless value.size == @subschemas.size
 
-  def call(value, options)
-    unless value.kind_of?(Array)
-      return Result.failure(Error.new(
-        symbolic_name: :not_an_array,
-        schema: self,
-        value: value,
-      ))
-    end
+        validated_array, error = apply_subschemas(value, options)
+        if error.empty?
+          Result.success(validated_array)
+        else
+          Result.failure(error)
+        end
+      end
 
-    unless value.size == @subschemas.size
-      return Result.failure(Error.new(
-        symbolic_name: :incorrect_size,
-        schema: self,
-        value: value,
-      ))
-    end
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map { |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
 
-    validate_value, error = apply_subschemas(value, options)
-    if error.empty?
-      Result.success(validate_value)
-    else
-      Result.failure(error)
-    end
-  end
+      private
 
-  def with_wrapped_subschemas(wrapper)
-    wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
-    self.class.new(wrapped_subschemas)
-  end
+      def apply_subschemas(array, options)
+        validated_array = []
+        errors = {}
 
-  private
+        array.zip(@subschemas).each_with_index do |(subvalue, subschema), idx|
+          result = subschema.call(subvalue, options)
+          if result.valid?
+            validated_array << result.value
+          else
+            errors[idx] = result.error
+            break if options.fail_fast?
+          end
+        end
 
-  def apply_subschemas(array_value, options)
-    validate_value = []
-    errors = {}
+        [validated_array, errors]
+      end
 
-    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?
+      def type_failure(value)
+        Result.failure(
+          Error.new(
+            symbolic_name: :not_an_array,
+            schema: self,
+            value: value,
+          ),
+        )
       end
-    end
 
-    [validate_value, errors]
+      def size_failure(value)
+        Result.failure(
+          Error.new(
+            symbolic_name: :incorrect_size,
+            schema: self,
+            value: value,
+          ),
+        )
+      end
+    end
   end
 end
-end
-end