rschema 3.1.1 → 3.2.0

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

@@ -1,74 +1,75 @@
+# 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 `false`.
+      class DefaultBooleansToFalse
+        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 `false`.
-  class DefaultBooleansToFalse
-    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_bools_to_false(value))
+        end
 
-    def call(value)
-      Result.success(default_bools_to_false(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_bools_to_false(hash)
-        missing_keys = keys_to_default(hash)
+        def default_bools_to_false(hash)
+          missing_keys = keys_to_default(hash)
 
-        if missing_keys.any?
-          defaults = missing_keys.map{ |k| [k, false] }.to_h
-          hash.merge(defaults)
-        else
-          hash # no coercion necessary
+          if missing_keys.any?
+            defaults = missing_keys.map { |k| [k, false] }.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_bool_defaulting - value.keys
-        else
-          []
+        def keys_to_default(value)
+          if value.is_a?(Hash)
+            keys_for_bool_defaulting - value.keys
+          else
+            []
+          end
         end
-      end
-
-      def keys_for_bool_defaulting
-        @keys_for_bool_defaulting ||= Set.new(
-          hash_attributes
-            .reject(&:optional)
-            .select { |attr| is_bool_schema?(attr.value_schema) }
-            .map(&:key)
-        )
-      end
 
-      def is_bool_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_bool_defaulting
+          @keys_for_bool_defaulting ||= Set.new(
+            hash_attributes
+              .reject(&:optional)
+              .select { |attr| bool_schema?(attr.value_schema) }
+              .map(&:key),
+          )
         end
 
-        non_coercer.is_a?(Schemas::Boolean)
+        def bool_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::Boolean)
+        end
       end
+    end
   end
-
-end
-end
 end

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

@@ -1,54 +1,58 @@
-module RSchema
-module Coercers
-module FixedHash
-
-  class RemoveExtraneousAttributes
-    attr_reader :hash_attributes
+# frozen_string_literal: true
 
-    def self.build(schema)
-      new(schema)
-    end
+module RSchema
+  module Coercers
+    module FixedHash
+      #
+      # Removes elements from `Hash` values that are not defined in the given
+      # `FixedHash` schema.
+      #
+      class RemoveExtraneousAttributes
+        attr_reader :hash_attributes
+
+        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(remove_extraneous_elements(value))
-    end
+        def call(value)
+          Result.success(remove_extraneous_elements(value))
+        end
 
-    def will_affect?(value)
-      keys_to_remove(value).any?
-    end
+        def will_affect?(value)
+          keys_to_remove(value).any?
+        end
 
-    private
+        private
 
-      def remove_extraneous_elements(hash)
-        extra_keys = keys_to_remove(hash)
+        def remove_extraneous_elements(hash)
+          extra_keys = keys_to_remove(hash)
 
-        if extra_keys.any?
-          hash.dup.tap do |stripped_hash|
-            extra_keys.each { |k| stripped_hash.delete(k) }
+          if extra_keys.any?
+            hash.dup.tap do |stripped_hash|
+              extra_keys.each { |k| stripped_hash.delete(k) }
+            end
+          else
+            hash
           end
-        else
-          hash
         end
-      end
 
-      def keys_to_remove(value)
-        if value.is_a?(Hash)
-          value.keys - valid_keys
-        else
-          []
+        def keys_to_remove(value)
+          if value.is_a?(Hash)
+            value.keys - valid_keys
+          else
+            []
+          end
         end
-      end
 
-      def valid_keys
-        @valid_keys ||= hash_attributes.map(&:key)
+        def valid_keys
+          @valid_keys ||= hash_attributes.map(&:key)
+        end
       end
+    end
   end
-
-end
-end
 end

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

@@ -1,70 +1,74 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module RSchema
-module Coercers
-module FixedHash
-
-  class SymbolizeKeys
-    attr_reader :hash_attributes
+  module Coercers
+    module FixedHash
+      #
+      # Coerces `String` keys into `Symbol`s according to the attributes in
+      # a given `FixedHash` schema.
+      #
+      class SymbolizeKeys
+        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(symbolize_keys(value))
-    end
+        def call(value)
+          Result.success(symbolize_keys(value))
+        end
 
-    def will_affect?(value)
-      keys_to_symbolize(hash).any?
-    end
+        def will_affect?(_value)
+          keys_to_symbolize(hash).any?
+        end
 
-    private
+        private
 
-      def symbolize_keys(hash)
-        keys = keys_to_symbolize(hash)
-        if keys.any?
-          hash.dup.tap do |new_hash|
-            keys.each { |k| new_hash[k.to_sym] = new_hash.delete(k) }
+        def symbolize_keys(hash)
+          keys = keys_to_symbolize(hash)
+          if keys.any?
+            hash.dup.tap do |new_hash|
+              keys.each { |k| new_hash[k.to_sym] = new_hash.delete(k) }
+            end
+          else
+            hash
           end
-        else
-          hash
         end
-      end
 
-      def keys_to_symbolize(value)
-        if value.is_a?(Hash)
-          non_string_keys = Set.new(value.keys) - string_keys
-          non_string_keys.intersection(symbol_keys_as_strings)
-        else
-          []
+        def keys_to_symbolize(value)
+          if value.is_a?(Hash)
+            non_string_keys = Set.new(value.keys) - string_keys
+            non_string_keys.intersection(symbol_keys_as_strings)
+          else
+            []
+          end
         end
-      end
 
-      def symbol_keys_as_strings
-        @symbol_keys_as_strings ||= Set.new(
-          all_keys
-            .select{ |k| k.is_a?(::Symbol) }
-            .map(&:to_s)
-        )
-      end
+        def symbol_keys_as_strings
+          @symbol_keys_as_strings ||= Set.new(
+            all_keys
+              .select { |k| k.is_a?(::Symbol) }
+              .map(&:to_s),
+          )
+        end
 
-      def string_keys
-        @string_keys ||= Set.new(
-          all_keys.select { |k| k.is_a?(::String) }
-        )
-      end
+        def string_keys
+          @string_keys ||= Set.new(
+            all_keys.select { |k| k.is_a?(::String) },
+          )
+        end
 
-      def all_keys
-        @all_keys ||= hash_attributes.map(&:key)
+        def all_keys
+          @all_keys ||= hash_attributes.map(&:key)
+        end
       end
+    end
   end
-
-end
-end
 end

data/lib/rschema/coercers/float.rb

@@ -1,22 +1,29 @@
-module RSchema
-module Coercers
+# frozen_string_literal: true
 
-  module Float
-    extend self
+module RSchema
+  module Coercers
+    #
+    # Coerces values into `Float` objects using `Kernel#Float`
+    #
+    module Float
+      extend self
 
-    def build(schema)
-      self
-    end
+      def build(_schema)
+        self
+      end
 
-    def call(value)
-      flt = Float(value) rescue nil
-      flt ? Result.success(flt) : Result.failure
-    end
+      def call(value)
+        flt = begin
+                Float(value)
+              rescue
+                nil
+              end
+        flt ? Result.success(flt) : Result.failure
+      end
 
-    def will_affect?(value)
-      not value.is_a?(Float)
+      def will_affect?(value)
+        !value.is_a?(Float)
+      end
     end
   end
-
-end
 end

data/lib/rschema/coercers/integer.rb

@@ -1,22 +1,28 @@
-module RSchema
-module Coercers
+# frozen_string_literal: true
 
-  module Integer
-    extend self
+module RSchema
+  module Coercers
+    #
+    # Coerces values to `Integer`s using `Kernel#Integer`
+    module Integer
+      extend self
 
-    def build(schema)
-      self
-    end
+      def build(_schema)
+        self
+      end
 
-    def call(value)
-      int = Integer(value) rescue nil
-      int ? Result.success(int) : Result.failure
-    end
+      def call(value)
+        int = begin
+                Integer(value)
+              rescue
+                nil
+              end
+        int ? Result.success(int) : Result.failure
+      end
 
-    def will_affect?(value)
-      not value.is_a?(Integer)
+      def will_affect?(value)
+        !value.is_a?(Integer)
+      end
     end
   end
-
-end
 end

data/lib/rschema/coercers/nil_empty_strings.rb

@@ -1,25 +1,28 @@
-module RSchema
-module Coercers
+# frozen_string_literal: true
 
-  module NilEmptyStrings
-    extend self
+module RSchema
+  module Coercers
+    #
+    # Coerces empty strings to `nil`
+    #
+    module NilEmptyStrings
+      extend self
 
-    def build(schema)
-      self
-    end
+      def build(_schema)
+        self
+      end
 
-    def call(value)
-      if "" == value
-        Result.success(nil)
-      else
-        Result.success(value)
+      def call(value)
+        if value == ''
+          Result.success(nil)
+        else
+          Result.success(value)
+        end
       end
-    end
 
-    def will_affect?(value)
-      "" == value
+      def will_affect?(value)
+        value == ''
+      end
     end
   end
-
-end
 end