dry-validation-rails 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 500d12bc6fad48330593308a23c315510fc282a787c7cdeb41503b30dd518c78
-  data.tar.gz: dd435b9261fb3dfbe81ac3200f9df3b3f86244b8e704378ff591bfc7cc76668b
+  metadata.gz: fe5b7374edb7ccf542e436b1f90fd2caca2cae5b0a320a72b292cf053600f5a1
+  data.tar.gz: fb19d418b26fe96e37d1e3aa550e915389214d6fdd3fe40edf9cd9ceb0315ea0
 SHA512:
-  metadata.gz: f5c6a9ef66888dcfb94a9516bab3f73dd1e4ac622737f5eb92abb0a56b4668b4a7becbbf4c2c2387178242d9ed61e1bed26f72028fb2f3f0674b7db84d5e8cc1
-  data.tar.gz: 56dda1dfcd16135f5c9a0da9373c7955e2c391b1679dd132109d00763b4b76106aa823bd672f6b48489d48cba460e737106e2d708acb5f132b5eb281ca8ab34d
+  metadata.gz: d88af909bf6625d14def732f9bd0b309a511446d724f87ebace41268908c35c59a869610180a63b5d5bcfc9a6f657129dac25ef03183203733e47346ae1ee651
+  data.tar.gz: 212c57c2d78d2befd7841436efc1a859ec21b7c72ae5c9e94b93588ed7e3770ba1887e7bed1f6d8ebe9a6cbcf8eb72e9ff90f63d6f22f23ccc548dbb76d091cf

data/README.md

@@ -24,9 +24,254 @@ If bundler is not being used to manage dependencies, install the gem by executin
 $ gem install dry-validation-rails
 ```
 
+## Configuration
+```ruby
+Dry::Validation::Rails.configure do |config|
+  config.default_schema_prefix = 'ApplicationContract::' 
+  config.default_schema_suffix = 'Schema'
+end
+
+Dry::Validation::Rails.configuration.default_schema_prefix = 'ApplicationContract::'
+Dry::Validation::Rails.configuration.default_schema_suffix = 'Contract'
+```
+
 ## Usage
 
-TODO: Write usage instructions here
+Simply drop in followability to a model:
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry
+end
+
+class UserSchema < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+### With DRY Schema
+You can use [dry-schema](https://dry-rb.org/gems/dry-schema/) for defining your schema and use it in your model.
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry
+end
+
+UserSchema = Dry::Schema.Params do
+  required(:name).filled(:string)
+  required(:email).filled(:string)
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+### With DRY Validation Contract
+You can use [dry-validation](https://dry-rb.org/gems/dry-validation/) for defining your schema and use it in your model.
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry
+end
+
+class UserSchema < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+### Passing options
+
+You can pass options to the schema by passing a hash to the `validates_with_dry` method.
+
+
+#### Prefix and Suffix
+```ruby
+class User < ActiveRecord::Base
+  # You can pass custom prefix and suffix for validator class
+  validates_with_dry schema_prefix: 'ApplicationContract::', schema_suffix: 'Contract'
+end
+
+class Application
+  class UserContract < Dry::Validation::Contract
+    params do
+      required(:name).filled(:string)
+      required(:email).filled(:string)
+    end
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+#### Custom Schema
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: UserCustomSchema # custom schema
+end
+
+class UserCustomSchema < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+#### Pass record to contract
+We can define it as an external dependency that will be injected to the contract's constructor for Dry Validation Contract. You can pass record to the contract like this:
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: UserSchema, pass_record_to_contract: true # default key is :record
+end
+
+class UserSchema < Dry::Validation::Contract
+  option :record # this is the record that will be passed to the contract as an option
+
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+    required(:age).filled(:integer).value(gteq?: 18)
+  end
+
+  rule(:age) do
+    key.failure('must be greater than 20') if record.role.admin? && value < 20
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+**Custom key for record**
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: UserSchema, pass_record_to_contract: { as: :user }
+end
+
+class UserSchema < Dry::Validation::Contract
+  option :user
+
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+    required(:age).filled(:integer).value(gteq?: 18)
+  end
+
+  rule(:age) do
+    key.failure('must be greater than 20') if user.role.admin? && value < 20
+  end
+end
+
+user = User.new(name: '', email: '')
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string"]
+```
+
+#### Run validation on update or create
+Default is `:all` which means it will run on both create and update. You can pass `:create` or `:update` to run validation only on create or update.
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: UserSchema, on: :create
+end
+
+class UserSchema < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+  end
+end
+
+user = User.first
+user.name = ''
+user.valid? # => true
+user.errors.full_messages # => []
+```
+
+### Run validation with if or unless
+You can pass `if` or `unless` option as a symbol or a proc to run validation only if the condition is true.
+
+***if***
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: AdminSchema, if: Proc.new { |user| user.admin? }
+  validates_with_dry schema: UserSchema, if: :normal_user?
+
+  def admin?
+    role.admin?
+  end
+
+  def normal_user?
+    !admin?
+  end
+end
+```
+
+***unless***
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: AdminSchema, unless: :normal_user?
+  validates_with_dry schema: UserSchema, unless: Proc.new { |user| user.admin? }
+
+  def admin?
+    role.admin?
+  end
+
+  def normal_user?
+    !admin?
+  end
+end
+```
+
+## JSON / JSONB Attributes
+You can validate json/jsonb columns with like this:
+
+```ruby
+class User < ActiveRecord::Base
+  validates_with_dry schema: UserSchema
+end
+
+class UserSchema < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:email).filled(:string)
+    required(:preferences).hash do
+      required(:color).filled(:string)
+      required(:font).filled(:string)
+    end
+  end
+end
+
+user = User.new(name: '', email: '', preferences: { color: '', font: '' })
+user.valid? # => false
+user.errors.full_messages # => ["Name is missing", "Name must be a string", "Email is missing", "Email must be a string", "Preferences is missing", "Preferences must be a hash", "Preferences.color is missing", "Preferences.color must be a string", "Preferences.font is missing", "Preferences.font must be a string"]
+```
 
 ## Development
 

data/lib/dry/validation/rails/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rails
+      class Configuration
+        DEFAULT_SCHEMA_PREFIX = ''
+        DEFAULT_SCHEMA_SUFFIX = 'Schema'
+
+        attr_accessor :default_schema_prefix, :default_schema_suffix
+
+        def initialize(default_schema_prefix: DEFAULT_SCHEMA_PREFIX, default_schema_suffix: DEFAULT_SCHEMA_SUFFIX)
+          @default_schema_prefix = default_schema_prefix
+          @default_schema_suffix = default_schema_suffix
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rails/helpers.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rails
+      module Helpers
+        SUPPORTED_VALIDATORS = [
+          Dry::Validation::Contract,
+          Dry::Schema.Params,
+          Dry::Schema::JSON
+        ].freeze
+
+        def default_schema_for(record, options = {})
+          prefix = options.fetch(:schema_prefix, Dry::Validation::Rails.configuration.default_schema_prefix).to_s
+          suffix = options.fetch(:schema_suffix, Dry::Validation::Rails.configuration.default_schema_suffix).to_s
+
+          begin
+            "#{prefix}#{record.class.name}#{suffix}".classify.constantize
+          rescue StandardError
+            raise Dry::Validation::Rails::SchemaNotFound, "Schema not found for #{record.class.name}"
+          end
+        end
+
+        # rubocop:disable Layout/LineLength
+        def valid_schema?(schema)
+          if schema.respond_to?(:ancestors)
+            return schema.ancestors.any? do |ancestor|
+                     SUPPORTED_VALIDATORS.include?(ancestor)
+                   end
+          end
+
+          schema.is_a?(Dry::Validation::Contract) || schema.is_a?(Dry::Schema::Params) || schema.is_a?(Dry::Schema::JSON)
+        end
+        # rubocop:enable Layout/LineLength
+
+        def need_to_validate?(record, options)
+          return true if options[:on].blank? || options[:on] == :all
+
+          record.new_record? if options[:on] == :create
+
+          record.persisted? if options[:on] == :update
+
+          raise ArgumentError, "Invalid value for :on option: #{options[:on]}"
+        end
+
+        # rubocop:disable Naming/PredicateName
+        def is_dry_schema?(schema)
+          schema.is_a?(Dry::Schema::Params) || schema.is_a?(Dry::Schema::JSON)
+        end
+
+        def is_dry_validation_contract?(schema)
+          schema.respond_to?(:ancestors) && schema.ancestors.include?(Dry::Validation::Contract)
+        end
+        # rubocop:enable Naming/PredicateName
+
+        def pass_record_to_contract?(options)
+          value = options[:pass_record_to_contract]
+
+          return true if boolean?(value) || value.is_a?(Hash)
+
+          false
+        end
+
+        def record_key_for_passing_to_contract(options)
+          return :record if boolean?(options[:pass_record_to_contract])
+
+          options.fetch(:pass_record_to_contract, {}).fetch(:as, :record)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def skip_validation?(options, record)
+          if_val = options[:if]
+          unless_val = options[:unless]
+
+          if if_val.present?
+            return false unless if_val.is_a?(Symbol) || if_val.is_a?(Proc)
+            return false if if_val.is_a?(Symbol) && record.respond_to?(if_val) && record.send(if_val)
+            return false if if_val.is_a?(Proc) && if_val.call(record)
+          end
+
+          if unless_val.present?
+            return false unless unless_val.is_a?(Symbol) || unless_val.is_a?(Proc)
+            return false if unless_val.is_a?(Symbol) && record.respond_to?(unless_val) && !record.send(unless_val)
+            return false if unless_val.is_a?(Proc) && !unless_val.call(record)
+          end
+
+          false
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        private
+
+        def boolean?(value)
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rails/validatable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Rails
+      module Validatable
+        def validates_with_dry(**options)
+          validates_with Dry::Validation::Rails::Validator, **options
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rails/validator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module Dry
+  module Validation
+    module Rails
+      class Validator < ActiveModel::Validator
+        include Dry::Validation::Rails::Helpers
+
+        def validate(record)
+          return if skip_validation?(options, record)
+
+          schema = options.fetch(:schema, default_schema_for(record, options))
+
+          unless valid_schema?(schema)
+            raise ArgumentError,
+                  'Schema must be a Dry::Schema::Params or Dry::Schema::JSON or Dry::Validation::Contract'
+          end
+
+          validate_schema(record, schema, options) if need_to_validate?(record, options)
+        end
+
+        def validate_schema(record, schema, options)
+          if is_dry_validation_contract?(schema)
+            validate_dry_validation_contract(record, schema, options)
+          elsif is_dry_schema?(schema)
+            validate_dry_schema(record, schema, options)
+          else
+            raise ArgumentError,
+                  'Schema must be a Dry::Schema::Params or Dry::Schema::JSON or Dry::Validation::Contract'
+          end
+        end
+
+        private
+
+        def validate_dry_validation_contract(record, schema, options)
+          validator_schema = if pass_record_to_contract?(options)
+                               key = record_key_for_passing_to_contract(options)
+                               schema.new(key => record)
+                             else
+                               schema.new
+                             end
+
+          result = validator_schema.call(record.attributes)
+
+          return if result.success?
+
+          validate_each(record, result.errors.to_h)
+        end
+
+        def validate_dry_schema(record, schema, _options)
+          result = schema.call(record.attributes)
+
+          return if result.success?
+
+          validate_each(record, result.errors.to_h)
+        end
+
+        def validate_each(record, errors)
+          errors.each do |attribute, all_errors|
+            all_errors.each do |error|
+              record.errors.add(attribute, error) if record.respond_to?(attribute.to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/rails/version.rb

@@ -3,7 +3,7 @@
 module Dry
   module Validation
     module Rails
-      VERSION = '0.1.0'
+      VERSION = '0.1.1'
     end
   end
 end

data/lib/dry/validation/rails.rb

@@ -1,14 +1,38 @@
 # frozen_string_literal: true
 
 require_relative 'rails/version'
+require_relative 'rails/configuration'
 require 'rails'
 require 'dry-validation'
+require 'active_support'
+require 'active_record'
+require 'active_model'
 
 module Dry
   module Validation
     module Rails
-      class Error < StandardError; end
-      # Your code goes here...
+      extend ActiveSupport::Autoload
+
+      autoload :Validatable
+      autoload :Validator
+      autoload :Errors
+
+      class << self
+        def configuration
+          @configuration ||= Configuration.new
+        end
+
+        def configure
+          yield configuration
+        end
+      end
+
+      class BaseError < StandardError; end
+      class SchemaNotFound < BaseError; end
     end
   end
 end
+
+ActiveSupport.on_load(:active_record) do
+  extend Dry::Validation::Rails::Validatable
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-validation-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - nejdetkadir
@@ -56,6 +56,10 @@ files:
 - Rakefile
 - dry-validation-rails.gemspec
 - lib/dry/validation/rails.rb
+- lib/dry/validation/rails/configuration.rb
+- lib/dry/validation/rails/helpers.rb
+- lib/dry/validation/rails/validatable.rb
+- lib/dry/validation/rails/validator.rb
 - lib/dry/validation/rails/version.rb
 - sig/dry/validation/rails.rbs
 homepage: https://github.com/nejdetkadir/dry-validation-rails