great_guardian 0.1.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9755441c71cd68b3ec0775ef0aa266a9e8ab9591d1546bdb6bdc1bf69f813a6b
+  data.tar.gz: 51b9331234a489ded36dd642a3711895a603ab55cc1143ebd6e24897207a6b2f
+SHA512:
+  metadata.gz: fc93e36dcab7b24a90ba0a0fb50926b78d47f68a84c6fd1643a7ddc8b949736c415f0f9c85e787cdd647ec7813813d92e7b89aac6284879d1ad7822a3b7c2f67
+  data.tar.gz: 9fcfe88e86a9f64a57453eca27e4dd5445ea3a8ff95bd30ea17e87baefbf550a28fdf8f262c615d0f99cee90fd8b47d1aa3d0b06529626b0a9c075f7b46bb1f8

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2020 Cyril Kato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# Great Guardian
+
+[![Build Status](https://api.travis-ci.org/cyril/great_guardian.rb.svg?branch=master)][travis]
+[![Gem Version](https://badge.fury.io/rb/great_guardian.svg)][gem]
+[![Inline docs](https://inch-ci.org/github/cyril/great_guardian.rb.svg?branch=master)][inchpages]
+[![Documentation](http://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
+
+> Web parameters validation for Ruby 🛡️
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'great_guardian', '>= 0.1.0.beta1'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install great_guardian --pre
+
+## Usage
+
+```ruby
+class EmailAttribute < GreatGuardian::Attribute::Base
+  def self.expected_value_type
+    ::GreatGuardian::ExpectedValue::String
+  end
+
+  def self.default_constraints
+    {
+      pattern: /\A[^@]+@[^@]+$\z/i
+    }
+  end
+end
+
+email_attribute = EmailAttribute.new(required: true)
+
+email_attribute.call(nil) # => #<GreatGuardian::Verdict:0x00007ffd3f00ad40 @attribute_name="email_attribute", @value=nil, @error_message=["attribute.email_attribute.errors.required", {:name=>["attribute.email_attribute.name"], :expected=>nil}], @medium=:body>
+email_attribute.call(4) # => #<GreatGuardian::Verdict:0x00007ffd3e360590 @attribute_name="email_attribute", @value=4, @error_message=["attribute.email_attribute.errors.type", {:name=>["attribute.email_attribute.name"], :expected=>["expected_value.string.type"]}], @medium=:body>
+email_attribute.call('boom') # => #<GreatGuardian::Verdict:0x00007ffd3e3d8360 @attribute_name="email_attribute", @value="boom", @error_message=["attribute.email_attribute.errors.pattern", {:name=>["attribute.email_attribute.name"], :expected=>/\A[^@]+@[^@]+$\z/i}], @medium=:body>
+email_attribute.call('bob@gmail.com') # => #<GreatGuardian::Verdict:0x00007ffd3e3c23d0 @attribute_name="email_attribute", @value="bob@gmail.com", @error_message=nil, @medium=:body>
+```
+
+## Contact
+
+* Home page: https://github.com/cyril/great_guardian.rb
+* Bugs/issues: https://github.com/cyril/great_guardian.rb/issues
+
+## Rubies
+
+* [MRI](https://www.ruby-lang.org/)
+* [Rubinius](https://rubinius.com/)
+* [JRuby](https://www.jruby.org/)
+
+## Versioning
+
+__GreatGuardian__ follows [Semantic Versioning 2.0](https://semver.org/).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[gem]: https://rubygems.org/gems/great_guardian
+[travis]: https://travis-ci.org/cyril/great_guardian.rb
+[inchpages]: https://inch-ci.org/github/cyril/great_guardian.rb
+[rubydoc]: https://rubydoc.info/gems/great_guardian/frames

data/lib/great_guardian.rb

@@ -0,0 +1,6 @@
+module GreatGuardian
+end
+
+require_relative File.join('great_guardian', 'attribute')
+require_relative File.join('great_guardian', 'expected_value')
+require_relative File.join('great_guardian', 'verdict')

data/lib/great_guardian/attribute.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GreatGuardian
+  # Collection of attributes.
+  module Attribute
+  end
+end
+
+Dir[File.join File.dirname(__FILE__), 'attribute', '*.rb'].each do |fname|
+  require_relative fname
+end

data/lib/great_guardian/attribute/base.rb

@@ -0,0 +1,161 @@
+module GreatGuardian
+  module Attribute
+    class Base
+      attr_reader :custom_constraints, :default_value, :medium
+
+      def initialize(required: true, medium: :body, default_value: nil, **custom_constraints)
+        raise ::ArgumentError, required.inspect unless [false, true].include?(required)
+        raise ::ArgumentError, medium.inspect    unless %i[body header querystring].include?(medium)
+
+        @custom_constraints = custom_constraints
+        @default_value      = default_value
+        @medium             = medium
+        @required           = required
+      end
+
+      def call(actual_value)
+        actual_value  = actual_value_or_default_value(actual_value)
+        error_message = compute_error_message(actual_value)
+
+        Verdict.new(to_s, actual_value, error_message, medium)
+      end
+
+      def constraints
+        self.class.default_constraints.merge(**custom_constraints)
+      end
+
+      def expected_value
+        self.class.expected_value_type.new(**constraints)
+      end
+
+      def required?
+        @required
+      end
+
+      def to_s
+        self.class
+            .name
+            .split('::')
+            .fetch(-1)
+            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+            .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+            .tr('-', '_')
+            .downcase
+      end
+
+      def to_sym
+        to_s.to_sym
+      end
+
+      def body?
+        medium.equal?(:body)
+      end
+
+      def header_or_querystring?
+        !body?
+      end
+
+      def self.possible_values; end
+
+      def self.default_value; end
+
+      def self.default_constraints
+        {}
+      end
+
+      def self.first_matched_error_on_complex_validation_logic_against(_actual_value); end
+
+      private
+
+      def actual_value_or_default_value(actual_value)
+        return actual_value unless not_required_and_nil_or_empty?(actual_value)
+
+        return default_value            unless default_value.nil?
+        return self.class.default_value unless self.class.default_value.nil?
+
+        actual_value
+      end
+
+      def compute_error_message(actual_value)
+        return if not_required_and_nil_or_empty?(actual_value)
+
+        if required_but_nil?(actual_value)
+          return i18n_attribute_error(:required, name: i18n_attribute_name)
+        end
+
+        first_error = expected_value.first_matched_error_against(actual_value, is_native: body?)
+
+        if first_error.nil?
+          unless self.class.possible_values.nil?
+            actual_value_is_included_in_possible_values = if self.class.expected_value_type.equal?(::GreatGuardian::ExpectedValue::Array)
+                                                            actual_value.all? { |item| self.class.possible_values.include?(item) }
+                                                          else
+                                                            self.class.possible_values.include?(actual_value)
+                                                          end
+
+            unless actual_value_is_included_in_possible_values
+              return i18n_attribute_error(:possible_values,
+                name:     i18n_attribute_name,
+                expected: self.class.possible_values.map(&:inspect).sort.join(', ')
+              )
+            end
+          end
+
+          error_on_complex_validation_logic = self.class.first_matched_error_on_complex_validation_logic_against(actual_value)
+
+          unless error_on_complex_validation_logic.nil?
+            return i18n_attribute_error(error_on_complex_validation_logic)
+          end
+        end
+
+        return if first_error.nil?
+
+        expected = expected_value.public_send(first_error)
+
+        if first_error.equal?(:type)
+          expected = i18n_expected_value_type(expected_value.type)
+        end
+
+        i18n_attribute_error(first_error,
+          name:     i18n_attribute_name,
+          expected: expected
+        )
+      end
+
+      def not_required_and_nil_or_empty?(actual_value)
+        return false if required?
+
+        return true if actual_value.nil?        && body?
+        return true if actual_value.to_s.empty? && header_or_querystring?
+
+        false
+      end
+
+      def required_but_nil?(actual_value)
+        actual_value.nil? && required?
+      end
+
+      def i18n_attribute_name
+        [
+          "attribute.#{self.to_sym}.name"
+        ]
+      end
+
+      def i18n_expected_value_type(expected_value)
+        [
+          "expected_value.#{expected_value}.type"
+        ]
+      end
+
+      def i18n_attribute_error(error, name: nil, expected: nil)
+        [
+          "attribute.#{self.to_sym}.errors.#{error}",
+          {
+            name:     name,
+            expected: expected
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/great_guardian/expected_value.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GreatGuardian
+  # Collection of expected values.
+  module ExpectedValue
+  end
+end
+
+Dir[File.join File.dirname(__FILE__), 'expected_value', '*.rb'].each do |fname|
+  require_relative fname
+end

data/lib/great_guardian/expected_value/array.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+
+module GreatGuardian
+  module ExpectedValue
+    class Array < Base
+      attr_reader :minlen, :maxlen
+
+      def initialize(minlen: nil, maxlen: nil)
+        raise ::ArgumentError, minlen.inspect if !minlen.nil? && !minlen.is_a?(::Integer)
+        raise ::ArgumentError, maxlen.inspect if !maxlen.nil? && !maxlen.is_a?(::Integer)
+
+        if !minlen.nil? && !maxlen.nil? && (minlen > maxlen)
+          raise ::ArgumentError, minlen.inspect, maxlen.inspect
+        end
+
+        @minlen = minlen
+        @maxlen = maxlen
+      end
+
+      def first_matched_error_against(actual_value, is_native: true)
+        actual_value = emulate(actual_value) unless is_native
+
+        return :type    unless valid_type?(actual_value)
+        return :minlen  if !minlen.nil? && actual_value.length < minlen
+        return :maxlen  if !maxlen.nil? && actual_value.length > maxlen
+      end
+
+      def self.types
+        [::Array]
+      end
+
+      def emulate(value)
+        if value.to_s.start_with?('[') && value.to_s.end_with?(']')
+          return value.to_s.split(',').map(&:strip)
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/great_guardian/expected_value/base.rb

@@ -0,0 +1,30 @@
+module GreatGuardian
+  module ExpectedValue
+    class Base
+      def initialize(**)
+      end
+
+      def valid_type?(actual_value)
+        self.class.types.any? { |type| actual_value.is_a?(type) }
+      end
+
+      def type
+        self.class
+            .name
+            .split('::')
+            .fetch(-1)
+            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+            .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+            .tr('-', '_')
+            .downcase
+            .to_sym
+      end
+
+      def self.types
+        raise ::NotImplementedError
+      end
+    end
+  end
+end
+
+# require_relative ::File.join('..', 'expected_value')

data/lib/great_guardian/expected_value/boolean.rb

@@ -0,0 +1,24 @@
+require_relative 'base'
+
+module GreatGuardian
+  module ExpectedValue
+    class Boolean < Base
+      def first_matched_error_against(actual_value, is_native: true)
+        actual_value = emulate(actual_value) unless is_native
+
+        return :type unless valid_type?(actual_value)
+      end
+
+      def self.types
+        [::FalseClass, ::TrueClass]
+      end
+
+      def emulate(value)
+        return true   if value.eql?('true')
+        return false  if value.eql?('false')
+
+        value
+      end
+    end
+  end
+end

data/lib/great_guardian/expected_value/number.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+
+module GreatGuardian
+  module ExpectedValue
+    class Number < Base
+      attr_reader :min, :max
+
+      def initialize(min: nil, max: nil)
+        raise ::ArgumentError, min.inspect if !min.nil? && !min.is_a?(::Numeric)
+        raise ::ArgumentError, max.inspect if !max.nil? && !max.is_a?(::Numeric)
+
+        if !min.nil? && !max.nil? && (min > max)
+          raise ::ArgumentError, min.inspect, max.inspect
+        end
+
+        @min = min
+        @max = max
+      end
+
+      def first_matched_error_against(actual_value, is_native: true)
+        actual_value = emulate(actual_value) unless is_native
+
+        return :type  unless valid_type?(actual_value)
+        return :min   if !min.nil? && actual_value < min
+        return :max   if !max.nil? && actual_value > max
+      end
+
+      def self.types
+        [::Numeric]
+      end
+
+      def emulate(value)
+        if value.match?(/\A-?([0-9]+.)?[0-9]+\z/)
+          return value.include?('.') ? value.to_f : value.to_i
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/great_guardian/expected_value/string.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+
+module GreatGuardian
+  module ExpectedValue
+    class String < Base
+      attr_reader :minlen, :maxlen, :pattern
+
+      def initialize(minlen: nil, maxlen: nil, pattern: nil)
+        raise ::ArgumentError, minlen.inspect if !minlen.nil? && !minlen.is_a?(::Integer)
+        raise ::ArgumentError, maxlen.inspect if !maxlen.nil? && !maxlen.is_a?(::Integer)
+
+        if !minlen.nil? && !maxlen.nil? && (minlen > maxlen)
+          raise ::ArgumentError, minlen.inspect, maxlen.inspect
+        end
+
+        raise ::ArgumentError, pattern.inspect if !pattern.nil? && !pattern.is_a?(::Regexp)
+
+        @minlen   = minlen
+        @maxlen   = maxlen
+        @pattern  = pattern
+      end
+
+      def first_matched_error_against(actual_value, is_native: true)
+        actual_value = emulate(actual_value) unless is_native
+
+        return :type    unless valid_type?(actual_value)
+        return :minlen  if !minlen.nil? && actual_value.length < minlen
+        return :maxlen  if !maxlen.nil? && actual_value.length > maxlen
+        return :pattern if !pattern.nil? && !actual_value.match?(pattern)
+      end
+
+      def self.types
+        [::String]
+      end
+
+      def emulate(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/great_guardian/verdict.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GreatGuardian
+  # Decision of Great Guardian.
+  class Verdict
+    attr_reader :value, :error_message, :medium
+
+    def initialize(attribute_name, value, error_message, medium)
+      raise ::ArgumentError, medium.inspect unless %i[body header querystring].include?(medium)
+
+      @attribute_name = attribute_name
+      @value          = value
+      @error_message  = error_message
+      @medium         = medium
+    end
+
+    def valid?
+      error_message.nil?
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def to_s
+      @attribute_name
+    end
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: great_guardian
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+platform: ruby
+authors:
+- Cyril Kato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: "Web parameters validation for Ruby \U0001F6E1️"
+email: contact@cyril.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/great_guardian.rb
+- lib/great_guardian/attribute.rb
+- lib/great_guardian/attribute/base.rb
+- lib/great_guardian/expected_value.rb
+- lib/great_guardian/expected_value/array.rb
+- lib/great_guardian/expected_value/base.rb
+- lib/great_guardian/expected_value/boolean.rb
+- lib/great_guardian/expected_value/number.rb
+- lib/great_guardian/expected_value/string.rb
+- lib/great_guardian/verdict.rb
+homepage: https://github.com/cyril/great_guardian.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: "Web parameters validation for Ruby \U0001F6E1️"
+test_files: []