knight 0.0.1 → 0.0.2

data/lib/knight/rule/format.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the format of a value
+    class Format < self
+      DEFAULT_MESSAGE = '%{attribute} has an invalid format'.freeze
+
+      # Regexp format
+      #
+      # @return [Regexp]
+      #
+      # @api private
+      attr_reader :regexp
+
+      # Initialize a format rule
+      #
+      # @param [Symbol] attribute_name
+      # @param [Regexp] regexp
+      #
+      # @option options [String] :message error_message
+      #
+      # @example
+      #   rule = Knight::Rule::Format.new(:username, /A-Z0-9/)
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attribute_name, regexp, options = {})
+        super(attribute_name, options)
+        @regexp = regexp
+      end
+
+      # Check value presence
+      #
+      # @param [String] value
+      #
+      # @return [true] if matched with the format
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        !!(regexp =~ value)
+      end
+
+      # Return the rule as a hash
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   hash = rule.to_hash
+      #
+      # @api public
+      def to_hash
+        super.merge({
+          format: regexp
+        }).freeze
+      end
+    end
+  end
+end

data/lib/knight/rule/inclusion.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the inclusion of a value
+    class Inclusion < self
+      DEFAULT_MESSAGE = '%{attribute} is not included in the list'.freeze
+
+      # Inclusion value
+      #
+      # @return [Range, Array]
+      #
+      # @api private
+      attr_reader :within
+
+      # Initialize an inclusion rule
+      #
+      # @param [Symbol] attribute_name
+      # @param [Range, Array] within
+      #
+      # @option options [String] :message error_message
+      #
+      # @example
+      #   rule = Knight::Rule::Inclusion.new(:username, ['john', 'jane'])
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attribute_name, within, options = {})
+        super(attribute_name, options)
+        @within = within
+      end
+
+      # Check value presence
+      #
+      # @param [Object] value
+      #
+      # @return [true] if the value within inclusion value
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        within.respond_to?(:cover?) ? within.cover?(value) : within.include?(value)
+      end
+
+      # Return the rule as a hash
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   hash = rule.to_hash
+      #
+      # @api public
+      def to_hash
+        super.merge({
+          within: within
+        }).freeze
+      end
+    end
+  end
+end

data/lib/knight/rule/maximum_length.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the length of a value
+    class MaximumLength < self
+      DEFAULT_MESSAGE = '%{attribute} is too long'.freeze
+
+      # Length value
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      attr_reader :maximum
+
+      # Initialize an exact length rule
+      #
+      # @param [Symbol] attribute_name
+      # @param [Fixnum] maximum
+      # @param [Hash] options for this rule
+      #
+      # @option options [String] :message error_message
+      #
+      # @example
+      #   rule = Knight::Rule::MaximumLength.new(:username, 20)
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attribute_name, maximum, options = {})
+        super(attribute_name, options)
+        @maximum = maximum
+      end
+
+      # Check length of the value
+      #
+      # @param [Object] value
+      #
+      # @return [true] if the length is matched
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        value.length <= maximum
+      end
+
+      # Return the rule as a hash
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   hash = rule.to_hash
+      #
+      # @api public
+      def to_hash
+        super.merge({
+          maximum: maximum
+        }).freeze
+      end
+    end
+  end
+end

data/lib/knight/rule/minimum_length.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the length of a value
+    class MinimumLength < self
+      DEFAULT_MESSAGE = '%{attribute} is too short'.freeze
+
+      # Length value
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      attr_reader :minimum
+
+      # Initialize an exact length rule
+      #
+      # @param [Symbol] attribute_name
+      # @param [Fixnum] minimum
+      # @param [Hash] options for this rule
+      #
+      # @option options [String] :message error_message
+      #
+      # @example
+      #   rule = Knight::Rule::MinimumLength.new(:username, 3)
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attribute_name, minimum, options = {})
+        super(attribute_name, options)
+        @minimum = minimum
+      end
+
+      # Check length of the value
+      #
+      # @param [Object] value
+      #
+      # @return [true] if the length is matched
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        value.length >= minimum
+      end
+
+      # Return the rule as a hash
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   hash = rule.to_hash
+      #
+      # @api public
+      def to_hash
+        super.merge({
+          minimum: minimum
+        }).freeze
+      end
+    end
+  end
+end

data/lib/knight/rule/presence.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the presence of a value
+    class Presence < self
+      DEFAULT_MESSAGE = "%{attribute} can't be blank".freeze
+
+      # Check the presence of a value
+      #
+      # @param [Object] value
+      #
+      # @return [true] if not blank
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        !blank?(value)
+      end
+
+      private
+
+      # Blank function
+      #
+      # @param [Object] value
+      #
+      # @return [true] if nil, empty string/array/hash
+      # @return [false] otherwise
+      #
+      # @api private
+      def blank?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/knight/rule/range_length.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Knight
+  class Rule
+
+    # A rule for checking the length of a value
+    class RangeLength < self
+      DEFAULT_MESSAGE = '%{attribute} has an invalid length'.freeze
+
+      # Length value
+      #
+      # @return [Range]
+      #
+      # @api private
+      attr_reader :range
+
+      # Initialize a length rule
+      #
+      # @param [Symbol] attribute_name
+      # @param [Range] range
+      # @param [Hash] options for this rule
+      #
+      # @option options [String] :message error_message
+      #
+      # @example
+      #   rule = Knight::Rule::RangeLength.new(:username, 3..20)
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def initialize(attribute_name, range, options = {})
+        super(attribute_name, options)
+        @range = range
+      end
+
+      # Check length of the value
+      #
+      # @param [Object] value
+      #
+      # @return [true] if the length is accepted
+      # @return [false] otherwise
+      #
+      # @api private
+      def matches?(value)
+        range.cover?(value.length)
+      end
+
+      # Return the rule as a hash
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   hash = rule.to_hash
+      #
+      # @api public
+      def to_hash
+        super.merge({
+          minimum: range.min,
+          maximum: range.max
+        }).freeze
+      end
+    end
+  end
+end

data/lib/knight/validator.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Knight
+  class Validator
+
+    DEFAULT_CONTEXT = :default
+
+    # Initialize a validator
+    #
+    # @example
+    #   Validator.new
+    #   Validator.new(Rule::Presence.new(:username))
+    #
+    # @param [Array(Rule)] rules
+    #
+    # @return [Validator]
+    #
+    # @api public
+    def initialize(*rules)
+      @rules = {}
+      rules.each { |rule| add(rule) }
+    end
+
+    # Add a rule
+    #
+    # @example
+    #   validator = Validator.new
+    #   validator.add(Rule::Presence.new(:username))
+    #
+    # @param [Rule] rule
+    # @param [Symbol] context
+    #
+    # @return [Set(Rule)]
+    #
+    # @api public
+    def add(rule, context_name = DEFAULT_CONTEXT)
+      context(context_name) { |rules| rules << rule } if rule
+    end
+
+    # Run the validator
+    #
+    # @example
+    #   validator = Validator.new(Rule::Presence.new(:username))
+    #   user = User.new(username: 'john')
+    #   validator.run(user)
+    #
+    # @param [Object] resource
+    # @param [Symbol] context
+    #
+    # @return [Result]
+    #
+    # @api public
+    def run(resource, context_name = DEFAULT_CONTEXT)
+      Result.new(resource, rules(context_name))
+    end
+
+    # Run the validator
+    #
+    # @example
+    #   validator = Validator.new(Rule::Presence.new(:username))
+    #   validator.rules
+    #
+    # @param [Symbol] context
+    #
+    # @return [Set(Rule)]
+    #
+    # @api public
+    def rules(context_name = DEFAULT_CONTEXT)
+      @rules.fetch(context_name) do |key|
+        @rules[key] = Set.new
+      end
+    end
+
+    # Accept block
+    #
+    # @example
+    #   validator = Validator.new
+    #   validator.context :registration do |context|
+    #     context << Rule::Presence.new(:username)
+    #   end
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def context(name)
+      yield rules(name)
+    end
+  end
+end