rschema 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d720955c9a91f41ca082da8683dcf7bed5d10ab6
-  data.tar.gz: 6d374b1df2484fa2ec0957ca3d5943289ecb9714
+  metadata.gz: 34db15e35dacc01ece4a64f6bc6f1d699d56a82f
+  data.tar.gz: 0104cab32868f52759495fe90c1139ac7f6ec2b7
 SHA512:
-  metadata.gz: 2152a4189beed6ab21c9fd11afbf668b32cbca48eb58c89820b424473c83ac766e2819f49dc10e456690c4e75a7c2dcb3be1f52cfdc4e89528f34c01c0c45209
-  data.tar.gz: d4ccfbf1529449d6f13633898dde3c5c65f363ba041724503214e68f23720a02c2870c0b0215ed5fd3324e71ff6f49a590ac4eb2bd8c6e4973e9fc2b0ca732cf
+  metadata.gz: ea3e3ea16cc3c1416b03a6df47f6b288f69cca1ed8dd53dfffb3ed8ffd0344eb9eefa7f5695f0d85ec529225b94b298dc9c6a23845558086881dc89f907d60a9
+  data.tar.gz: 649d06c7033f88cd0594f1c89943f991fd351703334780bfe1d4be349bbb4edba29156ecd24c8534d5496ef51b64a6942afb797a24423460e498ca7ec135d709

data/lib/rschema.rb

@@ -1,5 +1,6 @@
-require 'docile'
+# frozen_string_literal: true
 
+require 'docile'
 require 'rschema/options'
 require 'rschema/error'
 require 'rschema/result'
@@ -12,7 +13,6 @@ require 'rschema/coercion_wrapper'
 # Schema-based validation and coercion
 #
 module RSchema
-
   #
   # Creates a schema object using a DSL
   #
@@ -46,6 +46,10 @@ module RSchema
   #   end
   #
   def self.dsl_eval(dsl = nil, &block)
+    if block.nil?
+      raise ArgumentError, 'Must provide a block for the RSchema DSL'
+    end
+
     Docile::Execution.exec_in_proxy_context(
       dsl || default_dsl,
       Docile::FallbackContextProxy,
@@ -63,7 +67,8 @@ module RSchema
   #     end
   #
   # @yield (see .dsl_eval)
-  # @yieldreturn The attributes of the hash schema (the argument to {DSL#fixed_hash}).
+  # @yieldreturn The attributes of the hash schema
+  #   (the argument to {DSL#fixed_hash}).
   # @return [Schemas::Convenience] A {Schemas::FixedHash} schema wrapped in a
   #   {Schemas::Convenience}.
   #
@@ -75,7 +80,7 @@ module RSchema
   #
   def self.define_hash(&block)
     Schemas::Convenience.wrap(
-      default_dsl.fixed_hash(dsl_eval(&block))
+      default_dsl.fixed_hash(dsl_eval(&block)),
     )
   end
 
@@ -103,7 +108,7 @@ module RSchema
   #
   def self.define_predicate(name = nil, &block)
     Schemas::Convenience.wrap(
-      default_dsl.predicate(name, &block)
+      default_dsl.predicate(name, &block),
     )
   end
 
@@ -127,6 +132,9 @@ module RSchema
     include RSchema::DSL
   end
 
+  #
+  # Indicates that validation has failed
+  #
   class Invalid < StandardError
     attr_reader :validation_error
 

data/lib/rschema/coercers.rb

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

data/lib/rschema/coercers/any.rb

@@ -1,44 +1,50 @@
-module RSchema
-module Coercers
-
-  class Any
-    attr_reader :subcoercers
+# frozen_string_literal: true
 
-    def self.[](*subbuilders)
-      Builder.new(subbuilders)
-    end
+module RSchema
+  module Coercers
+    #
+    # Applies subcoercers, in order, until one succeeds
+    #
+    class Any
+      attr_reader :subcoercers
+
+      def self.[](*subbuilders)
+        Builder.new(subbuilders)
+      end
 
-    def initialize(subcoercers)
-      @subcoercers = subcoercers
-    end
+      def initialize(subcoercers)
+        @subcoercers = subcoercers
+      end
 
-    def call(value)
-      subcoercers.each do |coercer|
-        result = coercer.call(value)
-        return result if result.valid?
+      def call(value)
+        subcoercers.each do |coercer|
+          result = coercer.call(value)
+          return result if result.valid?
+        end
+        Result.failure
       end
-      Result.failure
-    end
 
-    def will_affect?(value)
-      subcoercers.any?{ |sc| sc.will_affect?(value) }
-    end
+      def will_affect?(value)
+        subcoercers.any? { |sc| sc.will_affect?(value) }
+      end
 
-    class Builder
-      attr_reader :subbuilders
+      #
+      # Builder for Coercers::Any
+      #
+      class Builder
+        attr_reader :subbuilders
 
-      def initialize(subbuilders)
-        @subbuilders = subbuilders
-      end
+        def initialize(subbuilders)
+          @subbuilders = subbuilders
+        end
 
-      def build(schema)
-        subcoercers = subbuilders.map do |builder|
-          builder.build(schema)
+        def build(schema)
+          subcoercers = subbuilders.map do |builder|
+            builder.build(schema)
+          end
+          Any.new(subcoercers)
         end
-        Any.new(subcoercers)
       end
     end
   end
-
-end
 end

data/lib/rschema/coercers/boolean.rb

@@ -1,34 +1,44 @@
-module RSchema
-module Coercers
+# frozen_string_literal: true
 
-  module Boolean
-    extend self
+module RSchema
+  module Coercers
+    #
+    # Coerces certain strings, and nil, to true or false
+    #
+    module Boolean
+      extend self
 
-    TRUTHY_STRINGS = ['on', '1', 'true', 'yes']
-    FALSEY_STRINGS = ['off', '0', 'false', 'no']
+      TRUTHY_STRINGS = %w[on 1 true yes].freeze
+      FALSEY_STRINGS = %w[off 0 false no].freeze
 
-    def build(schema)
-      self
-    end
+      def build(_schema)
+        self
+      end
 
-    def call(value)
-      case value
-      when true, false then Result.success(value)
-      when nil then Result.success(false)
-      when String
-        case
-        when TRUTHY_STRINGS.include?(value.downcase) then Result.success(true)
-        when FALSEY_STRINGS.include?(value.downcase) then Result.success(false)
+      def call(value)
+        case value
+        when true, false then Result.success(value)
+        when nil then Result.success(false)
+        when String then coerce_string(value)
         else Result.failure
         end
-      else Result.failure
       end
-    end
 
-    def will_affect?(value)
-      true != value && false != value
+      def will_affect?(value)
+        value != true && value != false
+      end
+
+      private
+
+      def coerce_string(str)
+        if TRUTHY_STRINGS.include?(str.downcase)
+          Result.success(true)
+        elsif FALSEY_STRINGS.include?(str.downcase)
+          Result.success(false)
+        else
+          Result.failure
+        end
+      end
     end
   end
-
-end
 end

data/lib/rschema/coercers/chain.rb

@@ -1,45 +1,51 @@
-module RSchema
-module Coercers
-
-  class Chain
-    attr_reader :subcoercers
+# frozen_string_literal: true
 
-    def self.[](*subbuilders)
-      Builder.new(subbuilders)
-    end
+module RSchema
+  module Coercers
+    #
+    # Applies a list of coercers, in order
+    #
+    class Chain
+      attr_reader :subcoercers
+
+      def self.[](*subbuilders)
+        Builder.new(subbuilders)
+      end
 
-    def initialize(subcoercers)
-      @subcoercers = subcoercers
-    end
+      def initialize(subcoercers)
+        @subcoercers = subcoercers
+      end
 
-    def call(value)
-      result = Result.success(value)
-      subcoercers.each do |coercer|
-        result = coercer.call(result.value)
-        break if result.invalid?
+      def call(value)
+        result = Result.success(value)
+        subcoercers.each do |coercer|
+          result = coercer.call(result.value)
+          break if result.invalid?
+        end
+        result
       end
-      result
-    end
 
-    def will_affect?(value)
-      subcoercers.any? { |sc| sc.will_affect?(value) }
-    end
+      def will_affect?(value)
+        subcoercers.any? { |sc| sc.will_affect?(value) }
+      end
 
-    class Builder
-      attr_reader :subbuilders
+      #
+      # Builder for Coercers::Chain
+      #
+      class Builder
+        attr_reader :subbuilders
 
-      def initialize(subbuilders)
-        @subbuilders = subbuilders
-      end
+        def initialize(subbuilders)
+          @subbuilders = subbuilders
+        end
 
-      def build(schema)
-        subcoercers = subbuilders.map do |builder|
-          builder.build(schema)
+        def build(schema)
+          subcoercers = subbuilders.map do |builder|
+            builder.build(schema)
+          end
+          Chain.new(subcoercers)
         end
-        Chain.new(subcoercers)
       end
     end
   end
-
-end
 end

data/lib/rschema/coercers/date.rb

@@ -1,29 +1,38 @@
+# frozen_string_literal: true
+
 module RSchema
-module Coercers
+  module Coercers
+    #
+    # Coerces strings into `Date` objects using `Date.parse`
+    module Date
+      extend self
 
-  module Date
-    extend self
+      def build(_schema)
+        self
+      end
 
-    def build(schema)
-      self
-    end
+      def call(value)
+        case value
+        when ::Date then Result.success(value)
+        when ::String then coerce_string(value)
+        else Result.failure
+        end
+      end
 
-    def call(value)
-      case value
-      when ::Date
-        Result.success(value)
-      when ::String
-        date = ::Date.parse(value) rescue nil
-        date ? Result.success(date) : Result.failure
-      else
-        Result.failure
+      def will_affect?(value)
+        !value.is_a?(::Date)
       end
-    end
 
-    def will_affect?(value)
-      not value.is_a?(::Date)
+      private
+
+      def coerce_string(str)
+        date = begin
+                 ::Date.parse(str)
+               rescue
+                 nil
+               end
+        date ? Result.success(date) : Result.failure
+      end
     end
   end
-
-end
 end

data/lib/rschema/coercers/fixed_hash/default_arrays_to_empty.rb

@@ -1,75 +1,76 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module RSchema
-module Coercers
-module FixedHash
+  module Coercers
+    module FixedHash
+      # The HTTP standard says that when a form is submitted, all unchecked
+      # check boxes will _not_ be sent to the server. That is, they will not
+      # be present at all in the params hash.
+      #
+      # This class coerces these missing values into an empty array, where an
+      # array is expected.
+      class DefaultArraysToEmpty
+        attr_reader :hash_attributes
 
-  # The HTTP standard says that when a form is submitted, all unchecked
-  # check boxes will _not_ be sent to the server. That is, they will not
-  # be present at all in the params hash.
-  #
-  # This class coerces these missing values into an empty array, where an array
-  # is expected.
-  class DefaultArraysToEmpty
-    attr_reader :hash_attributes
+        def self.build(schema)
+          new(schema)
+        end
 
-    def self.build(schema)
-      new(schema)
-    end
+        def initialize(fixed_hash_schema)
+          # TODO: make fixed hash attributes frozen, and eliminate dup
+          @hash_attributes = fixed_hash_schema.attributes.map(&:dup)
+        end
 
-    def initialize(fixed_hash_schema)
-      #TODO: make fixed hash attributes frozen, and eliminate dup
-      @hash_attributes = fixed_hash_schema.attributes.map(&:dup)
-    end
+        def call(value)
+          Result.success(default_arrays_to_empty(value))
+        end
 
-    def call(value)
-      Result.success(default_arrays_to_empty(value))
-    end
+        def will_affect?(value)
+          keys_to_default(value).any?
+        end
 
-    def will_affect?(value)
-      keys_to_default(value).any?
-    end
+        private
 
-    private
-      def default_arrays_to_empty(hash)
-        missing_keys = keys_to_default(hash)
+        def default_arrays_to_empty(hash)
+          missing_keys = keys_to_default(hash)
 
-        if missing_keys.any?
-          defaults = missing_keys.map{ |k| [k, []] }.to_h
-          hash.merge(defaults)
-        else
-          hash # no coercion necessary
+          if missing_keys.any?
+            defaults = missing_keys.map { |k| [k, []] }.to_h
+            hash.merge(defaults)
+          else
+            hash # no coercion necessary
+          end
         end
-      end
 
-      def keys_to_default(value)
-        if value.is_a?(Hash)
-          keys_for_array_defaulting - value.keys
-        else
-          []
+        def keys_to_default(value)
+          if value.is_a?(Hash)
+            keys_for_array_defaulting - value.keys
+          else
+            []
+          end
         end
-      end
-
-      def keys_for_array_defaulting
-        @keys_for_array_defaulting ||= Set.new(
-          hash_attributes
-            .reject(&:optional)
-            .select { |attr| is_array_schema?(attr.value_schema) }
-            .map(&:key)
-        )
-      end
 
-      def is_array_schema?(schema)
-        # dig through all the coercers
-        non_coercer = schema
-        while non_coercer.is_a?(Schemas::Coercer)
-          non_coercer = non_coercer.subschema
+        def keys_for_array_defaulting
+          @keys_for_array_defaulting ||= Set.new(
+            hash_attributes
+              .reject(&:optional)
+              .select { |attr| array_schema?(attr.value_schema) }
+              .map(&:key),
+          )
         end
 
-        non_coercer.is_a?(Schemas::VariableLengthArray)
+        def array_schema?(schema)
+          # dig through all the coercers
+          non_coercer = schema
+          while non_coercer.is_a?(Schemas::Coercer)
+            non_coercer = non_coercer.subschema
+          end
+
+          non_coercer.is_a?(Schemas::VariableLengthArray)
+        end
       end
+    end
   end
-
-end
-end
 end