dozuki 0.0.1 → 0.0.3

data/lib/dozuki/parsers.rb

@@ -0,0 +1,29 @@
+module Dozuki
+  module Parsers
+    module String
+      def self.parse(node)
+        node.text.strip
+      end
+    end
+    module Integer
+      def self.parse(node)
+        string = String.parse(node)
+        begin
+          Integer(string)
+        rescue ArgumentError
+          raise InvalidFormat.new(:node => node, :value => string, :format => "integer")
+        end
+      end
+    end
+    module Float
+      def self.parse(node)
+        string = String.parse(node)
+        begin
+          Float(string)
+        rescue ArgumentError
+          raise InvalidFormat.new(:node => node, :value => string, :format => "float")
+        end
+      end
+    end
+  end
+end

data/lib/dozuki/version.rb

@@ -1,3 +1,3 @@
 module Dozuki
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/dozuki/xml.rb

@@ -1,12 +1,7 @@
-require 'dozuki/xml/node'
-require 'dozuki/xml/node_collection'
-require 'dozuki/xml/parser'
-require 'dozuki/xml/exceptions'
-
 module Dozuki
   module XML
-    def self.parse(string)
-      Node.new(Nokogiri::XML.parse(string))
+    def self.parse(*args)
+      Node.new(Nokogiri::XML.parse(*args))
     end
   end
-end
+end

data/spec/dozuki/node_collection_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+module Dozuki
+  describe NodeCollection do
+
+    describe "as_node" do
+      let(:collection){mock "some_nodes"}
+      let(:blk){Proc.new{}}
+      let(:node_collection){NodeCollection.new(collection)}
+      let(:collection_item){mock "collection item"}
+      let(:new_node){mock "new node"}
+      before(:each) do
+        collection.stub(:each).and_yield(collection_item)
+        Node.stub(:new).and_return(new_node)
+      end
+
+      subject{node_collection.as_node(&blk)}
+
+      it "should iterate through the collection" do
+        collection.should_receive(:each)
+        subject
+      end
+      it "should create a new Node with the yielded collection item"  do
+        Node.should_receive(:new).with(collection_item)
+        subject
+      end
+      it "should call the bloc with the node" do
+        blk.should_receive(:call).with(new_node)
+        subject
+      end
+    end
+
+    describe "as_string" do
+      let(:collection){mock "some_nodes"}
+      let(:blk){Proc.new{}}
+      let(:node_collection){NodeCollection.new(collection)}
+      let(:collection_item){mock "collection item"}
+      let(:string){"string"}
+      before(:each) do
+        collection.stub(:each).and_yield(collection_item)
+        Dozuki::Parsers::String.stub(:parse).and_return(string)
+      end
+
+      subject{node_collection.as_string(&blk)}
+
+      it "should iterate through the collection" do
+        collection.should_receive(:each)
+        subject
+      end
+      it "should create a new Node with the yielded collection item"  do
+        Dozuki::Parsers::String.should_receive(:parse).with(collection_item)
+        subject
+      end
+      it "should call the bloc with the node" do
+        blk.should_receive(:call).with("string")
+        subject
+      end
+    end
+
+    describe "as_int" do
+      let(:collection){mock "some_nodes"}
+      let(:blk){Proc.new{}}
+      let(:node_collection){NodeCollection.new(collection)}
+      let(:collection_item){mock "collection item"}
+      let(:int){39}
+      before(:each) do
+        collection.stub(:each).and_yield(collection_item)
+        Dozuki::Parsers::Integer.stub(:parse).and_return(int)
+      end
+
+      subject{node_collection.as_int(&blk)}
+
+      it "should iterate through the collection" do
+        collection.should_receive(:each)
+        subject
+      end
+      it "should create a new Node with the yielded collection item"  do
+        Dozuki::Parsers::Integer.should_receive(:parse).with(collection_item)
+        subject
+      end
+      it "should call the bloc with the node" do
+        blk.should_receive(:call).with(int)
+        subject
+      end
+    end
+
+    describe "as_float" do
+      let(:collection){mock "some_nodes"}
+      let(:blk){Proc.new{}}
+      let(:node_collection){NodeCollection.new(collection)}
+      let(:collection_item){mock "collection item"}
+      let(:float){39.50}
+      before(:each) do
+        collection.stub(:each).and_yield(collection_item)
+        Dozuki::Parsers::Float.stub(:parse).and_return(float)
+      end
+
+      subject{node_collection.as_float(&blk)}
+
+      it "should iterate through the collection" do
+        collection.should_receive(:each)
+        subject
+      end
+      it "should create a new Node with the yielded collection item"  do
+        Dozuki::Parsers::Float.should_receive(:parse).with(collection_item)
+        subject
+      end
+      it "should call the bloc with the node" do
+        blk.should_receive(:call).with(float)
+        subject
+      end
+    end
+
+  end
+end

data/spec/dozuki/{xml/node_spec.rb → node_spec.rb}

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-module Dozuki::XML
+module Dozuki
   describe Node do
-    
+
     describe "initialization" do
       let(:nokogiri_node){mock("nokogiri_node")}
       subject{Node.new(nokogiri_node)}
       its(:nokogiri_node){should  == nokogiri_node}
     end
-    
+
     describe "missing methods" do
       let(:nokogiri_node){mock("nokogiri node")}
       subject{Node.new(nokogiri_node)}
@@ -26,8 +26,8 @@ module Dozuki::XML
         nokogiri_node.should_receive(:blah).with(&blk)
         subject.blah(&blk)
       end
-    end    
-    
+    end
+
     describe "responding to nokogiri's methods" do
       let(:nokogiri_node){mock("nokogiri node")}
       let(:node){Node.new(nokogiri_node)}
@@ -45,7 +45,7 @@ module Dozuki::XML
         end
       end
     end
-    
+
     describe "each" do
       let(:nokogiri_node)   {mock("nokogiri_node")}
       let(:xpath)           {"/some/xpath"}
@@ -59,21 +59,21 @@ module Dozuki::XML
 
       end
       subject{node.each(xpath)}
-      
+
       it "should get the collection from the nokogiri node" do
         nokogiri_node.should_receive(:xpath).with(xpath)
         subject
       end
-      
+
       it "should create a new NodeCollection with the collection" do
         NodeCollection.should_receive(:new).with(collection)
         subject
       end
-      
+
       it "should return the collection" do
         subject.should == node_collection
       end
-      
+
       context "where no block is passed" do
         before(:each) do
           node_collection.stub(:as_node).and_return(node_collection)
@@ -85,27 +85,27 @@ module Dozuki::XML
         end
       end
     end
-    
+
     describe "string" do
       let(:nokogiri_node)   { mock("nokogiri_node") }
       let(:xpath)           { "/some/xpath" }
       let(:node)            { Node.new(nokogiri_node) }
       let(:text_node)       { mock "some node" }
       let(:parsed)   { mock "parsed result" }
-      
+
       before(:each) do
         nokogiri_node.stub(:xpath).and_return([text_node])
-        Parser.stub(:to_string).and_return(parsed)
+        Dozuki::Parsers::String.stub(:parse).and_return(parsed)
       end
-      
+
       subject{ node.string(xpath) }
-      
+
       it "should get the collection from the nokogiri node" do
         nokogiri_node.should_receive(:xpath).with(xpath)
         subject
       end
       it "should parse the node to a string" do
-        Parser.should_receive(:to_string).with(text_node)
+        Dozuki::Parsers::String.should_receive(:parse).with(text_node)
         subject
       end
       it "should return the parsed result" do
@@ -116,31 +116,31 @@ module Dozuki::XML
           nokogiri_node.should_receive(:xpath).and_return([])
         end
         it "should raise a NotFound error" do
-          expect{subject}.to raise_error(NotFound)
+          expect{subject}.to raise_error(Dozuki::NotFound)
         end
       end
     end
-    
+
     describe "int" do
       let(:nokogiri_node)   { mock("nokogiri_node") }
       let(:xpath)           { "/some/xpath" }
       let(:node)            { Node.new(nokogiri_node) }
       let(:int_node)       { mock "some node" }
       let(:parsed)   { mock "parsed result" }
-      
+
       before(:each) do
         nokogiri_node.stub(:xpath).and_return([int_node])
-        Parser.stub(:to_int).and_return(parsed)
+        Dozuki::Parsers::Integer.stub(:parse).and_return(parsed)
       end
-      
+
       subject{ node.int(xpath) }
-      
+
       it "should get the collection from the nokogiri node" do
         nokogiri_node.should_receive(:xpath).with(xpath)
         subject
       end
       it "should parse the node to an int" do
-        Parser.should_receive(:to_int).with(int_node)
+        Dozuki::Parsers::Integer.should_receive(:parse).with(int_node)
         subject
       end
       it "should return the parsed result" do
@@ -151,31 +151,31 @@ module Dozuki::XML
           nokogiri_node.should_receive(:xpath).and_return([])
         end
         it "should raise a NotFound error" do
-          expect{subject}.to raise_error(NotFound)
+          expect{subject}.to raise_error(Dozuki::NotFound)
         end
       end
     end
-    
+
     describe "float" do
       let(:nokogiri_node)   { mock("nokogiri_node") }
       let(:xpath)           { "/some/xpath" }
       let(:node)            { Node.new(nokogiri_node) }
       let(:float_node)       { mock "some node" }
       let(:parsed)   { mock "parsed result" }
-      
+
       before(:each) do
         nokogiri_node.stub(:xpath).and_return([float_node])
-        Parser.stub(:to_float).and_return(parsed)
+        Dozuki::Parsers::Float.stub(:parse).and_return(parsed)
       end
-      
+
       subject{ node.float(xpath) }
-      
+
       it "should get the collection from the nokogiri node" do
         nokogiri_node.should_receive(:xpath).with(xpath)
         subject
       end
       it "should parse the node to an int" do
-        Parser.should_receive(:to_float).with(float_node)
+        Dozuki::Parsers::Float.should_receive(:parse).with(float_node)
         subject
       end
       it "should return the parsed result" do
@@ -186,23 +186,23 @@ module Dozuki::XML
           nokogiri_node.should_receive(:xpath).and_return([])
         end
         it "should raise a NotFound error" do
-          expect{subject}.to raise_error(NotFound)
+          expect{subject}.to raise_error(Dozuki::NotFound)
         end
       end
     end
-    
+
     describe "get" do
       let(:nokogiri_node)   { mock("nokogiri_node") }
       let(:xpath)           { "/some/xpath" }
       let(:node)            { Node.new(nokogiri_node) }
       let(:wanted_node)     { mock "some node" }
-      
+
       before(:each) do
         nokogiri_node.stub(:xpath).and_return([wanted_node])
       end
-      
+
       subject{ node.get(xpath) }
-      
+
       it "should get the collection from the nokogiri node" do
         nokogiri_node.should_receive(:xpath).with(xpath)
         subject
@@ -210,13 +210,13 @@ module Dozuki::XML
       it "should return the new dozuki node" do
         subject.nokogiri_node.should == wanted_node
       end
-      
+
       context "where the xpath returns no node" do
         before(:each) do
           nokogiri_node.should_receive(:xpath).and_return([])
         end
         it "should raise a NotFound error" do
-          expect{subject}.to raise_error(NotFound)
+          expect{subject}.to raise_error(Dozuki::NotFound)
         end
       end
       context "where a block is passed" do
@@ -228,7 +228,7 @@ module Dozuki::XML
         end
       end
     end
-    
+
     describe "exists?" do
       let(:nokogiri_node)   { mock("nokogiri_node") }
       let(:xpath)           { "/some/xpath" }
@@ -252,6 +252,6 @@ module Dozuki::XML
         end
       end
     end
-    
+
   end
-end
+end

data/spec/dozuki/{xml/parser_spec.rb → parsers_spec.rb}

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 module Dozuki
-  module XML
-    describe Parser do
-      describe "to_text" do
+  module Parsers
+    
+    describe String do
+      describe ".parse" do
         let(:string){"something"}
         let(:node){mock "node", :text => string}
-        subject{Parser.to_string(node)}
+        subject{String.parse(node)}
         it "should get the text" do
           subject.should == "something"
         end
@@ -17,10 +18,13 @@ module Dozuki
           end
         end
       end
-      describe "to_int" do
+    end
+
+    describe Integer do
+      describe ".parse" do
         let(:string){"2"}
         let(:node){mock "node", :text => string}
-        subject{Parser.to_int(node)}
+        subject{Integer.parse(node)}
         it "should get the integer" do
           subject.should == 2
         end
@@ -34,7 +38,7 @@ module Dozuki
           context "where there is characters in the string" do
             let(:string){"fjkdsk"}
             it "should raise an error" do
-              expect{subject}.to raise_error(InvalidFormat)
+              expect{subject}.to raise_error(InvalidFormat, "Cannot parse 'fjkdsk' to integer")
             end
           end
           context "where there are dots" do
@@ -45,34 +49,38 @@ module Dozuki
           end
         end
       end
-      describe "to_float" do
-        let(:string){"22.50"}
-        let(:node){mock "node", :text => string}
-        subject{Parser.to_float(node)}
-        it "should get the float" do
-          subject.should == 22.50
-        end
-        context "where the string has whitespace" do
-          let(:string){"\n\n22.59"}
-          it "should strip the whitespace" do
-            subject.should == 22.59
+
+      describe Float do
+        describe ".parse" do 
+          let(:string){"22.50"}
+          let(:node){mock "node", :text => string}
+          subject{Float.parse(node)}
+          it "should get the float" do
+            subject.should == 22.50
           end
-        end
-        context "where the string is badly formatted" do
-          context "where there is characters in the string" do
-            let(:string){"fjkdsk"}
-            it "should raise an error" do
-              expect{subject}.to raise_error(InvalidFormat)
+          context "where the string has whitespace" do
+            let(:string){"\n\n22.59"}
+            it "should strip the whitespace" do
+              subject.should == 22.59
             end
           end
-          context "where there are multiple dots" do
-            let(:string){"0.0.4"}
-            it "should raise an error" do
-              expect{subject}.to raise_error(InvalidFormat)
+          context "where the string is badly formatted" do
+            context "where there is characters in the string" do
+              let(:string){"fjkdsk"}
+              it "should raise an error" do
+                expect{subject}.to raise_error(InvalidFormat, "Cannot parse 'fjkdsk' to float")
+              end
+            end
+            context "where there are multiple dots" do
+              let(:string){"0.0.4"}
+              it "should raise an error" do
+                expect{subject}.to raise_error(InvalidFormat)
+              end
             end
           end
         end
       end
+
     end
   end
-end
+end