knight 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+bin

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+script: "COVERAGE=true bundle exec rspec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+notifications:
+  email:
+    - handi_wiguna@yahoo.com
+

data/Gemfile

@@ -1,4 +1,11 @@
+# encoding: utf-8
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in knight.gemspec
 gemspec
+
+group :development, :test do
+  gem 'rontgen'
+  eval_gemfile('Gemfile.dev') if File.exists?('Gemfile.dev')
+end

data/Gemfile.dev

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+group :development do
+  gem 'rake', '~>10.1'
+  gem 'rspec', '~>2.13'
+end
+
+group :metrics do
+  gem 'flog',      '~>4.1'
+  gem 'rubocop', git: 'https://github.com/bbatsov/rubocop'
+  gem 'simplecov', '~>0.7'
+  gem 'mutant', '0.3.0.rc1'
+  gem 'coveralls', '~>0.6.7', require: false
+end
+
+eval_gemfile('Gemfile.local') if File.exists?('Gemfile.local')

data/README.md

@@ -1,6 +1,8 @@
 # Knight
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/handiwiguna/knight.png?branch=master)](https://travis-ci.org/handiwiguna/knight)
+[![Code Climate](https://codeclimate.com/github/handiwiguna/knight.png)](https://codeclimate.com/github/handiwiguna/knight)
+[![Coverage Status](https://coveralls.io/repos/handiwiguna/knight/badge.png?branch=master)](https://coveralls.io/r/handiwiguna/knight)
 
 ## Installation
 

data/Rakefile

@@ -1 +1,6 @@
-require "bundler/gem_tasks"
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+
+require 'rontgen'
+Rontgen.load_tasks

data/knight.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.name          = "knight"
   gem.version       = Knight::VERSION
   gem.authors       = ["Handi Wiguna"]
-  gem.email         = ["handi@domikado.com"]
+  gem.email         = ["handi_wiguna@yahoo.com"]
   gem.description   = ""
   gem.summary       = ""
   gem.homepage      = ""
@@ -16,4 +16,7 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_dependency('equalizer', '~>0.0.5')
+  gem.add_dependency('abstract_type', '~>0.0.5')
 end

data/lib/knight.rb

@@ -1,5 +1,21 @@
-require "knight/version"
+# encoding: utf-8
+
+require 'equalizer'
+require 'abstract_type'
+
+require 'knight/version'
+require 'knight/rule'
+require 'knight/rule/presence'
+require 'knight/rule/exact_length'
+require 'knight/rule/maximum_length'
+require 'knight/rule/minimum_length'
+require 'knight/rule/range_length'
+require 'knight/rule/format'
+require 'knight/rule/inclusion'
+require 'knight/error'
+require 'knight/result'
+require 'knight/validator'
+require 'knight/instance_methods'
 
 module Knight
-  # Your code goes here...
 end

data/lib/knight/error.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Knight
+
+  # A representation of an error
+  class Error
+    include Equalizer.new(:rule, :resource)
+
+    # Broken rule
+    #
+    # @return [Rule]
+    #
+    # @api private
+    attr_reader :rule
+
+    # Object under validation
+    #
+    # @return [Object]
+    #
+    # @api private
+    attr_reader :resource
+
+    # Initialize an error
+    #
+    # @param [Rule] rule
+    # @param [Object] resource
+    #
+    # @return [Error]
+    #
+    # @api private
+    def initialize(rule, resource)
+      @rule = rule
+      @resource = resource
+    end
+
+    # Return formatted error message
+    #
+    # @example
+    #   error_message = error.message
+    #
+    # @return [String]
+    #
+    # @api public
+    def message
+      rule.message % rule.to_hash.merge(value: value)
+    end
+
+    private
+
+    # Return attribute value
+    #
+    # @return [Object]
+    #
+    # @api private
+    def value
+      attribute = rule.attribute_name
+      resource.public_send(attribute) if resource.respond_to?(attribute)
+    end
+  end
+end

data/lib/knight/instance_methods.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module Knight
+
+  # Base functionality that added when included to a class
+  module InstanceMethods
+
+    # Return the resource
+    #
+    # @return [Object]
+    #
+    # @api private
+    attr_reader :resource
+
+    # Extend base class to support validation
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    # Set the resource
+    #
+    # @param [Object] resource
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(resource)
+      @resource = resource
+    end
+
+    # Return the validation result
+    #
+    # @example
+    #   user = User.new
+    #
+    #   class RegistrationValidator
+    #     include Knight::InstanceMethods
+    #     validator.add(Knight::Rule::Presence.new(:username))
+    #   end
+    #
+    #   result = RegistrationValidator.new(user).result
+    #
+    # @return [Result]
+    #
+    # @api public
+    def run(context = Validator::DEFAULT_CONTEXT)
+      self.class.validator.run(resource, context)
+    end
+
+    module ClassMethods
+
+      # Return the validator object
+      #
+      # @return [Validator]
+      #
+      # @api private
+      def validator
+        @validator = @validator || Validator.new
+      end
+    end
+  end
+end

data/lib/knight/result.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Knight
+  class Result
+    include Equalizer.new(:resource, :rules)
+
+    # Return the resource
+    #
+    # @return [Object]
+    #
+    # @api private
+    attr_reader :resource
+
+    # Return the rule set
+    #
+    # @return [Set(Rule)]
+    #
+    # @api private
+    attr_reader :rules
+
+    # Initialize a validation result
+    #
+    # @param [Object] resource
+    # @param [Set(Rule)] rules
+    #
+    # @return [Result]
+    #
+    # @api private
+    def initialize(resource, rules)
+      @resource = resource
+      @rules = rules
+    end
+
+    # Check the result valid or not
+    #
+    # @example
+    #   validator = Validator.new(Rule::Presence.new(:username))
+    #   user = User.new(username: 'john')
+    #
+    #   result = validator.run(resource)
+    #   result.valid?
+    #
+    # @return [true] if valid
+    # @return [false] otherwise
+    #
+    # @api public
+    def valid?
+      errors.empty?
+    end
+
+    # Return the result errors
+    #
+    # @example
+    #   validator = Validator.new(Rule::Presence.new(:username))
+    #   user = User.new(username: 'john')
+    #
+    #   result = validator.run(resource)
+    #   result.errors
+    #
+    # @return [Set(Error)]
+    #
+    # @api public
+    def errors
+      rules.each_with_object(Set.new) do |rule, errors|
+        error = attribute_check(rule)
+        errors << error if error
+      end
+    end
+
+    private
+
+    # Check an attribute to the rule
+    #
+    # @return [Error] if invalid
+    # @return [nil] otherwise
+    #
+    # @api private
+    def attribute_check(rule)
+      if resource.respond_to?(rule.attribute_name)
+        rule.error(resource)
+      else
+        Error.new(rule, resource) if rule.kind_of?(Rule::Presence)
+      end
+    end
+  end
+end

data/lib/knight/rule.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module Knight
+
+  # An abstract class of a rule
+  class Rule
+    include AbstractType
+    include Equalizer.new(:attribute_name, :options)
+
+    DEFAULT_MESSAGE  = ''.freeze
+
+    # Attribute name to validate
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :attribute_name
+
+    # Attribute name to validate
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :options
+
+    # Message to displayed when rule is violated
+    #
+    # @return [String]
+    #
+    # @api private
+    attr_reader :message
+
+    # Initialize a rule
+    #
+    # @param [Symbol] attribute_name
+    # @param [Hash] options for this rule
+    #
+    # @option options [String] :message error message
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(attribute_name, options = {})
+      @attribute_name = attribute_name
+      @options        = options
+      @message        = @options.fetch(:message, self.class::DEFAULT_MESSAGE)
+    end
+
+    # Return error if the rule not satisfied
+    #
+    # @param [Object] resource
+    #
+    # @return [Error] if the rule not matched
+    # @return [nil] if the rule is satisfied
+    #
+    # @api private
+    def error(resource)
+      value = resource.public_send(attribute_name)
+      Error.new(self, resource) unless matches?(value)
+    end
+
+    # Return the rule as a hash
+    #
+    # @return [Hash]
+    #
+    # @example
+    #   hash = rule.to_hash
+    #
+    # @api public
+    def to_hash
+      { attribute: attribute_name }.freeze
+    end
+  end
+end

data/lib/knight/rule/exact_length.rb

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