knight 0.0.1 → 0.0.2

data/lib/knight/version.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Knight
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/metrics/flog.yml

@@ -0,0 +1,2 @@
+---
+threshold: 9.7

data/metrics/rubocop.yml

@@ -0,0 +1,17 @@
+AllCops:
+  Includes:
+    - 'Rakefile'
+    - 'Gemfile'
+    - 'Gemfile.dev'
+    - 'Gemfile.local'
+    - '../**/*.rake'
+  Excludes:
+    - '**/bin/*'
+
+# Document classes and non-namespace modules.
+Documentation:
+  Enabled: false
+
+# Limit lines to 80 characters.
+LineLength:
+  Enabled: false

data/spec/integration/contextual_validator_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Knight do
+  subject { result.valid? }
+
+  let(:validator) do
+    Class.new do
+      include InstanceMethods
+      validator.add(Rule::Presence.new(:username))
+      validator.add(Rule::ExactLength.new(:username, 3..4), :registration)
+
+      validator.context :registration do |context|
+        context << Rule::Presence.new(:title)
+        context << Rule::ExactLength.new(:description, 40)
+      end
+    end
+  end
+
+  let(:user_class) do
+    Class.new do
+      attr_reader :username
+      def initialize(username)
+        @username = username
+      end
+    end
+  end
+
+  context 'valid' do
+    let(:result) { validator.new(resource).run }
+    let(:resource) { user_class.new('john') }
+    it { should be_true }
+  end
+
+  context 'invalid' do
+    let(:result) { validator.new(resource).run(:registration) }
+    let(:resource) { user_class.new('john') }
+    it { should be_false }
+  end
+end

data/spec/integration/knight_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Knight do
+  subject { result.valid? }
+
+  let(:result) { validator.new(resource).run }
+  let(:validator) do
+    Class.new do
+      include InstanceMethods
+      validator.add(Rule::Presence.new(:username))
+      validator.add(Rule::ExactLength.new(:username, 4))
+      validator.add(Rule::Inclusion.new(:username, %w(john bejo)))
+      validator.add(Rule::Format.new(:username, /\Ajo/))
+    end
+  end
+
+  let(:user_class) do
+    Class.new do
+      attr_reader :username
+      def initialize(username)
+        @username = username
+      end
+    end
+  end
+
+  let(:resource) { user_class.new('john') }
+  it { should be_true }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+require 'knight'
+include Knight
+

data/spec/unit/knight/error/class_methods/new_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Error, '.new' do
+  subject { described_class.new(rule, resource) }
+
+  let(:resource) { double('resource') }
+  let(:rule) { Rule::Presence.new(:foo) }
+
+  it { should be_instance_of(described_class) }
+
+  its(:rule) { should eql(rule) }
+  its(:resource) { should eql(resource) }
+end

data/spec/unit/knight/error/message_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Error, '#message' do
+  subject { object.message }
+
+  let(:object)   { described_class.new(rule, resource) }
+  let(:resource) { klass.new }
+  let(:klass) do
+    Class.new do
+      def foo
+        'ab'
+      end
+    end
+  end
+  let(:message) { '%{attribute} must between %{minimum}-%{maximum} characters, value: %{value}' }
+  let(:rule) { Rule::RangeLength.new(:foo, 3..5, message: message) }
+
+  it { should eql('foo must between 3-5 characters, value: ab') }
+
+  context 'with no attribute defined' do
+    let(:klass) { Class.new }
+    it { should eql('foo must between 3-5 characters, value: ') }
+  end
+end

data/spec/unit/knight/instance_methods/class_methods/included_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe InstanceMethods, '.included' do
+  subject { object }
+
+  let(:object) { described_class }
+  let(:klass)  { Class.new       }
+
+  it 'delegates to the ancestor' do
+    included_ancestor = false
+    mod = Module.new do
+      define_method(:included) { |_| included_ancestor = true }
+    end
+    subject.extend mod
+    expect { klass.send(:include, subject) }.to change { included_ancestor }.from(false).to(true)
+  end
+
+  it 'respond_to validator' do
+    klass.send(:include, subject)
+    expect(klass).to respond_to(:validator)
+  end
+end

data/spec/unit/knight/instance_methods/class_methods/new_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe InstanceMethods, '.new' do
+  subject { described_class.new(resource) }
+
+  let(:described_class) { Class.new { include InstanceMethods } }
+  let(:resource) { double('resource') }
+
+  its(:resource) { should eql(resource) }
+end

data/spec/unit/knight/instance_methods/class_methods/validator_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe InstanceMethods, '.validator' do
+  subject { described_class.validator }
+
+  let(:described_class) { Class.new { include InstanceMethods } }
+  let(:object) { described_class.new(double('1')) }
+
+  it { should be_instance_of(Validator) }
+  specify { expect(subject).to equal(object.class.validator) }
+end

data/spec/unit/knight/instance_methods/run_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe InstanceMethods, '.run' do
+  subject { object.run }
+
+  let(:described_class) do
+    Class.new do
+      include InstanceMethods
+      validator.add(Rule::Presence.new(:username))
+      validator.add(Rule::Presence.new(:title), :registration)
+    end
+  end
+  let(:object) { described_class.new(resource) }
+  let(:resource) { double('resource') }
+
+  context 'default context' do
+    subject { object.run }
+    specify { expect(subject.rules).to eql(described_class.validator.rules) }
+    specify { expect(subject.rules.size).to eql(1) }
+  end
+
+  context 'register context' do
+    subject { object.run(:registration) }
+    specify { expect(subject.rules).to eql(described_class.validator.rules(:registration)) }
+    specify { expect(subject.rules.size).to eql(1) }
+  end
+end

data/spec/unit/knight/result/class_methods/new_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Result, '.new' do
+  subject { described_class.new(resource, rules) }
+
+  let(:validator) { Validator.new(Rule::Presence.new(:title)) }
+  let(:rules) { validator.rules }
+  let(:resource) { double('resource') }
+
+  it { should be_instance_of(described_class) }
+end

data/spec/unit/knight/result/errors_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Result, '#errors' do
+  subject { result.errors }
+
+  let(:klass) do
+    Class.new do
+      attr_reader :foo
+      def initialize(foo)
+        @foo = foo
+      end
+    end
+  end
+  let(:validator) { Validator.new(*rules) }
+  let(:result) { validator.run(resource) }
+
+  context 'valid object' do
+    let(:resource) { klass.new('bar') }
+    let(:rules) { [Rule::Presence.new(:foo)] }
+    specify { expect(subject.size).to eql(0) }
+  end
+
+  context 'valid object' do
+    let(:resource) { Class.new }
+    let(:rules) { [Rule::ExactLength.new(:bar, 3)] }
+    specify { expect(subject.size).to eql(0) }
+  end
+
+  context 'multi rules on distinct attribute' do
+    let(:rules) do
+      [Rule::Presence.new(:foo), Rule::ExactLength.new(:bar, 3)]
+    end
+
+    context 'empty string' do
+      let(:resource) { klass.new('') }
+      specify { expect(subject.size).to eql(1) }
+      specify { expect(subject.first.rule).to be_instance_of(Rule::Presence) }
+    end
+
+    context 'invalid object' do
+      let(:resource) { Class.new }
+      specify { expect(subject.size).to eql(1) }
+      specify { expect(subject.first.rule).to be_instance_of(Rule::Presence) }
+    end
+  end
+
+  context 'multi rules on 1 attribute' do
+    let(:rules) do
+      [Rule::Presence.new(:foo), Rule::ExactLength.new(:foo, 3)]
+    end
+
+    context 'empty string' do
+      let(:resource) { klass.new('') }
+      specify { expect(subject.size).to eql(2) }
+    end
+
+    context 'invalid value' do
+      let(:resource) { klass.new('john') }
+      specify { expect(subject.size).to eql(1) }
+      specify { expect(subject.first.rule).to be_instance_of(Rule::ExactLength) }
+    end
+
+    context 'invalid object' do
+      let(:resource) { Class.new }
+      specify { expect(subject.size).to eql(1) }
+      specify { expect(subject.first.rule).to be_instance_of(Rule::Presence) }
+    end
+  end
+end

data/spec/unit/knight/result/valid_predicate_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Result, '#valid?' do
+  subject { result.valid? }
+
+  let(:klass) do
+    Class.new do
+      attr_reader :foo
+      def initialize(foo)
+        @foo = foo
+      end
+    end
+  end
+  let(:validator) { Validator.new(Rule::Presence.new(:foo)) }
+  let(:result) { validator.run(resource) }
+
+  context 'valid result' do
+    let(:resource) { klass.new('bar') }
+    it { should be_true }
+  end
+
+  context 'invalid result' do
+    let(:resource) { klass.new('') }
+    it { should be_false }
+  end
+end

data/spec/unit/knight/rule/class_methods/new_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule, '.new' do
+
+  {
+    Rule::Presence => "%{attribute} can't be blank"
+  }.each do |described_class, default_message|
+    context 'when called on the Rule subclass' do
+      let(:object)    { described_class }
+      let(:attribute) { :foo }
+      let(:options)   { { message: 'message' } }
+
+      context 'with options' do
+        subject { object.new(attribute, options) }
+
+        it { should be_instance_of(object) }
+        its(:attribute_name) { should eql(attribute) }
+        its(:options) { should eql(options) }
+        its(:message) { should eql('message') }
+      end
+
+      context 'with no options' do
+        subject { object.new(attribute) }
+
+        it { should be_instance_of(object) }
+        its(:options) { should be_empty }
+        its(:message) { should eql(default_message) }
+      end
+    end
+  end
+
+  context 'when called on the Rule class' do
+    subject { described_class.new(:foo) }
+    specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class} is an abstract type") }
+  end
+end

data/spec/unit/knight/rule/error_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule, '#error' do
+  subject { rule.error(resource) }
+
+  let(:klass) do
+    Class.new do
+      def foo
+        'value'
+      end
+    end
+  end
+  let(:rule) { Rule::Presence.new(:foo) }
+  let(:resource) { klass.new }
+
+  context 'not matched' do
+    before { rule.should_receive(:matches?).with('value').and_return(false) }
+
+    it { should eql(Error.new(rule, resource)) }
+  end
+
+  context 'matched' do
+    before { rule.should_receive(:matches?).with('value').and_return(true) }
+
+    it { should be_nil }
+  end
+end

data/spec/unit/knight/rule/exact_length/class_methods/new_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rule::ExactLength, '.new' do
+
+  let(:attribute) { :foo }
+  let(:length)    { 3 }
+  let(:options)   { { message: 'message' } }
+
+  context 'with options' do
+    subject { described_class.new(attribute, length, options) }
+
+    it { should be_instance_of(described_class) }
+    its(:attribute_name) { should eql(attribute) }
+    its(:length) { should eql(length) }
+    its(:options) { should eql(options) }
+  end
+
+  context 'with no options' do
+    subject { described_class.new(attribute, length) }
+
+    it { should be_instance_of(described_class) }
+    its(:options) { should be_empty }
+    its(:message) { should eql('%{attribute} has an invalid length') }
+  end
+end