remarkable 3.0.0

data/lib/remarkable/version.rb

@@ -0,0 +1,3 @@
+module Remarkable
+  VERSION = '3.0.0' unless self.const_defined?('VERSION')
+end

data/lib/remarkable.rb

@@ -0,0 +1,20 @@
+# Load core files
+dir = File.dirname(__FILE__)
+require File.join(dir, 'remarkable', 'version')
+require File.join(dir, 'remarkable', 'matchers')
+require File.join(dir, 'remarkable', 'i18n')
+require File.join(dir, 'remarkable', 'dsl')
+require File.join(dir, 'remarkable', 'messages')
+
+require File.join(dir, 'remarkable', 'base')
+require File.join(dir, 'remarkable', 'macros')
+require File.join(dir, 'remarkable', 'pending')
+require File.join(dir, 'remarkable', 'core_ext', 'array')
+
+# Loads rspec files only if spec is defined
+if defined?(Spec)
+  require File.join(dir, 'remarkable', 'rspec')
+end
+
+# Add Remarkable default locale file
+Remarkable.add_locale File.join(dir, '..', 'locale', 'en.yml')

data/locale/en.yml

@@ -0,0 +1,14 @@
+en:
+  remarkable:
+    core:
+      not: "not"
+      should: "should"
+      should_not: "should not"
+      example_disabled: "Example disabled"
+      failure_message_for_should: "Expected {{expectation}}"
+      failure_message_for_should_not: "Did not expect {{expectation}}"
+
+      helpers:
+        words_connector: ", "
+        two_words_connector: " and "
+        last_word_connector: ", and "

data/spec/base_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Remarkable::Base do
+  subject { [1, 2, 3] }
+
+  it 'should provide default structure to matchers' do
+    [1, 2, 3].should contain(1)
+    [1, 2, 3].should contain(1, 2)
+    [1, 2, 3].should contain(1, 2, 3)
+
+    [1, 2, 3].should_not contain(4)
+    [1, 2, 3].should_not contain(1, 4)
+  end
+
+  it 'should not change rspec matchers default behavior' do
+    should include(3)
+    [1, 2, 3].should include(3)
+
+    1.should == 1
+    true.should be_true
+    false.should be_false
+    proc{ 1 + '' }.should raise_error(TypeError)
+  end
+
+  it 'should store spec instance binding' do
+    matcher = contain(1)
+    should matcher
+    matcher.instance_variable_get('@spec').class.ancestors.should include(Spec::Example::ExampleGroup)
+  end
+
+  it { should contain(1) }
+  it { should_not contain(10) }
+
+  class MatchersSandbox
+    include Remarkable::Matchers
+  end
+
+  it 'should allow Macros and Matchers to be added to any class' do
+    MatchersSandbox.new.should respond_to(:contain)
+  end
+
+end

data/spec/dsl/assertions_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Remarkable::DSL::Assertions do
+  subject { [1, 2, 3] }
+
+  before(:each) do
+    @matcher = Remarkable::Specs::Matchers::CollectionContainMatcher.new(1, 2, 3)
+  end
+
+  it 'should provide default structure for assertions' do
+    should collection_contain(1)
+    should collection_contain(1, 2)
+    should collection_contain(1, 2, 3)
+
+    should_not collection_contain(4)
+    should_not collection_contain(1, 4)
+  end
+
+  it 'should provide default structure for single assertions' do
+    should single_contain(1)
+    should_not single_contain(4)
+    nil.should_not single_contain(1)
+  end
+
+  it 'should provide collection in description' do
+    @matcher.description.should == 'contain 1, 2, and 3'
+  end
+
+  it 'should provide value to expectation messages' do
+    @matcher.matches?([4])
+    @matcher.failure_message.should == 'Expected that 1 is included in [4]'
+  end
+
+  it 'should accept blocks as argument' do
+    should_not single_contain(4)
+    should single_contain(4){ |array| array << 4 }
+  end
+
+  it 'should provide an interface for default_options hook' do
+    matcher = Remarkable::Specs::Matchers::CollectionContainMatcher.new(1, :args => true)
+    matcher.instance_variable_get('@options').should == { :working => true, :args => true }
+  end
+
+  it 'should provide an interface for after_initialize hook' do
+    matcher = Remarkable::Specs::Matchers::CollectionContainMatcher.new(1)
+    matcher.instance_variable_get('@after_initialize').should be_true
+  end
+
+  it 'should provide an interface for before_assert hook' do
+    matcher = Remarkable::Specs::Matchers::CollectionContainMatcher.new(1)
+    [1, 2, 3].should matcher
+    matcher.instance_variable_get('@before_assert').should be_true
+  end
+end

data/spec/dsl/optionals_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Remarkable::DSL::Optionals do
+  before(:each) do
+    @matcher = Remarkable::Specs::Matchers::BeAPersonMatcher.new
+  end
+
+  it "should create optional methods on the fly" do
+    @matcher.first_name('José')
+    @matcher.instance_variable_get('@options')[:first_name].should == 'José'
+
+    @matcher.last_name('Valim')
+    @matcher.instance_variable_get('@options')[:last_name].should == 'Valim'
+  end
+
+  it "should allow defaults values" do
+    @matcher.age
+    @matcher.instance_variable_get('@options')[:age].should == 18
+  end
+
+  it "should allow alias to be set" do
+    @matcher.family_name('Valim')
+    @matcher.instance_variable_get('@options')[:last_name].should == 'Valim'
+  end
+
+  it 'should provide a description with optionals' do
+    @matcher = Remarkable::Specs::Matchers::SingleContainMatcher.new(1)
+    @matcher.description.should == 'contain 1 not checking for blank'
+
+    @matcher.allow_blank(10)
+    @matcher.description.should == 'contain 1 with blank equal 10'
+
+    @matcher.allow_blank(true)
+    @matcher.description.should == 'contain 1 with blank equal true'
+
+    @matcher.allow_nil(true)
+    @matcher.description.should == 'contain 1 allowing nil and with blank equal true'
+
+    @matcher.allow_nil(false)
+    @matcher.description.should == 'contain 1 not allowing nil and with blank equal true'
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Remarkable::I18n do
+  subject { [1, 2, 3] }
+
+  before(:all) do
+    Remarkable.locale = :"pt-BR"
+  end
+
+  it 'should have a locale apart from I18n' do
+    I18n.locale.should_not == Remarkable.locale
+  end
+
+  it 'should delegate translate to I18n API overwriting the default locale' do
+    ::I18n.should_receive(:translate).with('remarkable.core.not', :locale => :"pt-BR").and_return('translated')
+    Remarkable.t('remarkable.core.not').should == 'translated'
+  end
+
+  it 'should delegate localize to I18n API overwriting the default locale' do
+    ::I18n.should_receive(:localize).with('remarkable.core.not', :locale => :"pt-BR").and_return('localized')
+    Remarkable.l('remarkable.core.not').should == 'localized'
+  end
+
+  it 'should delegate add_locale to I18n backend' do
+    backend = mock(::I18n::Backend)
+    ::I18n.should_receive(:backend).and_return(backend)
+    backend.should_receive(:load_translations).with('a', 'b', 'c')
+
+    Remarkable.add_locale('a', 'b', 'c')
+  end
+
+  after(:all) do
+    Remarkable.locale = :en
+  end
+
+  Remarkable.locale = :"pt-BR"
+  should_collection_contain(1)
+  should_not_collection_contain(4)
+  xshould_not_collection_contain(5)
+  Remarkable.locale = :en
+end

data/spec/locale/en.yml

@@ -0,0 +1,19 @@
+en:
+  remarkable:
+    specs:
+      contain:
+        description: "contain the given values"
+      single_contain:
+        description: "contain {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil"
+            negative: "not allowing nil"
+          allow_blank:
+            positive: "with blank equal {{inspect}}"
+            not_given: "not checking for blank"
+      collection_contain:
+        description: "contain {{values}}"
+        expectations:
+          included: "{{more}}{{value}} is included in {{subject_inspect}}"
+          is_array?: "subject is a array, but got {{subject_name}}"

data/spec/locale/pt-BR.yml

@@ -0,0 +1,21 @@
+pt-BR:
+  remarkable:
+    core:
+      not: não
+      should: deve
+      should_not: não deve
+      example_disabled: Exemplo desativado
+      failure_message_for_should: Esperava que {{expectation}}
+      failure_message_for_should_not: Não esperava que {{expectation}}
+
+      helpers:
+        words_connector: ', '
+        two_words_connector: ' e '
+        last_word_connector: ' e '
+
+    specs:
+      collection_contain:
+        description: "conter os valores fornecidos"
+        expectations:
+          included: "{{value}} estivesse incluso em {{subject_inspect}}"
+          is_array?: "valor dado é um array, mas é {{subject_name}}"

data/spec/macros_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Remarkable::Macros do
+  subject { [1, 2, 3] }
+
+  should_contain(1)
+  should_contain(1, 2)
+  should_contain(1, 2, 3)
+
+  should_not_contain(4)
+  should_not_contain(1, 4)
+
+  describe "with disabled examples" do
+    # Example disabled without parameters to ensure rescue works properly
+    xshould_not_single_contain
+    xshould_contain(5)
+    xshould_not_contain(1)
+  end
+
+  describe "with blocks" do
+    subject { [1, 2, 3] }
+
+    should_not_single_contain(4)
+    should_single_contain(4){ |array| array << 4 }
+  end
+end

data/spec/matchers/be_a_person_matcher.rb

@@ -0,0 +1,25 @@
+module Remarkable
+  module Specs
+    module Matchers
+      class BeAPersonMatcher < Remarkable::Base
+        arguments
+
+        optional :first_name
+        optional :age, :default => 18
+        optional :last_name, :alias => :family_name
+
+        def description
+          "be a person"
+        end
+
+        def expectation
+          "is not a person"
+        end
+      end
+
+      def be_a_person(*args, &block)
+        BeAPersonMatcher.new(*args, &block).spec(self)
+      end
+    end
+  end
+end

data/spec/matchers/collection_contain_matcher.rb

@@ -0,0 +1,32 @@
+module Remarkable
+  module Specs
+    module Matchers
+      class CollectionContainMatcher < Remarkable::Base
+        arguments :collection => :values, :as => :value
+
+        optional :working
+        default_options :working => true
+
+        assertion :is_array? do
+          @subject.is_a?(Array)
+        end
+
+        collection_assertion :included? do
+          return @subject.include?(@value), :more => 'that '
+        end
+
+        after_initialize do
+          @after_initialize = true
+        end
+
+        before_assert do
+          @before_assert = true
+        end
+      end
+
+      def collection_contain(*args)
+        CollectionContainMatcher.new(*args).spec(self)
+      end
+    end
+  end
+end

data/spec/matchers/contain_matcher.rb

@@ -0,0 +1,31 @@
+module Remarkable
+  module Specs
+    module Matchers
+      class ContainMatcher < Remarkable::Base
+        def initialize(*values)
+          @values = values
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@values) do |value|
+            @value = value
+            included?
+          end
+        end
+
+        def included?
+          return true if @subject.include?(@value)
+
+          @expectation = "#{@value} is included in #{@subject.inspect}"
+          false
+        end
+      end
+
+      def contain(*args)
+        ContainMatcher.new(*args).spec(self)
+      end
+    end
+  end
+end

data/spec/matchers/single_contain_matcher.rb

@@ -0,0 +1,50 @@
+module Remarkable
+  module Specs
+    module Matchers
+      class SingleContainMatcher < Remarkable::Base
+        arguments :value, :block => :iterator
+
+        assertions :is_array?, :included?
+
+        optional :allow_nil
+        optional :allow_blank
+
+        after_initialize :set_after_initialize
+
+        before_assert do
+          @before_assert = true
+          @iterator.call(@subject) if @iterator
+        end
+
+        protected
+
+          def included?
+            return true if @subject.include?(@value)
+
+            @expectation = "#{@value} is not included in #{@subject.inspect}"
+            false
+          end
+
+          def is_array?
+            return true if @subject.is_a?(Array)
+
+            @expectation = "subject is a #{subject_name}"
+            false
+          end
+
+          def default_options
+            { :working => true }
+          end
+
+          def set_after_initialize
+            @after_initialize = true
+          end
+
+      end
+
+      def single_contain(*args, &block)
+        SingleContainMatcher.new(*args, &block).spec(self)
+      end
+    end
+  end
+end

data/spec/messages_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Remarkable::Messages do
+  subject { [1, 2, 3] }
+
+  describe 'without I18n' do
+    before(:each) do
+      @matcher = Remarkable::Specs::Matchers::ContainMatcher.new(1, 2, 3)
+    end
+
+    it 'should provide a description' do
+      @matcher.description.should == 'contain the given values'
+    end
+
+    it 'should provide a failure message' do
+      @matcher.matches?([4])
+      @matcher.failure_message.should == 'Expected 1 is included in [4]'
+    end
+
+    it 'should provide a negative failure message' do
+      @matcher.matches?([1])
+      @matcher.negative_failure_message.should == 'Did not expect 2 is included in [1]'
+    end
+
+    it 'should provide a not word' do
+      @matcher.send(:not_word).should == 'not '
+    end
+  end
+
+  describe 'with I18n' do
+    before(:all) do
+      Remarkable.locale = :"pt-BR"
+    end
+
+    before(:each) do
+      @matcher = Remarkable::Specs::Matchers::CollectionContainMatcher.new(1, 2, 3)
+    end
+
+    it 'should provide a default i18n scope' do
+      @matcher.send(:matcher_i18n_scope).should == 'remarkable.specs.collection_contain'
+    end
+
+    it 'should provide a translated description' do
+      @matcher.description.should == 'conter os valores fornecidos'
+    end
+
+    it 'should provide a translated failure message' do
+      @matcher.matches?([4])
+      @matcher.failure_message.should == 'Esperava que 1 estivesse incluso em [4]'
+    end
+
+    it 'should provide a translated negative failure message' do
+      @matcher.matches?([1])
+      @matcher.negative_failure_message.should == 'Não esperava que 2 estivesse incluso em [1]'
+    end
+
+    it 'should provide an i18n not word' do
+      @matcher.send(:not_word).should == 'não '
+    end
+
+    after(:all) do
+      Remarkable.locale = :en
+    end
+  end
+end