yema 0.0.1

data/lib/yema/validator.rb

@@ -0,0 +1,25 @@
+module Yema
+  class Validator
+
+    attr_reader :rule, :resource
+
+    def initialize(rule, resource)
+      @rule, @resource = rule, resource
+    end
+
+    def value
+      resource.public_send(rule.attribute_name)
+    end
+
+    def valid?
+      rule.matches?(value)
+    end
+
+    def errors
+      errors = []
+      errors << Error.new(rule, resource) unless valid?
+      errors.to_set
+    end
+
+  end
+end

data/lib/yema/version.rb

@@ -0,0 +1,3 @@
+module Yema
+  VERSION = "0.0.1"
+end

data/lib/yema/virtus/attribute.rb

@@ -0,0 +1,48 @@
+module Yema
+  module Virtus
+    class Attribute
+
+      attr_reader :attribute
+      DEFAULT_BUILDERS  = [ Builder::StrongType, Builder::Required ].freeze
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def self.specific_builders
+        [].freeze
+      end
+
+      def self.builders
+        DEFAULT_BUILDERS + specific_builders
+      end
+
+      def rules
+        rules = []
+        self.class.builders.each do |builder|
+          rule = builder.new(attribute).build
+          rules << rule if rule
+        end
+        rules.to_set
+      end
+
+      def self.build(attribute)
+        klass = determine_type(attribute)
+        klass.new(attribute)
+      end
+
+      private
+
+      # TODO: find a better way for mapping virtus type
+      def self.determine_type(attribute)
+        if    attribute.kind_of?(::Virtus::Attribute::String);  self::String
+        elsif attribute.kind_of?(::Virtus::Attribute::Numeric); self::Numeric
+        elsif attribute.kind_of?(::Virtus::Attribute::Array);   self::Array
+        elsif attribute.kind_of?(::Virtus::Attribute::Boolean); self
+        else
+          raise TypeError, "#{attribute.class} is not supported"
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/attribute/array.rb

@@ -0,0 +1,12 @@
+module Yema
+  module Virtus
+    class Attribute
+      class Array < self
+
+        def self.specific_builders
+          super + [Builder::Length].freeze
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/attribute/numeric.rb

@@ -0,0 +1,12 @@
+module Yema
+  module Virtus
+    class Attribute
+      class Numeric < self
+
+        def self.specific_builders
+          super + [Builder::Inclusion].freeze
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/attribute/string.rb

@@ -0,0 +1,16 @@
+module Yema
+  module Virtus
+    class Attribute
+      class String < self
+
+        def self.specific_builders
+          super + [
+            Builder::Length,
+            Builder::Format,
+            Builder::Inclusion,
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/builder.rb

@@ -0,0 +1,17 @@
+module Yema
+  module Virtus
+    class Builder
+
+      attr_reader :attribute
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def options
+        attribute.options
+      end
+
+    end
+  end
+end

data/lib/yema/virtus/builder/format.rb

@@ -0,0 +1,13 @@
+module Yema
+  module Virtus
+    class Builder
+      class Format < self
+
+        def build
+          format = options.fetch(:format, false)
+          Rule::Format.new(attribute.name, format: format) if format
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/builder/inclusion.rb

@@ -0,0 +1,13 @@
+module Yema
+  module Virtus
+    class Builder
+      class Inclusion < self
+
+        def build
+          within = options.fetch(:within, false)
+          Rule::Inclusion.new(attribute.name, within: within) if within
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/builder/length.rb

@@ -0,0 +1,13 @@
+module Yema
+  module Virtus
+    class Builder
+      class Length < self
+
+        def build
+          length = options.fetch(:length, false)
+          Rule::Length.new(attribute.name, length: length) if length
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/builder/required.rb

@@ -0,0 +1,13 @@
+module Yema
+  module Virtus
+    class Builder
+      class Required < self
+
+        def build
+          required = options.fetch(:required, false)
+          Rule::Required.new(attribute.name) if required
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/builder/strong_type.rb

@@ -0,0 +1,18 @@
+module Yema
+  module Virtus
+    class Builder
+      class StrongType < self
+
+        def build
+          strict = options.fetch(:strict, :high)
+          unless strict == :none
+            Yema::Rule::StrongType.new(attribute.name,
+                                       type: attribute.class.primitive,
+                                       member_type: attribute.options[:member_type],
+                                       strict: strict)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yema/virtus/validations.rb

@@ -0,0 +1,28 @@
+module Yema
+  module Virtus
+    module Validations
+
+      def self.included(base)
+        base.instance_eval do
+          include ::Virtus::ValueObject
+          include Yema::Validations
+          extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+
+        private
+
+        def virtus_add_attribute(attribute)
+          super
+          build_validation(attribute)
+        end
+
+        def build_validation(attribute)
+          rules.merge(Yema::Virtus::Attribute.build(attribute).rules)
+        end
+      end
+    end
+  end
+end

data/spec/integration/rule/format_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Yema::Rule::Format, '#errors' do
+
+  subject { rule.errors(resource) }
+
+  let(:rule)      { described_class.new(attribute, options) }
+  let(:resource)  { stub('resource', attribute => value)    }
+  let(:attribute) { :foo                                    }
+  let(:options)   { { format: /foo/ }                       }
+
+  [
+    'foo',
+    'afoo',
+    'fooa',
+    'afooa',
+  ].each do |value|
+    it_behaves_like "valid resource", value
+  end
+
+  it_behaves_like "invalid resource", 'abcdds'
+
+end

data/spec/integration/rule/inclusion_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Yema::Rule::Inclusion, '#errors' do
+
+  subject { rule.errors(resource) }
+
+  let(:rule)      { described_class.new(attribute, options) }
+  let(:resource)  { stub('resource', attribute => value)    }
+  let(:attribute) { :foo                                    }
+
+  context "with range options" do
+    let(:options) { { within: 3..6 } }
+
+    [3, 5].each do |value|
+      it_behaves_like "valid resource", value
+    end
+
+    it_behaves_like "invalid resource", 2
+  end
+
+  context "with array options" do
+    let(:options) { { within: ["a", "b"] } }
+
+    it_behaves_like "valid resource", "a"
+    it_behaves_like "invalid resource", "c"
+  end
+
+end

data/spec/integration/rule/length_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Yema::Rule::Length, '#errors' do
+
+  subject { rule.errors(resource) }
+
+  let(:rule)      { described_class.new(attribute, options) }
+  let(:resource)  { stub('resource', attribute => value)    }
+  let(:attribute) { :foo                                    }
+  let(:options)   { { length: 5 }                           }
+
+  it_behaves_like "valid resource", "asdfg"
+  it_behaves_like "invalid resource", "longer_string"
+  it_behaves_like "invalid resource", ""
+
+  [
+    nil,
+    false,
+    true,
+    10000,
+  ].each do |value|
+    context "with invalid value: #{value.inspect}" do
+      let(:value) { value                                     }
+      specify     { expect{subject}.to raise_error(ArgumentError) }
+    end
+  end
+
+  context "when options is a range" do
+    let(:options) { { length: 3..6 } }
+
+    [
+      "abc",
+      "abcabc",
+    ].each do |value|
+      it_behaves_like "valid resource", value
+    end
+    it_behaves_like "invalid resource", "abcabca"
+  end
+
+end

data/spec/integration/rule/required_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Yema::Rule::Required, '#errors' do
+
+  subject { rule.errors(resource) }
+
+  let(:rule)      { described_class.new(attribute, options) }
+  let(:resource)  { stub('resource', attribute => value)    }
+  let(:attribute) { :foo                                    }
+  let(:options)   { {}                                      }
+
+  [
+    nil,
+    "",
+    {},
+    [],
+  ].each do |value|
+    it_behaves_like "invalid resource", value
+  end
+
+  it_behaves_like "valid resource", "bar"
+end

data/spec/integration/rule/strong_type_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Yema::Rule::StrongType, '#errors' do
+
+  subject { rule.errors(resource) }
+
+  let(:rule)      { described_class.new(attribute, options) }
+  let(:resource)  { stub('resource', attribute => value)    }
+  let(:attribute) { :foo                                    }
+  let(:options)   { {type: String}.merge(mode)              }
+  let(:mode)      { {}                                      }
+
+  context "allow_nil mode" do
+    let(:mode) { {strict: :allow_nil} }
+
+    it_behaves_like "valid resource", nil
+    it_behaves_like "invalid resource", 1
+    it_behaves_like "valid resource", 'string'
+  end
+
+  context "default mode" do
+    it_behaves_like "invalid resource", nil
+    it_behaves_like "invalid resource", 1
+    it_behaves_like "valid resource", 'string'
+  end
+
+end

data/spec/integration/virtus/combination_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe 'Combination' do
+
+  subject { described_class.new(value).errors }
+
+  let(:described_class) do
+    Class.new do
+      include Yema::Virtus::Validations
+      attribute :name,        String
+      attribute :username,    String,         required: true,      format: /langit/
+      attribute :salutation,  String,         within: ['mr', 'ms']
+      attribute :address,     String,         strict: :allow_nil
+      attribute :age,         Integer,        within: 1..26
+      attribute :height,      Integer,        required: false,     default: 173
+      attribute :active,      Virtus::Attribute::Boolean
+      attribute :pages,       Array[String],  length: 2..3
+      attribute :phones,      Array
+      self
+    end
+  end
+
+  it_behaves_like "valid resource", {
+    name: 'handi',
+    username: 'langitbiru',
+    salutation: 'mr',
+    age: '23',
+    active: false,
+    pages: [1, 2, '3a'],
+    phones: [1, 2, '3a'],
+  }
+
+  describe "check value" do
+    subject { described_class.new(value) }
+
+    let(:value) do
+      {
+        name: 'handi',
+        username: 'langitbiru',
+        salutation: 'mr',
+        age: '23',
+        pages: [1, 2, 3],
+        phones: [1, 2, 3],
+      }
+    end
+
+    its(:name)       { should eql('handi')      }
+    its(:username)   { should eql('langitbiru') }
+    its(:salutation) { should eql('mr')         }
+    its(:address)    { should be_nil            }
+    its(:age)        { should eql(23)           }
+    its(:height)     { should eql(173)          }
+    its(:active)     { should be_false          }
+    specify          { subject.pages.count.should eql(3)  }
+    specify          { subject.phones.count.should eql(3) }
+  end
+
+end