hanami-ruby3 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aaa6b22733000fa1ba8e1e678fad8a21f3efa1a8c03a0860f8ce49aceb57b0b
-  data.tar.gz: 3068aeb3c3448d1b547d1637a2818839813deaaf5ef6d50c698bd4170c436c76
+  metadata.gz: 49e5e9e5b246dd74297750a1be4a0dff8f27f5bfd0cdac95dbeb3bbda1815c21
+  data.tar.gz: a36ed7e9847c8395e14a45d5a8214f9f0b890eeb261e88538f4d65077a94b86e
 SHA512:
-  metadata.gz: 526813c24d0db9a2e2b3d4d1283d2cf3980a6b4b15169a31b63736b6795148794fd48e73d8527e722145c45eba8d12a2b0d966b57087b08b6f6fb1eca636444a
-  data.tar.gz: 460a0b14e02b2301bb2ed4b9cbad698c1b7de49220d562082b8bd7454721ebd8f85703008e444ebbcfee4795a7df4d8397225f52a0feef441365a21d6f601651
+  metadata.gz: a22e0224fcd2d30defc87d8ff415aef7c6b7a8968354e139722f285019d5bfcf9948121e40ff2d615e27e07d20d8e536622b8306bb031eb3ebfe6f7657c566d3
+  data.tar.gz: 73264f585ebdac7972fd32c0fa7458b269650e715ae94a06035240ba443836088b0b6f08cb737aadfbb681cd5bc0c8220d5bc5c1978f337daa510ba64e1ea6c4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hanami-ruby3 (0.0.3)
+    hanami-ruby3 (0.1.0)
       hanami (~> 1.3.4)
 
 GEM

data/README.md

@@ -1,6 +1,8 @@
 # Hanami Ruby 3.0
 
-Monkey patches Hanami components to support Ruby 3.0
+Monkey patches Hanami components to support Ruby 3.0. This includes
+1. Copying Hanami 1.3.X files to support Ruby 3 syntax.
+2. Copying Hanami 1.3.X files and getting rid of deprecated DRY libraries to allow upgrade of those gems.
 
 ## Overview
 
@@ -23,6 +25,12 @@ In your project, install overrides for the given classes
 ```ruby
 # custom-hanami-utils is required to allow installing Hanami 1.3.5 with ruby 3
 gem 'hanami-utils', github: 'swilgosz/hanami-utils', branch: '1.3.x-support-ruby-3.0'
+
+# Deprecated DRY libraries are renamed to RDY - we install those so we can update our DRY libraries freely.
+%w[core container configurable equalizer monads logic types struct validation].each do |name|
+  gem "rdy-#{name}", ascenda_private: "Kaligo/rdy", glob: "lib/rdy/#{name}/rdy-#{name}.gemspec"
+end
+
 gem 'hanami-ruby3'
 ```
 

data/lib/hanami/hanami-ruby3.rb

@@ -1 +1,3 @@
 require_relative "./hanami/ruby3"
+
+require_relative "./hanami/v1"

data/lib/hanami/ruby3/version.rb

@@ -2,6 +2,6 @@
 
 module Hanami
   module Ruby3
-    VERSION = "0.0.3"
+    VERSION = "0.1.0"
   end
 end

data/lib/hanami/ruby3.rb

@@ -2,7 +2,10 @@ require_relative "./ruby3/version"
 
 require "hanami"
 
-Dir["#{__dir__}/ruby3/hanami/**/*.rb"].each do |f|
+Dir[
+  "#{__dir__}/ruby3/hanami/**/*.rb",
+  "#{__dir__}/v1/**/*.rb"
+].each do |f|
   require_relative f
 end
 

data/lib/hanami/v1/README.md

@@ -0,0 +1,11 @@
+## Collection of overwritten Hanami 1.3.5 files
+
+Ruby 3 folder contains Hanami 1.3.5 files tweaked to support Ruby 3 syntax.
+This is different in the sense that we need to keep some Hanami 1.3 files in parallel
+of updated versions of them.
+
+We have renamed old DRY -> `RDY` and stored in `Kaligo/rdy` repository, so we can install newer versions of those libs in parallel. In order to do so, we need to kopy some of the Hanami files that depend on deprecated DRY gems and change them to use `RDY`
+
+### Examples
+
+- Hanami::Action::Params uses hanami-validations which uses old Dry-Validations with all the old dry-gems preventing us from gradual update. These files are updated to use RDY instead.

data/lib/hanami/v1/action/base_params.rb

@@ -0,0 +1,186 @@
+require 'rack/request'
+require 'hanami/utils/hash'
+
+module Hanami
+  module V1
+    module Action
+      class BaseParams
+        # The key that returns raw input from the Rack env
+        #
+        # @since 0.7.0
+        # @api private
+        RACK_INPUT    = 'rack.input'.freeze
+
+        # The key that returns router params from the Rack env
+        # This is a builtin integration for Hanami::Router
+        #
+        # @since 0.7.0
+        # @api private
+        ROUTER_PARAMS = 'router.params'.freeze
+
+        # The key that returns Rack session params from the Rack env
+        # Please note that this is used only when an action is unit tested.
+        #
+        # @since 1.0.0
+        # @api private
+        #
+        # @example
+        #   # action unit test
+        #   action.call('rack.session' => { 'foo' => 'bar' })
+        #   action.session[:foo] # => "bar"
+        RACK_SESSION = 'rack.session'.freeze
+
+        # HTTP request method for Rack env
+        #
+        # @since 1.1.1
+        # @api private
+        REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+
+        # Default HTTP request method for Rack env
+        #
+        # @since 1.1.1
+        # @api private
+        DEFAULT_REQUEST_METHOD = 'GET'.freeze
+
+        # @attr_reader env [Hash] the Rack env
+        #
+        # @since 0.7.0
+        # @api private
+        attr_reader :env
+
+        # @attr_reader raw [Hash] the raw params from the request
+        #
+        # @since 0.7.0
+        # @api private
+        attr_reader :raw
+
+        # Initialize the params and freeze them.
+        #
+        # @param env [Hash] a Rack env or an hash of params.
+        #
+        # @return [Params]
+        #
+        # @since 0.7.0
+        # @api private
+        def initialize(env)
+          @env    = env
+          @raw    = _extract_params
+          @params = Hanami::Utils::Hash.deep_symbolize(@raw)
+          freeze
+        end
+
+        # Returns the object associated with the given key
+        #
+        # @param key [Symbol] the key
+        #
+        # @return [Object,nil] return the associated object, if found
+        #
+        # @since 0.7.0
+        def [](key)
+          @params[key]
+        end
+
+        # Get an attribute value associated with the given key.
+        # Nested attributes are reached by listing all the keys to get to the value.
+        #
+        # @param keys [Array<Symbol,Integer>] the key
+        #
+        # @return [Object,NilClass] return the associated value, if found
+        #
+        # @since 0.7.0
+        #
+        # @example
+        #   require 'hanami/controller'
+        #
+        #   module Deliveries
+        #     class Create
+        #       include Hanami::Action
+        #
+        #       def call(params)
+        #         params.get(:customer_name)     # => "Luca"
+        #         params.get(:uknown)            # => nil
+        #
+        #         params.get(:address, :city)    # => "Rome"
+        #         params.get(:address, :unknown) # => nil
+        #
+        #         params.get(:tags, 0)           # => "foo"
+        #         params.get(:tags, 1)           # => "bar"
+        #         params.get(:tags, 999)         # => nil
+        #
+        #         params.get(nil)                # => nil
+        #       end
+        #     end
+        #   end
+        def get(*keys)
+          @params.dig(*keys)
+        end
+
+        # This is for compatibility with Hanami::Helpers::FormHelper::Values
+        #
+        # @api private
+        # @since 0.8.0
+        alias dig get
+
+        # Provide a common interface with Params
+        #
+        # @return [TrueClass] always returns true
+        #
+        # @since 0.7.0
+        #
+        # @see Hanami::Action::Params#valid?
+        def valid?
+          true
+        end
+
+        # Serialize params to Hash
+        #
+        # @return [::Hash]
+        #
+        # @since 0.7.0
+        def to_h
+          @params
+        end
+        alias_method :to_hash, :to_h
+
+        # Iterates through params
+        #
+        # @param blk [Proc]
+        #
+        # @since 0.7.1
+        def each(&blk)
+          to_h.each(&blk)
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        def _extract_params
+          result = {}
+
+          if env.key?(RACK_INPUT)
+            result.merge! ::Rack::Request.new(env).params
+            result.merge! _router_params
+          else
+            result.merge! _router_params(env)
+            env[REQUEST_METHOD] ||= DEFAULT_REQUEST_METHOD
+          end
+
+          result
+        end
+
+        # @since 0.7.0
+        # @api private
+        def _router_params(fallback = {})
+          env.fetch(ROUTER_PARAMS) do
+            if session = fallback.delete(RACK_SESSION) # rubocop:disable Lint/AssignmentInCondition
+              fallback[RACK_SESSION] = Hanami::Utils::Hash.new(session).symbolize!.to_hash
+            end
+
+            fallback
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/action/params.rb

@@ -0,0 +1,248 @@
+require_relative './base_params'
+require_relative '../validations/form'
+
+module Hanami
+  module V1
+    module Action
+      # A set of params requested by the client
+      #
+      # It's able to extract the relevant params from a Rack env of from an Hash.
+      #
+      # There are three scenarios:
+      #   * When used with Hanami::Router: it contains only the params from the request
+      #   * When used standalone: it contains all the Rack env
+      #   * Default: it returns the given hash as it is. It's useful for testing purposes.
+      #
+      # @since 0.1.0
+      class Params < BaseParams
+        include Hanami::V1::Validations::Form
+
+        # Params errors
+        #
+        # @since 1.1.0
+        class Errors < SimpleDelegator
+          # @since 1.1.0
+          # @api private
+          def initialize(errors = {})
+            super(errors)
+          end
+
+          # Add an error to the param validations
+          #
+          # This has a semantic similar to `Hash#dig` where you use a set of keys
+          # to get a nested value, here you use a set of keys to set a nested
+          # value.
+          #
+          # @param args [Array<Symbol, String>] an array of arguments: the last
+          #   one is the message to add (String), while the beginning of the array
+          #   is made of keys to reach the attribute.
+          #
+          # @raise [ArgumentError] when try to add a message for a key that is
+          #   already filled with incompatible message type.
+          #   This usually happens with nested attributes: if you have a `:book`
+          #   schema and the input doesn't include data for `:book`, the messages
+          #   will be `["is missing"]`. In that case you can't add an error for a
+          #   key nested under `:book`.
+          #
+          # @since 1.1.0
+          #
+          # @example Basic usage
+          #   require "hanami/controller"
+          #
+          #   class MyAction
+          #     include Hanami::Action
+          #
+          #     params do
+          #       required(:book).schema do
+          #         required(:isbn).filled(:str?)
+          #       end
+          #     end
+          #
+          #     def call(params)
+          #       # 1. Don't try to save the record if the params aren't valid
+          #       return unless params.valid?
+          #
+          #       BookRepository.new.create(params[:book])
+          #     rescue Hanami::Model::UniqueConstraintViolationError
+          #       # 2. Add an error in case the record wasn't unique
+          #       params.errors.add(:book, :isbn, "is not unique")
+          #     end
+          #   end
+          #
+          # @example Invalid argument
+          #   require "hanami/controller"
+          #
+          #   class MyAction
+          #     include Hanami::Action
+          #
+          #     params do
+          #       required(:book).schema do
+          #         required(:title).filled(:str?)
+          #       end
+          #     end
+          #
+          #     def call(params)
+          #       puts params.to_h   # => {}
+          #       puts params.valid? # => false
+          #       puts params.error_messages # => ["Book is missing"]
+          #       puts params.errors         # => {:book=>["is missing"]}
+          #
+          #       params.errors.add(:book, :isbn, "is not unique") # => ArgumentError
+          #     end
+          #   end
+          def add(*args)
+            *keys, key, error = args
+            _nested_attribute(keys, key) << error
+          rescue TypeError
+            raise ArgumentError.new("Can't add #{args.map(&:inspect).join(', ')} to #{inspect}")
+          end
+
+          private
+
+          # @since 1.1.0
+          # @api private
+          def _nested_attribute(keys, key)
+            if keys.empty?
+              self
+            else
+              keys.inject(self) { |result, k| result[k] ||= {} }
+              dig(*keys)
+            end[key] ||= []
+          end
+        end
+
+        # This is a Hanami::Validations extension point
+        #
+        # @since 0.7.0
+        # @api private
+        def self._base_rules
+          lambda do
+            optional(:_csrf_token).filled(:str?)
+          end
+        end
+
+        # Define params validations
+        #
+        # @param blk [Proc] the validations definitions
+        #
+        # @since 0.7.0
+        #
+        # @see https://guides.hanamirb.org/validations/overview
+        #
+        # @example
+        #   class Signup
+        #     MEGABYTE = 1024 ** 2
+        #     include Hanami::Action
+        #
+        #     params do
+        #       required(:first_name).filled(:str?)
+        #       required(:last_name).filled(:str?)
+        #       required(:email).filled?(:str?, format?: /\A.+@.+\z/)
+        #       required(:password).filled(:str?).confirmation
+        #       required(:terms_of_service).filled(:bool?)
+        #       required(:age).filled(:int?, included_in?: 18..99)
+        #       optional(:avatar).filled(size?: 1..(MEGABYTE * 3))
+        #     end
+        #
+        #     def call(params)
+        #       halt 400 unless params.valid?
+        #       # ...
+        #     end
+        #   end
+        def self.params(&blk)
+          validations(&blk || ->() {})
+        end
+
+        # Initialize the params and freeze them.
+        #
+        # @param env [Hash] a Rack env or an hash of params.
+        #
+        # @return [Params]
+        #
+        # @since 0.1.0
+        # @api private
+        def initialize(env)
+          @env = env
+          super(_extract_params)
+          @result = validate
+          @params = _params
+          @errors = Errors.new(@result.messages)
+          freeze
+        end
+
+        # Returns raw params from Rack env
+        #
+        # @return [Hash]
+        #
+        # @since 0.3.2
+        def raw
+          @input
+        end
+
+        # Returns structured error messages
+        #
+        # @return [Hash]
+        #
+        # @since 0.7.0
+        #
+        # @example
+        #   params.errors
+        #     # => {:email=>["is missing", "is in invalid format"], :name=>["is missing"], :tos=>["is missing"], :age=>["is missing"], :address=>["is missing"]}
+        attr_reader :errors
+
+        # Returns flat collection of full error messages
+        #
+        # @return [Array]
+        #
+        # @since 0.7.0
+        #
+        # @example
+        #   params.error_messages
+        #     # => ["Email is missing", "Email is in invalid format", "Name is missing", "Tos is missing", "Age is missing", "Address is missing"]
+        def error_messages(error_set = errors)
+          error_set.each_with_object([]) do |(key, messages), result|
+            k = Utils::String.titleize(key)
+
+            _messages = if messages.is_a?(Hash)
+              error_messages(messages)
+            else
+              messages.map { |message| "#{k} #{message}" }
+            end
+
+            result.concat(_messages)
+          end
+        end
+
+        # Returns true if no validation errors are found,
+        # false otherwise.
+        #
+        # @return [TrueClass, FalseClass]
+        #
+        # @since 0.7.0
+        #
+        # @example
+        #   params.valid? # => true
+        def valid?
+          errors.empty?
+        end
+
+        # Serialize params to Hash
+        #
+        # @return [::Hash]
+        #
+        # @since 0.3.0
+        def to_h
+          @params
+        end
+        alias_method :to_hash, :to_h
+
+        private
+
+        # @api private
+        def _params
+          _router_params.merge(@result.output)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/validations/form.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../validations"
+
+module Hanami
+  module V1
+    module Validations
+      # Validations mixin for forms/HTTP params.
+      #
+      # This must be used when the input comes from a browser or an HTTP endpoint.
+      # It knows how to deal with common data types, and common edge cases like blank strings.
+      #
+      # @since 0.6.0
+      #
+      # @example
+      #   require 'hanami/validations/form'
+      #
+      #   class Signup
+      #     include Hanami::Validations::Form
+      #
+      #     validations do
+      #       required(:name).filled(:str?)
+      #       optional(:location).filled(:str?)
+      #     end
+      #   end
+      #
+      #   result = Signup.new('location' => 'Rome').validate
+      #   result.success? # => false
+      #
+      #   result = Signup.new('name' => 'Luca').validate
+      #   result.success? # => true
+      #
+      #   # it works with symbol keys too
+      #   result = Signup.new(location: 'Rome').validate
+      #   result.success? # => false
+      #
+      #   result = Signup.new(name: 'Luca').validate
+      #   result.success? # => true
+      #
+      #   result = Signup.new(name: 'Luca', location: 'Rome').validate
+      #   result.success? # => true
+      module Form
+        # Override Ruby's hook for modules.
+        #
+        # @param base [Class] the target action
+        #
+        # @since 0.6.0
+        # @api private
+        #
+        # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+        def self.included(base)
+          base.class_eval do
+            include Hanami::V1::Validations
+            extend  ClassMethods
+          end
+        end
+
+        # @since 0.6.0
+        # @api private
+        module ClassMethods
+          private
+
+          # @since 0.6.0
+          # @api private
+          def _schema_type
+            :Form
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/validations/inline_predicate.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  module V1
+    module Validations
+      # Inline predicate
+      #
+      # @since 0.6.0
+      # @api private
+      class InlinePredicate
+        # @since 0.6.0
+        # @api private
+        attr_reader :name
+
+        # @since 0.6.0
+        # @api private
+        attr_reader :message
+
+        # Return a new instance.
+        #
+        # @param name [Symbol] inline predicate name
+        # @param message [String] optional failure message
+        # @param blk [Proc] predicate implementation
+        #
+        # @return [Hanami::Validations::InlinePredicate] a new instance
+        #
+        # @since 0.6.0
+        # @api private
+        def initialize(name, message, &blk)
+          @name    = name
+          @message = message
+          @blk     = blk
+        end
+
+        # @since 0.6.0
+        # @api private
+        def to_proc
+          @blk
+        end
+
+        # @since 0.6.0
+        # @api private
+        def ==(other)
+          self.class == other.class &&
+            name == other.name
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/validations/namespace.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "hanami/utils/string"
+
+module Hanami
+  module V1
+    module Validations
+      # Validations message namespace.
+      #
+      # For a given `FooValidator` class, it will look for I18n messages within
+      # the `foo` group.
+      #
+      # @since 0.6.0
+      # @api private
+      class Namespace
+        # @since 0.6.0
+        # @api private
+        SUFFIX = "Validator"
+
+        # @since 0.6.0
+        # @api private
+        SUFFIX_REPLACEMENT = ""
+
+        # @since 0.6.0
+        # @api private
+        RUBY_NAMESPACE_SEPARATOR = "/"
+
+        # @since 0.6.0
+        # @api private
+        RUBY_NAMESPACE_REPLACEMENT = "."
+
+        # @since 0.6.0
+        # @api private
+        def self.new(name, klass)
+          result = name || klass.name
+          return nil if result.nil?
+
+          super(result)
+        end
+
+        # @since 0.6.0
+        # @api private
+        def initialize(name)
+          @name = name
+        end
+
+        # @since 0.6.0
+        # @api private
+        def to_s
+          underscored_name.gsub(RUBY_NAMESPACE_SEPARATOR, RUBY_NAMESPACE_REPLACEMENT)
+        end
+
+        private
+
+        # @since 0.6.0
+        # @api private
+        def underscored_name
+          Hanami::Utils::String.underscore(name_without_suffix)
+        end
+
+        # @since 0.6.0
+        # @api private
+        def name_without_suffix
+          @name.sub(SUFFIX, SUFFIX_REPLACEMENT)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/validations/predicates.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rdy/logic/predicates"
+require "hanami/utils/class_attribute"
+
+module Hanami
+  module Validations
+    # Mixin to include when defining shared predicates
+    #
+    # @since 0.6.0
+    #
+    # @see Hanami::Validations::ClassMethods#predicates
+    #
+    # @example Inline Predicate
+    #   require 'hanami/validations'
+    #
+    #   module MySharedPredicates
+    #     include Hanami::Validations::Predicates
+    #
+    #     predicate :foo? do |actual|
+    #       actual == 'foo'
+    #     end
+    #   end
+    #
+    #   class MyValidator
+    #     include Hanami::Validations
+    #     predicates MySharedPredicates
+    #
+    #     validations do
+    #       required(:name).filled(:foo?)
+    #     end
+    #   end
+    module Predicates
+      # @since 0.6.0
+      # @api private
+      def self.included(base)
+        base.class_eval do
+          include Rdy::Logic::Predicates
+          include Hanami::Utils::ClassAttribute
+
+          class_attribute :messages
+          class_attribute :messages_path
+        end
+      end
+    end
+  end
+end

data/lib/hanami/v1/validations.rb

@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+require "rdy-validation"
+require "hanami/utils/class_attribute"
+require_relative "./validations/namespace"
+require_relative "./validations/predicates"
+require_relative "./validations/inline_predicate"
+require "set"
+
+Rdy::Validation::Messages::Namespaced.configure do |config|
+  # rubocop:disable Lint/NestedPercentLiteral
+  #
+  # This is probably a false positive.
+  # See: https://github.com/bbatsov/rubocop/issues/5314
+  config.lookup_paths = config.lookup_paths + %w[
+    %<root>s.%<rule>s.%<predicate>s
+  ].freeze
+  # rubocop:enable Lint/NestedPercentLiteral
+end
+
+# @since 0.1.0
+module Hanami
+  module V1
+    # Hanami::Validations is a set of lightweight validations for Ruby objects.
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require 'hanami/validations'
+    #
+    #   class Signup
+    #     include Hanami::Validations
+    #
+    #     validations do
+    #       # ...
+    #     end
+    #   end
+    module Validations
+      # @since 0.6.0
+      # @api private
+      DEFAULT_MESSAGES_ENGINE = :yaml
+
+      # Override Ruby's hook for modules.
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+
+          include Hanami::Utils::ClassAttribute
+          class_attribute :schema
+          class_attribute :_messages
+          class_attribute :_messages_path
+          class_attribute :_namespace
+          class_attribute :_predicates_module
+
+          class_attribute :_predicates
+          self._predicates = Set.new
+        end
+      end
+
+      # Validations DSL
+      #
+      # @since 0.1.0
+      module ClassMethods
+        # Define validation rules from the given block.
+        #
+        # @param blk [Proc] validation rules
+        #
+        # @since 0.6.0
+        #
+        # @see https://guides.hanamirb.org/validations/overview
+        #
+        # @example Basic Example
+        #   require 'hanami/validations'
+        #
+        #   class Signup
+        #     include Hanami::Validations
+        #
+        #     validations do
+        #       required(:name).filled
+        #     end
+        #   end
+        #
+        #   result = Signup.new(name: "Luca").validate
+        #
+        #   result.success? # => true
+        #   result.messages # => []
+        #   result.output   # => {:name=>""}
+        #
+        #   result = Signup.new(name: "").validate
+        #
+        #   result.success? # => false
+        #   result.messages # => {:name=>["must be filled"]}
+        #   result.output   # => {:name=>""}
+        def validations(&blk)
+          schema_predicates = __predicates
+
+          base   = _build(predicates: schema_predicates, &_base_rules)
+          schema = _build(predicates: schema_predicates, rules: base.rules, &blk)
+          schema.configure(&_schema_config)
+          schema.configure(&_schema_predicates)
+          schema.extend(__messages) unless _predicates.empty?
+
+          self.schema = schema.new
+        end
+
+        # Define an inline predicate
+        #
+        # @param name [Symbol] inline predicate name
+        # @param message [String] optional error message
+        # @param blk [Proc] predicate implementation
+        #
+        # @return nil
+        #
+        # @since 0.6.0
+        #
+        # @example Without Custom Message
+        #   require 'hanami/validations'
+        #
+        #   class Signup
+        #     include Hanami::Validations
+        #
+        #     predicate :foo? do |actual|
+        #       actual == 'foo'
+        #     end
+        #
+        #     validations do
+        #       required(:name).filled(:foo?)
+        #     end
+        #   end
+        #
+        #   result = Signup.new(name: nil).call
+        #   result.messages # => { :name => ['is invalid'] }
+        #
+        # @example With Custom Message
+        #   require 'hanami/validations'
+        #
+        #   class Signup
+        #     include Hanami::Validations
+        #
+        #     predicate :foo?, message: 'must be foo' do |actual|
+        #       actual == 'foo'
+        #     end
+        #
+        #     validations do
+        #       required(:name).filled(:foo?)
+        #     end
+        #   end
+        #
+        #   result = Signup.new(name: nil).call
+        #   result.messages # => { :name => ['must be foo'] }
+        def predicate(name, message: "is invalid", &blk)
+          _predicates << InlinePredicate.new(name, message, &blk)
+        end
+
+        # Assign a set of shared predicates wrapped in a module
+        #
+        # @param mod [Module] a module with shared predicates
+        #
+        # @since 0.6.0
+        #
+        # @see Hanami::Validations::Predicates
+        #
+        # @example
+        #   require 'hanami/validations'
+        #
+        #   module MySharedPredicates
+        #     include Hanami::Validations::Predicates
+        #
+        #     predicate :foo? fo |actual|
+        #       actual == 'foo'
+        #     end
+        #   end
+        #
+        #   class MyValidator
+        #     include Hanami::Validations
+        #     predicates MySharedPredicates
+        #
+        #     validations do
+        #       required(:name).filled(:foo?)
+        #     end
+        #   end
+        def predicates(mod)
+          self._predicates_module = mod
+        end
+
+        # Define the type of engine for error messages.
+        #
+        # Accepted values are `:yaml` (default), `:i18n`.
+        #
+        # @param type [Symbol] the preferred engine
+        #
+        # @since 0.6.0
+        #
+        # @example
+        #   require 'hanami/validations'
+        #
+        #   class Signup
+        #     include Hanami::Validations
+        #
+        #     messages :i18n
+        #   end
+        def messages(type)
+          self._messages = type
+        end
+
+        # Define the path where to find translation file
+        #
+        # @param path [String] path to translation file
+        #
+        # @since 0.6.0
+        #
+        # @example
+        #   require 'hanami/validations'
+        #
+        #   class Signup
+        #     include Hanami::Validations
+        #
+        #     messages_path 'config/messages.yml'
+        #   end
+        def messages_path(path)
+          self._messages_path = path
+        end
+
+        # Namespace for error messages.
+        #
+        # @param name [String] namespace
+        #
+        # @since 0.6.0
+        #
+        # @example
+        #   require 'hanami/validations'
+        #
+        #   module MyApp
+        #     module Validators
+        #       class Signup
+        #         include Hanami::Validations
+        #
+        #         namespace 'signup'
+        #       end
+        #     end
+        #   end
+        #
+        #   # Instead of looking for error messages under the `my_app.validator.signup`
+        #   # namespace, it will look just for `signup`.
+        #   #
+        #   # This helps to simplify YAML files where are stored error messages
+        def namespace(name = nil)
+          if name.nil?
+            Namespace.new(_namespace, self)
+          else
+            self._namespace = name.to_s
+          end
+        end
+
+        private
+
+        # @since 0.6.0
+        # @api private
+        def _build(options = {}, &blk)
+          options = {build: false}.merge(options)
+          Rdy::Validation.__send__(_schema_type, options, &blk)
+        end
+
+        # @since 0.6.0
+        # @api private
+        def _schema_type
+          :Schema
+        end
+
+        # @since 0.6.0
+        # @api private
+        def _base_rules
+          lambda do
+          end
+        end
+
+        # @since 0.6.0
+        # @api private
+        def _schema_config
+          lambda do |config|
+            config.messages      = _messages      unless _messages.nil?
+            config.messages_file = _messages_path unless _messages_path.nil?
+            config.namespace     = namespace
+
+            require "rdy/validation/messages/i18n" if config.messages == :i18n
+          end
+        end
+
+        # @since 0.6.0
+        # @api private
+        def _schema_predicates
+          return if _predicates_module.nil? && _predicates.empty?
+
+          lambda do |config|
+            config.messages      = _predicates_module&.messages || @_messages || DEFAULT_MESSAGES_ENGINE
+            config.messages_file = _predicates_module.messages_path unless _predicates_module.nil?
+
+            require "rdy/validation/messages/i18n" if config.messages == :i18n
+          end
+        end
+
+        # @since 0.6.0
+        # @api private
+        def __predicates
+          mod = _predicates_module || Module.new { include Hanami::Validations::Predicates }
+
+          _predicates.each do |p|
+            mod.module_eval do
+              predicate(p.name, &p.to_proc)
+            end
+          end
+
+          mod
+        end
+
+        # @since 0.6.0
+        # @api private
+        def __messages
+          result = _predicates.each_with_object({}) do |p, ret|
+            ret[p.name] = p.message
+          end
+
+          # @api private
+          Module.new do
+            @@__messages = result # rubocop:disable Style/ClassVars
+
+            # @api private
+            def self.extended(base)
+              base.instance_eval do
+                def __messages
+                  Hash[en: {errors: @@__messages}]
+                end
+              end
+            end
+
+            # @api private
+            def messages
+              engine = super
+
+              messages = if engine.respond_to?(:merge)
+                          engine
+                        else
+                          engine.messages
+                        end
+
+              config.messages == :i18n ? messages : messages.merge(__messages)
+            end
+          end
+        end
+      end
+
+      # Initialize a new instance of a validator
+      #
+      # @param input [#to_h] a set of input data
+      #
+      # @since 0.6.0
+      def initialize(input = {})
+        @input = input.to_h
+      end
+
+      # Validates the object.
+      #
+      # @return [Rdy::Validations::Result]
+      #
+      # @since 0.2.4
+      def validate
+        self.class.schema.call(@input)
+      end
+
+      # Returns a Hash with the defined attributes as symbolized keys, and their
+      # relative values.
+      #
+      # @return [Hash]
+      #
+      # @since 0.1.0
+      def to_h
+        validate.output
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-ruby3
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Ascenda Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-08 00:00:00.000000000 Z
+date: 2023-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hanami
@@ -53,6 +53,14 @@ files:
 - lib/hanami/ruby3/hanami/view/rendering/scope.rb
 - lib/hanami/ruby3/hanami/views/default.rb
 - lib/hanami/ruby3/version.rb
+- lib/hanami/v1/README.md
+- lib/hanami/v1/action/base_params.rb
+- lib/hanami/v1/action/params.rb
+- lib/hanami/v1/validations.rb
+- lib/hanami/v1/validations/form.rb
+- lib/hanami/v1/validations/inline_predicate.rb
+- lib/hanami/v1/validations/namespace.rb
+- lib/hanami/v1/validations/predicates.rb
 homepage: http://github.com/Kaligo/hanami-ruby3
 licenses: []
 metadata: