muffins 0.0.5 → 0.0.6

data/spec/muffins/document_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Muffins::Document do
+
+  subject { described_class.new(:body => body) }
+
+  context "HTML" do
+
+    let(:body) { fixture_file("books.html") }
+    let(:path) { ".book" }
+
+    describe "#all" do
+      it "returns 2 objects" do
+        subject.all(path).size.should eql(2)
+      end
+    end
+
+    describe "#first" do
+      it "returns a string" do
+        subject.first(path).should be_a(String)
+      end
+    end
+
+  end
+
+  context "XML" do
+
+    let(:body) { fixture_file("books.xml") }
+    let(:path) { "book" }
+
+    describe "#all" do
+      it "returns 2 objects" do
+        subject.all(path).size.should eql(2)
+      end
+    end
+
+    describe "#first" do
+      it "returns an element" do
+        subject.first(path).should be_a(String)
+      end
+    end
+
+  end
+
+
+end

data/spec/muffins/mapping_parent_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Muffins::MappingParent do
+
+  class Book
+    include Muffins
+  end
+
+  subject { Muffins::MappingParent.new(options) }
+
+  let(:options) do
+    { :path  => path,
+      :klass => klass }
+  end
+
+  let(:klass) { Book    }
+  let(:path)  { "#book" }
+
+  let(:name) { :foo }
+  let(:type) { String }
+  let(:opts) { {} }
+
+  its(:klass) { should eql(klass) }
+  its(:path)  { should eql(path) }
+
+  describe "#map" do
+    it "initializes a namespaced mapping" do
+      subject.map(name, type, opts)
+      klass.send(:mappings).first.within.should == path
+    end
+  end
+
+end

data/spec/muffins/mapping_spec.rb

@@ -1,280 +1,43 @@
 require 'spec_helper'
 
-module Muffins
-  class Book
-    include Muffins
-  end
-
-  describe Mapping do
-
-    let(:name)    { :foo }
-    let(:options) { {} }
-
-    let(:document) { mock(Nokogiri::XML::Document) }
-
-    let(:node)     { mock(Nokogiri::XML::Node) }
-    let(:nodes)    { [node] }
-
-    let(:value)    { 'bar' }
-    let(:values)   { [value] }
-
-    subject { Mapping.new(name, options) }
-
-    describe "#map" do
-      before(:each) do
-        subject.stub(:typecast).with(node).and_return(value)
-      end
-
-      context "#collection? returns true" do
-        before(:each) do
-          subject.stub(:collection?).and_return(true)
-
-          document.stub(:css).and_return(nodes)
-        end
-
-        it "typecasts the parsed values" do
-          subject.should_receive(:typecast).with(node).and_return(value)
-          subject.map(document)
-        end
-
-        it "returns an array of typecasted values" do
-          subject.map(document).should == values
-        end
-      end
-
-      context "#collection? returns false" do
-        before(:each) do
-          subject.stub(:collection?).and_return(false)
-
-          document.stub(:at_css).and_return(node)
-        end
-
-        it "typecasts the parsed value" do
-          subject.should_receive(:typecast).with(node).and_return(value)
-          subject.map(document)
-        end
-
-        it "returns the typecasted value" do
-          subject.map(document).should == value
-        end
-      end
-    end
-
-    describe "#path" do
-      context "no options are passed" do
-        it "returns the mapping name" do
-          subject.path.should == name
-        end
-      end
+describe Muffins::Mapping do
 
-      context "options[:to] is passed" do
-        let(:to)    { 'bar' }
-        let(:options) { {:to => to} }
+  subject { described_class.new(options) }
 
-        before(:each) do
-          subject.stub(:options).and_return(options)
-        end
+  let(:name)       { :foo }
+  let(:type)       { String }
+  let(:to)         { ".book > .title" }
+  let(:within)     { "#books" }
+  let(:collection) { false }
 
-        it "returns the passed path name" do
-          subject.path.should == to
-        end
-      end
+  let(:document)   { fixture_file("books.html") }
 
-      context "options[:within] is passed" do
-        let(:within) { 'parent' }
-        let(:to)     { 'child' }
-
-        let(:options) { {:within => within, :to => to} }
+  let(:options) do
+    { :name       => name,
+      :type       => type,
+      :to         => to,
+      :within     => within,
+      :collection => collection }
+  end
 
-        before(:each) do
-          subject.stub(:options).and_return(options)
-        end
+  its(:absolute_path) { should eql("#books > .book > .title") }
+  its(:relative_path) { should eql(".book > .title") }
 
-        it "returns the css selector with parent and child" do
-          subject.path.should == "#{within} > #{to}"
-        end
-      end
+  describe "#coerce" do
+    it "coerces to the set type" do
+      subject.coerce(1).should be_a(String)
     end
+  end
 
-    describe "#collection?" do
-      context "options[:collection] is nil" do
-        it "returns false" do
-          subject.collection?.should be_false
-        end
-      end
-
-      context "options[:collection] is false" do
-
-        let(:options) { {:collection => false} }
-
-        before(:each) do
-          subject.stub(:options).and_return(options)
-        end
-
-        it "returns false" do
-          subject.collection?.should be_false
-        end
-      end
-
-      context "options[:collection] is true" do
-
-        let(:options) { {:collection => true} }
-
-        before(:each) do
-          subject.stub(:options).and_return(options)
-        end
-
-        it "returns true" do
-          subject.collection?.should be_true
-        end
-      end
+  describe "#parse" do
+    context "when collection is false" do
+      it { subject.parse(document).should eql("War and Peace (Vintage Classics)") }
     end
 
-    describe "#primitive?" do
-    end
-
-    describe "#typecast" do
-
-      before(:each) do
-        node.stub(:try).with(:text).and_return(value)
-
-        subject.stub(:options).and_return(options)
-      end
-
-      context "#primitive? returns true" do
-
-        before(:each) do
-          subject.stub(:primitive?).and_return(true)
-        end
-
-        context "options[:type] = String" do
-          let(:options) { {:type => String} }
-
-          it "returns an instance of String" do
-            subject.typecast(node).should be_a(String)
-          end
-        end
-
-        context "options[:type] = Float" do
-          let(:options) { {:type => Float} }
-          let(:value)   { '10.01' }
-
-          it "returns an instance of Float" do
-            subject.typecast(node).should be_a(Float)
-          end
-        end
-
-        context "options[:type] = Time" do
-          let(:options) { {:type => Time} }
-
-          let(:value)   { '00:00:00 -0700' }
-
-          it "returns an instance of Time" do
-            subject.typecast(node).should be_a(Time)
-          end
-        end
-
-        context "options[:type] = Date" do
-          let(:options) { {:type => Date} }
-
-          let(:value)   { '2011-01-01' }
-
-          it "returns an instance of Date" do
-            subject.typecast(node).should be_a(Date)
-          end
-        end
-
-        context "options[:type] = DateTime" do
-          let(:options) { {:type => DateTime} }
-
-          let(:value)   { '2011-01-01 00:00:00 -0700' }
-
-          it "returns an instance of DateTime" do
-            subject.typecast(node).should be_a(DateTime)
-          end
-        end
-
-        context "options[:type] = Integer" do
-          let(:options) { {:type => Integer} }
-
-          let(:value)   { '12908234' }
-
-          it "returns an instance of Integer" do
-            subject.typecast(node).should be_a(Integer)
-          end
-        end
-
-        context "options[:type] = Boolean" do
-          let(:options) { {:type => Boolean} }
-
-          context "value = 't'" do
-
-            let(:value)   { 't' }
-
-            it "returns true" do
-              subject.typecast(node).should be_true
-            end
-          end
-
-          context "value = 'true'" do
-            
-            let(:value)   { 'true' }
-
-            it "returns true" do
-              subject.typecast(node).should be_true
-            end
-          end
-
-          context "value = '1'" do
-            
-            let(:value)   { '1' }
-
-            it "returns true" do
-              subject.typecast(node).should be_true
-            end
-          end
-
-          context "value = '0'" do
-            
-            let(:value)   { '0' }
-
-            it "returns false" do
-              subject.typecast(node).should be_false
-            end
-          end
-
-          context "value = 'false'" do
-            
-            let(:value)   { 'false' }
-
-            it "returns false" do
-              subject.typecast(node).should be_false
-            end
-          end
-
-          context "value = 'f'" do
-            
-            let(:value)   { 'f' }
-
-            it "returns false" do
-              subject.typecast(node).should be_false
-            end
-          end
-        end
-      end
-
-      context "#primitive? returns false" do
-        let(:options) { {:type => Book} }
-
-        before(:each) do
-          subject.stub(:primitive?).and_return(false)
-        end
-
-        it "attempts to parse the nested set" do
-          Book.should_receive(:parse).with(node)
-          subject.typecast(node)
-        end
-      end
+    context "when collection is true" do
+      let(:collection) { true }
+      it { subject.parse(document).should eql([ "War and Peace (Vintage Classics)", "Anna Karenina (Oprah's Book Club)" ])}
     end
   end
-end
+
+end

data/spec/muffins_spec.rb

@@ -2,127 +2,67 @@ require 'spec_helper'
 
 describe Muffins do
 
-  context "when included in a class" do
+  class Book
+    include Muffins
 
-    subject do
-      class Book
-        include Muffins
-      end
-    end
-
-    let(:book) { mock(Book) }
-
-    let(:mapping)         { mock(Muffins::Mapping) }
-    let(:mapping_name)    { :foo }
-    let(:mapping_options) { {} }
-
-
-    describe ".mappings" do
-      it "returns an array" do
-        subject.mappings.should be_an(Array)
-      end
-    end
-
-    describe ".base_path" do
-      context "value is passed" do
-        it "sets @base_path to the passed value" do
-          subject.base_path('book')
-          subject.instance_variable_get(:@base_path).should == 'book'
-        end
-      end
+    path ".book"
+  end
 
-      context "no value is passed" do
-        it "returns the value of @base_path" do
-          subject.instance_variable_set(:@base_path, 'book')
-          subject.base_path.should == 'book'
-        end
-      end
-    end
+  subject { Book }
 
-    describe ".parse" do
-      let(:document)  { mock(Nokogiri::XML::Document) }
-      let(:node)      { mock(Nokogiri::XML::Node) }
+  let(:book) { Book.new }
 
-      let(:nodes)     { [node] }
+  let(:name)    { :foo   }
+  let(:type)    { String }
 
-      let(:base_path) { 'book' }
-      let(:mappings)  { [mapping] }
+  let(:mapping)  { mock(Muffins::Mapping) }
+  let(:mappings) { [] }
 
-      let(:mapping_value) { 'bar' }
+  describe ".parse" do
 
-      before(:each) do
-        subject.stub(:base_path).and_return(base_path)
-        subject.stub(:new).and_return(book)
-        subject.stub(:mappings).and_return(mappings)
+    let(:document) { fixture_file("books.html") }
 
-        book.stub("#{mapping_name}=")
+    it "parses a document based on the path" do
+      subject.parse(document).count.should == 2
+    end
 
-        document.stub(:css).with(base_path).and_return(nodes)
+  end
 
-        mapping.stub(:name).and_return(mapping_name)
-        mapping.stub(:map).with(node).and_return(mapping_value)
+  describe ".within" do
+    it "yields an instance of MappingParent" do
+      subject.within(name) do |parent|
+        parent.should be_a(Muffins::MappingParent)
       end
+    end
+  end
 
-      it "sets klass#method_name to the mapped node value" do
-        book.should_receive("#{mapping_name}=").with(mapping_value)
-        subject.parse(document)
-      end
+  describe ".map" do
 
-      it "returns an array of klasses" do
-        subject.parse(document).should == [book]
-      end
+    before do
+      Muffins::Mapping.stub(:new).and_return(mapping)
+      subject.stub(:mappings).and_return(mappings)
     end
 
-    describe ".within" do
-      it "yields an instance of Muffins::MappingDecorator" do
-        subject.within :foo do |foo|
-          foo.should be_a(Muffins::MappingDecorator)
-        end
-      end
+    it "initializes a new Mapping" do
+      Muffins::Mapping.should_receive(:new).with(:name => name, :type => type)
+      subject.map(name, type)
     end
 
-    describe ".map" do
-
-      let(:mappings)        { [] }
-
-      before(:each) do
-        Muffins::Mapping.stub(:new)
-          .with(mapping_name, mapping_options)
-          .and_return(mapping)
-
-
-        book.stub(:respond_to?).with(mapping_name)
-        subject.stub(:new).and_return(book)
-
-        subject.stub(:mappings).and_return(mappings)
-      end
-
-      it "adds a new instance of Muffins::Mapping to .mappings" do
-        mappings.should_receive(:<<).with(mapping)
-        subject.map mapping_name, mapping_options
-      end
-
-      context "the mapping name is not a defined method" do
-        before(:each) do
-          book.stub(:respond_to?).with(mapping_name).and_return(false)
-        end
-
-        it "defines an attr_accessor for the mapping name" do
-          subject.should_receive(:attr_accessor).with(mapping_name)
-          subject.map mapping_name
-        end
-      end
+    it "adds a mapping to the list of mappings" do
+      mappings.should_receive(:<<).with(mapping)
+      subject.map(name, type)
+    end
 
-      context "the mapping name is already a defined method" do
-        before(:each) do
-          book.stub(:respond_to?).with(mapping_name).and_return(true)
-        end
+    it "creates a getter method for :foo" do
+      subject.map(name, type)
+      book.should respond_to(name)
+    end
 
-        it "does not overwrite the existing method" do
-          subject.should_not_receive(:attr_accessor).with(mapping_name)
-          subject.map mapping_name
-        end
-      end
+    it "creates a setter method for :foo" do
+      subject.map(name, type)
+      book.should respond_to("#{name}=")
     end
+
   end
-end
+
+end