rschema 3.1.1 → 3.2.0

data/lib/rschema/coercers/symbol.rb

@@ -1,25 +1,28 @@
-module RSchema
-module Coercers
+# frozen_string_literal: true
 
-  module Symbol
-    extend self
+module RSchema
+  module Coercers
+    #
+    # Coerces `String`s to `Symbol`s
+    #
+    module Symbol
+      extend self
 
-    def build(schema)
-      self
-    end
+      def build(_schema)
+        self
+      end
 
-    def call(value)
-      case value
-      when ::Symbol then Result.success(value)
-      when ::String then Result.success(value.to_sym)
-      else Result.failure
+      def call(value)
+        case value
+        when ::Symbol then Result.success(value)
+        when ::String then Result.success(value.to_sym)
+        else Result.failure
+        end
       end
-    end
 
-    def will_affect?(value)
-      not value.is_a?(Symbol)
+      def will_affect?(value)
+        !value.is_a?(Symbol)
+      end
     end
   end
-
-end
 end

data/lib/rschema/coercers/time.rb

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

data/lib/rschema/coercion_wrapper.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 module RSchema
+  #
+  # Builds coercing schemas, by wrapping coercers around an existing schema.
+  #
   class CoercionWrapper
     def initialize(&initializer)
       @builder_by_schema = {}
@@ -21,36 +26,30 @@ module RSchema
 
     private
 
-      def builder_for_schema(schema)
-        @builder_by_schema.fetch(schema.class) do
-          if schema.is_a?(Schemas::Type)
-            builder_for_type(schema.type)
-          else
-            nil
-          end
-        end
+    def builder_for_schema(schema)
+      @builder_by_schema.fetch(schema.class) do
+        builder_for_type(schema.type) if schema.is_a?(Schemas::Type)
       end
+    end
 
-      def builder_for_type(type)
-        # polymorphic lookup
-        type.ancestors.each do |ancestor|
-          builder = @builder_by_type[ancestor]
-          return builder if builder
-        end
-
-        nil
+    def builder_for_type(type)
+      # polymorphic lookup
+      type.ancestors.each do |ancestor|
+        builder = @builder_by_type[ancestor]
+        return builder if builder
       end
 
-      def wrap_with_coercer(schema)
-        builder = builder_for_schema(schema)
-        if builder
-          coercer = builder.build(schema)
-          Schemas::Coercer.new(coercer, schema)
-        else
-          schema
-        end
-      end
+      nil
+    end
 
+    def wrap_with_coercer(schema)
+      builder = builder_for_schema(schema)
+      if builder
+        coercer = builder.build(schema)
+        Schemas::Coercer.new(coercer, schema)
+      else
+        schema
+      end
+    end
   end
 end
-

data/lib/rschema/coercion_wrapper/rack_params.rb

@@ -1,25 +1,24 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module RSchema
-class CoercionWrapper
-
-  RACK_PARAMS = CoercionWrapper.new do
-    coerce_type Symbol, with: Coercers::Symbol
-    coerce_type Integer, with: Coercers::Integer
-    coerce_type Float, with: Coercers::Float
-    coerce_type Time, with: Coercers::Time
-    coerce_type Date, with: Coercers::Date
+  class CoercionWrapper
+    RACK_PARAMS = CoercionWrapper.new do
+      coerce_type Symbol, with: Coercers::Symbol
+      coerce_type Integer, with: Coercers::Integer
+      coerce_type Float, with: Coercers::Float
+      coerce_type Time, with: Coercers::Time
+      coerce_type Date, with: Coercers::Date
 
-    coerce Schemas::Maybe, with: Coercers::NilEmptyStrings
-    coerce Schemas::Boolean, with: Coercers::Boolean
-    coerce Schemas::FixedHash, with: Coercers::Chain[
-      Coercers::FixedHash::SymbolizeKeys,
-      Coercers::FixedHash::RemoveExtraneousAttributes,
-      Coercers::FixedHash::DefaultBooleansToFalse,
-      Coercers::FixedHash::DefaultArraysToEmpty,
-    ]
+      coerce Schemas::Maybe, with: Coercers::NilEmptyStrings
+      coerce Schemas::Boolean, with: Coercers::Boolean
+      coerce Schemas::FixedHash, with: Coercers::Chain[
+        Coercers::FixedHash::SymbolizeKeys,
+        Coercers::FixedHash::RemoveExtraneousAttributes,
+        Coercers::FixedHash::DefaultBooleansToFalse,
+        Coercers::FixedHash::DefaultArraysToEmpty,
+      ]
+    end
   end
-
 end
-end
-

data/lib/rschema/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSchema
   #
   # A mixin containing all the standard RSchema DSL methods.
@@ -45,15 +47,15 @@ module RSchema
     # Creates a {Schemas::VariableLengthArray} if given one argument, otherwise
     # creates a {Schemas::FixedLengthArray}
     #
-    # @param subschemas [Array<schema>] one or more schema objects representing elements
-    #   in the array.
+    # @param subschemas [Array<schema>] one or more schema objects representing
+    #   elements in the array.
     # @return [Schemas::VariableLengthArray, Schemas::FixedLengthArray]
     #
     # @example (see Schemas::VariableLengthArray)
     # @example (see Schemas::FixedLengthArray)
     #
     def array(*subschemas)
-      subschemas = subschemas.map{ |ss| inconvenience(ss) }
+      subschemas = subschemas.map { |ss| inconvenience(ss) }
 
       if subschemas.count == 1
         Schemas::VariableLengthArray.new(subschemas.first)
@@ -87,7 +89,7 @@ module RSchema
     def fixed_hash(attribute_hash)
       Schemas::FixedHash.new(attributes(attribute_hash))
     end
-    alias_method :hash, :fixed_hash
+    alias hash fixed_hash
 
     #
     # Creates a {Schemas::Set} schema
@@ -143,8 +145,9 @@ module RSchema
     end
 
     #
-    # Turns an "attribute hash" into an array of {Schemas::FixedHash::Attribute}.
-    # Primarily for use with {Schemas::FixedHash#merge}.
+    # Turns an "attribute hash" into an array of
+    # {Schemas::FixedHash::Attribute}. Primarily for use with
+    # {Schemas::FixedHash#merge}.
     #
     # @param attribute_hash [Hash<key, schema>] A hash of keys to subschemas.
     #   The values of this hash must be schema objects.
@@ -161,7 +164,9 @@ module RSchema
       attribute_hash.map do |dsl_key, value_schema|
         optional = dsl_key.is_a?(OptionalWrapper)
         key = optional ? dsl_key.key : dsl_key
-        Schemas::FixedHash::Attribute.new(key, inconvenience(value_schema), optional)
+        Schemas::FixedHash::Attribute.new(
+          key, inconvenience(value_schema), optional,
+        )
       end
     end
 
@@ -190,9 +195,11 @@ module RSchema
     #
     # @example (see Schemas::Enum)
     #
-    def enum(valid_values, subschema=nil)
+    def enum(valid_values, subschema = nil)
       subschema = inconvenience(subschema) if subschema
-      Schemas::Enum.new(valid_values, subschema || type(valid_values.first.class))
+      Schemas::Enum.new(
+        valid_values, subschema || type(valid_values.first.class),
+      )
     end
 
     #
@@ -205,7 +212,7 @@ module RSchema
     # @example (see Schemas::Sum)
     #
     def either(*subschemas)
-      subschemas = subschemas.map{ |ss| inconvenience(ss) }
+      subschemas = subschemas.map { |ss| inconvenience(ss) }
       Schemas::Sum.new(subschemas)
     end
 
@@ -239,7 +246,7 @@ module RSchema
     # @example (see Schemas::Pipeline)
     #
     def pipeline(*subschemas)
-      subschemas = subschemas.map{ |ss| inconvenience(ss) }
+      subschemas = subschemas.map { |ss| inconvenience(ss) }
       Schemas::Pipeline.new(subschemas)
     end
 
@@ -331,9 +338,9 @@ module RSchema
     end
 
     # @!visibility private
-    def respond_to?(sym, include_all=false)
+    def respond_to_missing?(sym, include_all = false)
       # check if method starts with an underscore followed by a capital
-      super || !!sym.to_s.match(/\A_[A-Z]/)
+      super || sym.to_s.match(/\A_[A-Z]/)
     end
   end
 end

data/lib/rschema/error.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 module RSchema
+  #
+  # Contains info about how a schema failed validation
+  #
   class Error
     attr_reader :schema, :value, :symbolic_name, :vars
 
     def initialize(schema:, value:, symbolic_name:, vars: {})
-      raise ArgumentError.new("vars must be a hash") unless vars.is_a?(Hash)
+      raise ArgumentError.new('vars must be a hash') unless vars.is_a?(Hash)
 
       @schema = schema
       @value = value
@@ -19,10 +24,10 @@ module RSchema
 
     def inspect
       attrs = vars.merge(value: value)
-        .map{ |k, v| "#{k}=#{v.inspect}" }
-        .join(' ')
+                  .map { |k, v| "#{k}=#{v.inspect}" }
+                  .join(' ')
 
-      "<#{self.class} #{to_s} #{attrs}>"
+      "<#{self.class} #{self} #{attrs}>"
     end
   end
 end

data/lib/rschema/options.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 module RSchema
+  #
+  # Settings, passed in as an argument when calling schemas
+  #
   class Options
     def self.default
       @default ||= new

data/lib/rschema/rails.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'rschema'
+require 'rschema/coercion_wrapper/rack_params'
+
+module RSchema
+  module Rails
+    #
+    # A mixin for ActionController that provides methods for validating params.
+    #
+    module Controller
+      def self.included(klass)
+        klass.include(InstanceMethods)
+        klass.extend(ClassMethods)
+      end
+
+      #
+      # Instance methods added to ActionController classes
+      #
+      module InstanceMethods
+        def param_schema(&schema_block)
+          self.class.param_schema(&schema_block)
+        end
+
+        def validate_params(schema = nil, &schema_block)
+          schema ||= param_schema(&schema_block)
+          schema.validate(request.parameters.to_hash)
+        end
+
+        def validate_params!(*args, &block)
+          result = validate_params(*args, &block)
+          raise InvalidParams.new(result.error) if result.invalid?
+          result.value
+        end
+      end
+
+      #
+      # Class methods added to ActionController classes
+      #
+      module ClassMethods
+        def param_schema(&schema_block)
+          schema = RSchema.define_hash(&schema_block)
+          RSchema::CoercionWrapper::RACK_PARAMS.wrap(schema)
+        end
+      end
+    end
+
+    #
+    # Raised when {validate_params!} fails
+    #
+    class InvalidParams < StandardError
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+        super('Parameters do not conform to schema')
+      end
+    end
+  end
+end

data/lib/rschema/result.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 module RSchema
+  #
+  # The return value when calling a schema
+  #
   class Result
     def self.success(value = nil)
       if value.nil?
@@ -28,22 +33,15 @@ module RSchema
     end
 
     def invalid?
-      not valid?
+      !valid?
     end
 
     def value
-      if valid?
-        @value
-      else
-        raise InvalidError
-      end
-    end
-
-    def error
-      @error
+      raise RSchema::Invalid.new(error) if invalid?
+      @value
     end
 
-    class InvalidError < StandardError; end
+    attr_reader :error
 
     # @!visibility private
     NIL_SUCCESS = new(true, nil, nil)