yema 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+bin/
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yema.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+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,70 @@
+# Yema
+
+[![Build Status](https://travis-ci.org/handiwiguna/yema.png?branch=master)](https://travis-ci.org/handiwiguna/yema)
+[![Code Climate](https://codeclimate.com/github/handiwiguna/yema.png)](https://codeclimate.com/github/handiwiguna/yema)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'yema'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yema
+
+## Usage
+
+Standalone:
+
+```ruby
+class User
+  include Yema::Validations
+  attr_accessor :age
+end
+
+User.rules.add(Yema::Rule::StrongType, Integer)
+
+user = User.new
+user.age = 3
+user.valid? # => true
+
+user.age = '3'
+user.valid? # => true
+
+user.age = 'abc'
+user.valid? # => false
+```
+
+Virtus Integration:
+
+```ruby
+class UserParam
+  include Yema::Virtus::Validations
+  attribute :age, Integer, required: true
+end
+
+user = UserParam.new(age: 2)
+user.valid? # => true
+
+user = UserParam.new(age: '2')
+user.valid? # => true
+
+user = UserParam.new(age: 'abc')
+user.valid? # => false
+
+user = UserParam.new
+user.valid? # => false
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/yema.rb

@@ -0,0 +1,33 @@
+require 'equalizer'
+require 'virtus'
+
+require "yema/version"
+require 'yema/error'
+require 'yema/exceptions'
+require 'yema/validations'
+require 'yema/validator'
+require 'yema/registry/rule'
+
+require 'yema/rule'
+require 'yema/rule/required'
+require 'yema/rule/format'
+require 'yema/rule/length'
+require 'yema/rule/inclusion'
+require 'yema/rule/strong_type'
+
+require 'yema/virtus/validations'
+require 'yema/virtus/builder'
+require 'yema/virtus/builder/format'
+require 'yema/virtus/builder/inclusion'
+require 'yema/virtus/builder/length'
+require 'yema/virtus/builder/required'
+require 'yema/virtus/builder/strong_type'
+
+require 'yema/virtus/attribute'
+require 'yema/virtus/attribute/numeric'
+require 'yema/virtus/attribute/array'
+require 'yema/virtus/attribute/string'
+
+module Yema
+  Undefined = Object.new.freeze
+end

data/lib/yema/error.rb

@@ -0,0 +1,11 @@
+module Yema
+  class Error
+    include Equalizer.new(:rule, :resource)
+
+    attr_reader :rule, :resource
+
+    def initialize(rule, resource)
+      @rule, @resource = rule, resource
+    end
+  end
+end

data/lib/yema/exceptions.rb

@@ -0,0 +1,3 @@
+module Yema
+  class InvalidOptionError < StandardError; end
+end

data/lib/yema/registry/rule.rb

@@ -0,0 +1,26 @@
+module Yema
+  module Registry
+    class Rule
+      include Enumerable
+
+      attr_reader :rules
+
+      def initialize
+        @rules = Set.new
+      end
+
+      def add(rule)
+        @rules << rule if rule
+      end
+
+      def merge(rule_set)
+        @rules.merge(rule_set)
+      end
+
+      def each
+        return enum_for :each unless block_given?
+        @rules.each{|rule| yield rule}
+      end
+    end
+  end
+end

data/lib/yema/rule.rb

@@ -0,0 +1,32 @@
+module Yema
+  class Rule
+    include Equalizer.new(:attribute_name)
+
+    attr_reader :attribute_name
+
+    def initialize(attribute_name, options={})
+      assert_required_options(options)
+      @attribute_name = attribute_name
+    end
+
+    def self.required_options
+      []
+    end
+
+    def validate(resource)
+      Validator.new(self, resource)
+    end
+
+    def errors(resource)
+      validate(resource).errors
+    end
+
+    private
+
+    def assert_required_options(options)
+      shortage = self.class.required_options - options.keys
+      raise InvalidOptionError, "Missing options: #{shortage.inspect}" unless shortage.empty?
+    end
+
+  end
+end

data/lib/yema/rule/format.rb

@@ -0,0 +1,29 @@
+module Yema
+  class Rule
+    class Format < self
+
+      attr_reader :format
+
+      def initialize(attribute_name, options={})
+        super
+        extract_options(options)
+      end
+
+      def self.required_options
+        [:format]
+      end
+
+      def matches?(value)
+        !!(format =~ value)
+      end
+
+      private
+
+      def extract_options(options)
+        @format = options.fetch(:format)
+        raise InvalidOptionError, "Format option only accept Regexp" unless format.kind_of?(Regexp)
+      end
+
+    end
+  end
+end

data/lib/yema/rule/inclusion.rb

@@ -0,0 +1,29 @@
+module Yema
+  class Rule
+    class Inclusion < self
+
+      attr_reader :within
+
+      def initialize(attribute_name, options={})
+        super
+        extract_options(options)
+      end
+
+      def self.required_options
+        [:within]
+      end
+
+      def matches?(value)
+        within.include?(value)
+      end
+
+      private
+
+      def extract_options(options)
+        @within = options.fetch(:within)
+        raise InvalidOptionError, "Within option only accept Array or Range" unless [Array, Range].include?(within.class)
+      end
+
+    end
+  end
+end

data/lib/yema/rule/length.rb

@@ -0,0 +1,34 @@
+module Yema
+  class Rule
+    class Length < self
+
+      attr_reader :length
+
+      def initialize(attribute_name, options={})
+        super
+        extract_options(options)
+      end
+
+      def self.required_options
+        [:length]
+      end
+
+      def matches?(value)
+        raise ArgumentError unless value.respond_to?(:length)
+
+        case length
+        when Range;  length.include?(value.length)
+        when Fixnum; length == value.length
+        end
+      end
+
+      private
+
+      def extract_options(options)
+        @length = options.fetch(:length)
+        raise InvalidOptionError, "Length option only accept Fixnum or Range" unless [Fixnum, Range].include?(length.class)
+      end
+
+    end
+  end
+end

data/lib/yema/rule/required.rb

@@ -0,0 +1,17 @@
+module Yema
+  class Rule
+    class Required < self
+
+      def matches?(value)
+        !blank?(value)
+      end
+
+      private
+
+      def blank?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+    end
+  end
+end

data/lib/yema/rule/strong_type.rb

@@ -0,0 +1,58 @@
+module Yema
+  class Rule
+    class StrongType < self
+
+      attr_reader :type, :strict, :member_type
+
+      def initialize(attribute_name, options={})
+        super
+        extract_options(options)
+      end
+
+      def self.required_options
+        [:type]
+      end
+
+      def matches?(value)
+        return allow_nil_rule(value) if strict == :allow_nil
+        if type == TrueClass || type == FalseClass
+          boolean_matches?(value)
+        elsif value.kind_of?(Array)
+          array_matches?(value)
+        else
+          value.kind_of?(type)
+        end
+      end
+
+      private
+
+      def allow_nil_rule(value)
+        return true if value.nil?
+        value.kind_of?(type)
+      end
+
+      def extract_options(options)
+        @type        = options.fetch(:type)
+        @member_type = options.fetch(:member_type, nil)
+        @strict      = options.fetch(:strict, :high)
+        assert_options_value
+      end
+
+      def assert_options_value
+        raise InvalidOptionError, "Strict option only accept [:high, :allow_nil]" unless [:high, :allow_nil].include?(strict)
+      end
+
+      def boolean_matches?(value)
+        value.equal?(true) || value.equal?(false)
+      end
+
+      def array_matches?(value)
+        if member_type
+          value.kind_of?(Array) && value.all? { |v| v.kind_of?(member_type) }
+        else
+          value.kind_of?(Array)
+        end
+      end
+    end
+  end
+end

data/lib/yema/validations.rb

@@ -0,0 +1,30 @@
+module Yema
+  module Validations
+
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def rules
+      self.class.rules
+    end
+
+    def errors
+      Set.new.tap do |errors|
+        rules.each { |rule| errors.merge(rule.errors(self)) }
+      end
+    end
+
+    module ClassMethods
+      def rules
+        @rules ||= Registry::Rule.new
+      end
+    end
+
+  end
+end