representable_matchers 0.2.0 → 0.2.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODljOTYyZDljNDE4ZWZjNzJkN2FkYzQ1MzYyMTJkY2VkN2JlYzM0NA==
+    YjNmNGE2OGI1YWM3OThiYTRhOGM5NDEwMjc2YmI1MGY4YjM2NWY0Zg==
   data.tar.gz: !binary |-
-    NTljNmZmMzMzMDhhMTdiNTRmYWQwMDc1OGM1YTU3MzJmNWExOGFhZQ==
+    ODk1MWQxOTQ4NGViZjMzNWY0NDExMzhlY2U4ODRkMzE3ZWE1YTIyNg==
 SHA512:
   metadata.gz: !binary |-
-    NDk4ZTViOTEzNzNmNjY4ZjVkMjEwOWYyZDExYWIwMTExMDBmMmQ4ZjU1MTNj
-    YTkxNGI4OTBlZTFhOWEyMTUzNzhkOGY1ZjliYjBmMjA1MzNkMzQ4YWM1NDA4
-    YTljYWE3OTc3MzQxMDc0M2Y5NjVhYmZhYzdmMDNjNzRhNWMyOTA=
+    MDI4M2MzYzczMWNiNGY3ZDJjYjU4MDNmODc2NzVhMTA3MzlmZmRmNjBjYzUw
+    ZGFlZGExNzQ0MGRiZGViMWJjNTRkZjY5MmVkZGI0ZTM5YmUyZjMxMTUyZDgx
+    YjFmMjBhNzg2NzlmNDQzN2IwZTE5NzEzMTdmNjMxZjEzNmNhMmQ=
   data.tar.gz: !binary |-
-    OTQzMzM0OWUyN2RkM2E2ZTYwOTAxYTliYWRjZjQwZWJiNjYxOThjMTdjMWRk
-    OTRiYzIwZWNiMDdlZjEzZDQ4YmM4NjMwNjI1Nzk1MDUzZTk1OTEwMWNlMDMy
-    YzFkNDYxNzRkMmMwMTA1YWM1NDJhNWQwMGRmYjViZThlNmUwNjg=
+    MDU5M2ZkNDU0OGFlNGExY2I3MzQzMjZjODg1NGFiMjNlMTk0ZjgwMGZiZTAw
+    ZDM5YmQ1NGNhYWIzYmJhMjJhZGFlYWNiOTk1NmJlM2RhNTc5Mjg5N2ZkMmIy
+    ZDU4OTkwYWVlZGJjMzYzZDZiNTljZDE1YmY0MGM3ODhlNmRiODk=

data/README.md

@@ -1,6 +1,6 @@
 # Representable Matchers
 
-[![Build Status](https://travis-ci.org/CodingZeal/representable_matchers.png?branch=master)](https://travis-ci.org/CodingZeal/representable_matchers) [![Code Climate](https://codeclimate.com/github/CodingZeal/representable_matchers.png)](https://codeclimate.com/github/CodingZeal/representable_matchers)
+[![Build Status](https://travis-ci.org/CodingZeal/representable_matchers.png?branch=master)](https://travis-ci.org/CodingZeal/representable_matchers) [![Code Climate](https://codeclimate.com/github/CodingZeal/representable_matchers.png)](https://codeclimate.com/github/CodingZeal/representable_matchers) [![Gem Version](https://badge.fury.io/rb/representable_matchers.png)](http://badge.fury.io/rb/representable_matchers)
 
 Shoulda-style RSpec/Test Unit matchers for the Representable Gem
 
@@ -21,10 +21,13 @@ Or install it yourself as:
 ## Usage
 
     it { should have_representable_property(:name) }
+    it { should have_representable_collection(:children) }
 
 With submatchers
 
     it { should have_representable_property(:name).class_name("String") }
+    it { should have_representable_property(:class_and_extension).class_name("Array").extends(AbstractRepresenter) }
+    it { should have_representable_collection(:children).class_name("Array").extends(AbstractRepresenter).parse_strategy(:sync) }
 
 ## Contributing
 

data/lib/matchers/base_matcher.rb

@@ -0,0 +1,63 @@
+module Representable
+  module Matchers
+    class BaseMatcher
+
+      def initialize(property)
+        @property = property
+      end
+
+      def class_name(class_name)
+        add_submatcher(ClassNameMatcher.new(@property, class_name))
+        self
+      end
+
+      def extends(extension)
+        add_submatcher(ExtensionOfMatcher.new(@property, extension))
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject
+        submatchers_match?
+      end
+
+      def description
+        ""
+      end
+
+      def failure_message_for_should
+        submatcher_failure_messages_for_should.last or raise "Undefined failure message for should"
+      end
+
+      def failure_message_for_should_not
+        submatcher_failure_messages_for_should_not.last or raise "Undefined failure message for should not"
+      end
+
+      private
+
+      def submatchers
+        @submatchers ||= []
+      end
+
+      def add_submatcher(submatcher)
+        submatchers << submatcher
+      end
+
+      def submatchers_match?
+        failing_submatchers.empty?
+      end
+
+      def failing_submatchers
+        @failing_submatchers ||= submatchers.select { |matcher| !matcher.matches?(@subject) }
+      end
+
+      def submatcher_failure_messages_for_should
+        failing_submatchers.map(&:failure_message_for_should)
+      end
+
+      def submatcher_failure_messages_for_should_not
+        failing_submatchers.map(&:failure_message_for_should_not)
+      end
+    end
+  end
+end

data/lib/matchers/extension_of_matcher.rb

@@ -0,0 +1,34 @@
+module Representable
+  module Matchers
+    
+    class ExtensionOfMatcher < Struct.new(:property, :extension)
+
+      def matches?(subject)
+        @subject = subject
+        matches_extension?
+      end
+
+      def description
+        "only allow representable properties extending specific representers"
+      end
+
+      def failure_message_for_should
+        "Expected #{expectation}"
+      end
+
+      def failure_message_for_should_not
+        "Did not expect #{expectation}"
+      end
+
+      private
+
+      def matches_extension?
+        @subject.send(:representable_attrs)[property].options[:extend] == extension
+      end
+
+      def expectation
+        "#{@subject.class} to be a representation of #{extension}"
+      end
+    end
+  end
+end

data/lib/matchers/have_representable_collection_matcher.rb

@@ -0,0 +1,31 @@
+module Representable
+  module Matchers
+
+    def have_representable_collection(property)
+      HaveRepresentableCollectionMatcher.new(property)
+    end
+
+    class HaveRepresentableCollectionMatcher < BaseMatcher
+
+      def initialize(property)
+        super(property)
+        add_representable_collection_submatcher
+      end
+
+      def parse_strategy(strategy)
+        add_submatcher(ParseStrategyMatcher.new(@property, strategy))
+        self
+      end
+
+      def description
+        "only allow properties being represented by Representable"
+      end
+
+      private
+
+      def add_representable_collection_submatcher
+        add_submatcher(RepresentableCollectionMatcher.new(@property))
+      end
+    end
+  end
+end

data/lib/matchers/have_representable_property_matcher.rb

@@ -5,38 +5,15 @@ module Representable
       HaveRepresentablePropertyMatcher.new(property)
     end
 
-    class HaveRepresentablePropertyMatcher
+    class HaveRepresentablePropertyMatcher < BaseMatcher
 
       def initialize(property)
-        @property = property
+        super(property)
         add_representable_property_submatcher
       end
 
-      def class_name(class_name)
-        add_submatcher(ClassNameMatcher.new(@property, class_name))
-        self
-      end
-
-      def extends(extension)
-        add_submatcher(ExtensionOfMatcher.new(@property, extension))
-        self
-      end
-
-      def matches?(subject)
-        @subject = subject
-        submatchers_match?
-      end
-
       def description
-        # TODO
-      end
-
-      def failure_message_for_should
-        submatcher_failure_messages_for_should.last
-      end
-
-      def failure_message_for_should_not
-        submatcher_failure_messages_for_should_not.last
+        "only allow properties being represented by Representable"
       end
 
       private
@@ -44,30 +21,6 @@ module Representable
       def add_representable_property_submatcher
         add_submatcher(RepresentablePropertyMatcher.new(@property))
       end
-
-      def submatchers
-        @submatchers ||= []
-      end
-
-      def add_submatcher(submatcher)
-        submatchers << submatcher
-      end
-
-      def submatchers_match?
-        failing_submatchers.empty?
-      end
-
-      def failing_submatchers
-        @failing_submatchers ||= submatchers.select { |matcher| !matcher.matches?(@subject) }
-      end
-
-      def submatcher_failure_messages_for_should
-        failing_submatchers.map(&:failure_message_for_should)
-      end
-
-      def submatcher_failure_messages_for_should_not
-        failing_submatchers.map(&:failure_message_for_should_not)
-      end
     end
   end
 end

data/lib/matchers/parse_strategy_matcher.rb

@@ -0,0 +1,34 @@
+module Representable
+  module Matchers
+
+    class ParseStrategyMatcher < Struct.new(:property, :strategy)
+
+      def matches?(subject)
+        @subject = subject
+        matches_strategy?
+      end
+
+      def description
+        "only allow representable collection to use a specific parse strategy"
+      end
+
+      def failure_message_for_should
+        "Expected #{expectation}"
+      end
+
+      def failure_message_for_should_not
+        "Did not expect #{expectation}"
+      end
+
+      private
+
+      def matches_strategy?
+        @subject.send(:representable_attrs)[property].options[:parse_strategy] == strategy
+      end
+
+      def expectation
+        "#{@subject.class} to be a kind of #{strategy}"
+      end
+    end
+  end
+end

data/lib/matchers/representable_collection_matcher.rb

@@ -0,0 +1,34 @@
+module Representable
+  module Matchers
+    
+    class RepresentableCollectionMatcher < Struct.new(:property)
+
+      def matches?(subject)
+        @subject = subject
+        collection?
+      end
+
+      def description
+        "only allow representable collection"
+      end
+
+      def failure_message_for_should
+        "Expected #{expectation}"
+      end
+
+      def failure_message_for_should_not
+        "Did not expect #{expectation}"
+      end
+
+      private
+
+      def collection?
+        @subject.send(:representable_attrs)[property].options[:collection] == true
+      end
+
+      def expectation
+        "#{@subject.class} to be a collection"
+      end
+    end
+  end
+end

data/lib/matchers/version.rb

@@ -1,5 +1,5 @@
 module Representable
   module Matchers
-    VERSION = "0.2.0"
+    VERSION = "0.2.2"
   end
 end

data/lib/representable_matchers.rb

@@ -1,3 +1,8 @@
 require "matchers/class_name_matcher"
+require "matchers/extension_of_matcher"
+require "matchers/parse_strategy_matcher"
+require "matchers/base_matcher"
 require "matchers/representable_property_matcher"
-require "matchers/have_representable_property_matcher"
+require "matchers/representable_collection_matcher"
+require "matchers/have_representable_property_matcher"
+require "matchers/have_representable_collection_matcher"

data/spec/matchers/base_matchers_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Representable::Matchers::BaseMatcher do
+  let(:property) { :foo }
+  let(:fake_matcher) { double("fake_matcher") }
+  let(:fake_representation) { double("fake_representation") }
+
+  subject { Representable::Matchers::BaseMatcher.new(property) }
+
+  describe "#matches?" do
+    it { expect( subject.matches?(fake_representation) ).to be_true }
+  end
+
+  describe "#class_name" do
+    let(:class_name) { "Foo" }
+
+    it "adds a ClassNameMatcher" do
+      Representable::Matchers::ClassNameMatcher.should_receive(:new).with(property, class_name)
+      expect( subject.class_name(class_name) ).to eq(subject)
+    end
+  end
+
+  describe "#extends" do
+    let(:extension) { Representable }
+
+    it "adds a ExtensionOfMatcher" do
+      Representable::Matchers::ExtensionOfMatcher.should_receive(:new).with(property, extension)
+      expect( subject.extends(extension) ).to eq(subject)
+    end
+  end
+
+  describe "#description" do
+    it { expect( subject.description ).to be_a_kind_of(String) }
+  end
+
+  describe "#failure_message_for_should" do
+    it { expect { subject.failure_message_for_should }.to raise_error }
+  end
+
+  describe "#failure_message_for_should" do
+    it { expect { subject.failure_message_for_should_not }.to raise_error }
+  end
+end

data/spec/matchers/class_name_matcher_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe Representable::Matchers::ClassNameMatcher do
+  it_should_behave_like "a matcher"
+ 
   let(:property) { :foo }
   let(:class_name) { "Person" }
 
@@ -28,10 +30,5 @@ describe Representable::Matchers::ClassNameMatcher do
         expect( subject.matches?(subject_object) ).to be_false
       end
     end
-    
   end
-
-  its(:description) { should be_a_kind_of String }
-  its(:failure_message_for_should) { should be_a_kind_of String }
-  its(:failure_message_for_should_not) { should be_a_kind_of String }
 end

data/spec/matchers/extension_of_matcher_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Representable::Matchers::ExtensionOfMatcher do
+  it_should_behave_like "a matcher"
+
+  let(:property) { :foo }
+  let(:extension) { Module }
+
+  subject { Representable::Matchers::ExtensionOfMatcher.new(property, extension) }
+
+  describe "#matches?" do
+    let(:fake_representation) { FakeRepresentable.representation }
+
+    context "when it matches" do
+
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[]).with(:extend).and_return(extension)
+      end
+
+      it do
+        expect( subject.matches?(fake_representation) ).to be_true
+      end
+    end
+
+    context "when it doesn't match" do
+
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[]).with(:extend).and_return(Representable)
+      end
+
+      it do
+        expect( subject.matches?(fake_representation) ).to be_false
+      end
+    end
+  end
+end

data/spec/matchers/have_representable_collection_matcher_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Representable::Matchers do
+  subject { FakeRepresentable.representation }
+
+  describe "#have_representable_collection" do
+    context "without submatchers" do
+      it { should have_representable_collection(:children) }
+    end
+
+    context "with submatchers" do
+      it { should have_representable_collection(:children).class_name("Array").extends(AbstractRepresenter).parse_strategy(:sync) }
+    end
+  end
+end
+  
+describe Representable::Matchers::HaveRepresentableCollectionMatcher do
+  let(:property) { :foo }
+  let(:fake_matcher) { double("fake_matcher") }
+  let(:fake_representation) { double("fake_representation") }
+
+  subject { Representable::Matchers::HaveRepresentableCollectionMatcher.new(property) }
+
+  before do
+    Representable::Matchers::RepresentableCollectionMatcher.should_receive(:new).with(property).and_return(fake_matcher)
+  end
+
+  describe "#parse_strategy" do
+    let(:parse_strategy) { :sync }
+
+    it "adds a ClassNameMatcher" do
+      Representable::Matchers::ParseStrategyMatcher.should_receive(:new).with(property, parse_strategy)
+      expect( subject.parse_strategy(parse_strategy) ).to eq(subject)
+    end
+  end
+
+  its(:description) { should be_a_kind_of String }
+end

data/spec/matchers/have_representable_property_matcher_spec.rb

@@ -1,16 +1,68 @@
 require "spec_helper"
+
+describe Representable::Matchers do
+  subject { FakeRepresentable.representation }
+  
+  describe "#have_representable_property" do  
+    context "without submatchers" do
+      it { should have_representable_property(:name) }
+      it { should_not have_representable_property(:foo) }
+    end
+
+    context "with submatchers" do
+      it { should have_representable_property(:class_only).class_name("String") }
+      it { should have_representable_property(:class_and_extension).class_name("Array").extends(AbstractRepresenter) }
+    end
+  end
+end
   
 describe Representable::Matchers::HaveRepresentablePropertyMatcher do
-  subject { FakeRepresentable.representation }
+  let(:property) { :foo }
+  let(:fake_matcher) { double("fake_matcher") }
+  let(:fake_representation) { double("fake_representation") }
+
+  subject { Representable::Matchers::HaveRepresentablePropertyMatcher.new(property) }
+
+  before do
+    Representable::Matchers::RepresentablePropertyMatcher.should_receive(:new).with(property).and_return(fake_matcher)
+    fake_matcher.stub(:matches?).and_return(true)
+  end
+
+  describe "#matches?" do
+    before do
+      fake_matcher.should_receive(:matches?).with(fake_representation).and_return(matches?)
+    end
+
+    context "when it matches" do
+      let(:matches?) { true }
+      it { expect( subject.matches?(fake_representation) ).to be_true }
+    end
+
+    context "when it doesn't match" do
+      let(:matches?) { false }
+      it { expect( subject.matches?(fake_representation) ).to be_false }
+    end
+  end
+
+  describe "#class_name" do
+    let(:class_name) { "Foo" }
 
-  it { should have_representable_property(:name) }
-  it { should_not have_representable_property(:foo) }
+    it "adds a ClassNameMatcher" do
+      Representable::Matchers::ClassNameMatcher.should_receive(:new).with(property, class_name)
+      expect( subject.class_name(class_name) ).to eq(subject)
+    end
+  end
 
-  describe "submatchers" do
+  describe "#extends" do
+    let(:extension) { Representable }
 
-    subject { FakeRepresentable.representation }
+    it "adds a ExtensionOfMatcher" do
+      Representable::Matchers::ExtensionOfMatcher.should_receive(:new).with(property, extension)
+      expect( subject.extends(extension) ).to eq(subject)
+    end
+  end
 
-    it { should have_representable_property(:class_only).class_name("String") }
-    it { should_not have_representable_property(:class_only).class_name("Foo") }
+  describe "#description" do
+    it { expect( subject.description ).to be_a_kind_of String }
   end
 end

data/spec/matchers/parse_strategy_matcher_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Representable::Matchers::ParseStrategyMatcher do
+  it_should_behave_like "a matcher"
+ 
+  let(:property) { :foo }
+  let(:strategy) { :sync }
+
+  subject { Representable::Matchers::ParseStrategyMatcher.new(property, strategy) }
+
+  describe "#matches?" do
+    let(:parse_strategy) { :sync }
+    let(:fake_representation) { double("fake_representation") }
+
+    context "when it matches" do
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[]).with(:parse_strategy).and_return(parse_strategy)
+      end
+
+      it "calls on the representable object for it's attributes" do
+        expect( subject.matches?(fake_representation) ).to be_true
+      end
+    end
+
+    context "when it doesn't match" do
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[], :to_s).and_return(:dont_sync)
+      end
+
+      it "calls on the representable object for it's attributes" do
+        expect( subject.matches?(fake_representation) ).to be_false
+      end
+    end
+  end
+end

data/spec/matchers/representable_attribute_matcher_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe Representable::Matchers::RepresentablePropertyMatcher do
+  it_should_behave_like "a matcher"
+
   let(:property) { :foo }
   subject { Representable::Matchers::RepresentablePropertyMatcher.new(property) }
 
@@ -27,8 +29,4 @@ describe Representable::Matchers::RepresentablePropertyMatcher do
       end
     end
   end
-
-  its(:description) { should be_a_kind_of String }
-  its(:failure_message_for_should) { should be_a_kind_of String }
-  its(:failure_message_for_should_not) { should be_a_kind_of String }
 end

data/spec/matchers/representable_collection_matcher_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Representable::Matchers::RepresentableCollectionMatcher do
+  it_should_behave_like "a matcher"
+
+  let(:property) { :foo }
+  let(:collection) { true }
+
+  subject { Representable::Matchers::RepresentableCollectionMatcher.new(property) }
+
+  describe "#matches?" do
+    let(:fake_representation) { FakeRepresentable.representation }
+
+    context "when it matches" do
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[]).with(:collection).and_return(collection)
+      end
+
+      it do
+        expect( subject.matches?(fake_representation) ).to be_true
+      end
+    end
+
+    context "when it doesn't match" do
+      let(:collection) { false }
+
+      before do
+        fake_representation.stub_chain(:send, :[], :options, :[]).with(:collection).and_return(collection)
+      end
+
+      it do
+        expect( subject.matches?(fake_representation) ).to be_false
+      end
+    end
+  end
+end

data/spec/support/fake_representable.rb

@@ -1,9 +1,13 @@
+module AbstractRepresenter
+end
+
 class FakeRepresentable
   module Representer
     include Representable::JSON
     property :name
     property :class_only, class: String
-    property :class_and_extension, class: Array
+    property :class_and_extension, class: Array, extend: AbstractRepresenter
+    collection :children, class: Array, extend: AbstractRepresenter, parse_strategy: :sync
   end
 
   def self.representation

data/spec/support/shared_examples.rb

@@ -0,0 +1,5 @@
+shared_examples "a matcher" do
+  its(:description) { should be_a_kind_of String }
+  its(:failure_message_for_should) { should be_a_kind_of String }
+  its(:failure_message_for_should_not) { should be_a_kind_of String }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: representable_matchers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Coding Zeal
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-08 00:00:00.000000000 Z
+date: 2013-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,19 +80,30 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/matchers/base_matcher.rb
 - lib/matchers/class_name_matcher.rb
+- lib/matchers/extension_of_matcher.rb
+- lib/matchers/have_representable_collection_matcher.rb
 - lib/matchers/have_representable_property_matcher.rb
+- lib/matchers/parse_strategy_matcher.rb
+- lib/matchers/representable_collection_matcher.rb
 - lib/matchers/representable_property_matcher.rb
 - lib/matchers/version.rb
 - lib/representable_matchers.rb
 - representable_matchers.gemspec
 - spec/integrations/rspec.rb
 - spec/integrations/test_unit.rb
+- spec/matchers/base_matchers_spec.rb
 - spec/matchers/class_name_matcher_spec.rb
+- spec/matchers/extension_of_matcher_spec.rb
+- spec/matchers/have_representable_collection_matcher_spec.rb
 - spec/matchers/have_representable_property_matcher_spec.rb
+- spec/matchers/parse_strategy_matcher_spec.rb
 - spec/matchers/representable_attribute_matcher_spec.rb
+- spec/matchers/representable_collection_matcher_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_representable.rb
+- spec/support/shared_examples.rb
 homepage: https://github.com/CodingZeal/representable_matchers
 licenses:
 - MIT
@@ -120,8 +131,14 @@ summary: Shoulda-style RSpec/Test Unit matchers for the Representable Gem
 test_files:
 - spec/integrations/rspec.rb
 - spec/integrations/test_unit.rb
+- spec/matchers/base_matchers_spec.rb
 - spec/matchers/class_name_matcher_spec.rb
+- spec/matchers/extension_of_matcher_spec.rb
+- spec/matchers/have_representable_collection_matcher_spec.rb
 - spec/matchers/have_representable_property_matcher_spec.rb
+- spec/matchers/parse_strategy_matcher_spec.rb
 - spec/matchers/representable_attribute_matcher_spec.rb
+- spec/matchers/representable_collection_matcher_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_representable.rb
+- spec/support/shared_examples.rb