dozuki 0.0.1

data/spec/dozuki/xml/node_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+module Dozuki::XML
+  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)}
+      it "should be proxied to the nokogiri node" do
+        nokogiri_node.should_receive(:blah)
+        subject.blah
+      end
+      it "should be proxied to the nokogiri node with args" do
+        args  = [1,2,3]
+        nokogiri_node.should_receive(:blah).with(*args)
+        subject.blah(*args)
+      end
+      it "should be proxied to the nokogiri node with blocks" do
+        blk = Proc.new{}
+        nokogiri_node.should_receive(:blah).with(&blk)
+        subject.blah(&blk)
+      end
+    end    
+    
+    describe "responding to nokogiri's methods" do
+      let(:nokogiri_node){mock("nokogiri node")}
+      let(:node){Node.new(nokogiri_node)}
+      subject{node.respond_to?(:something_silly)}
+      context "where nokogiri responds to the method" do
+        before(:each){nokogiri_node.stub(:respond_to?).with(:something_silly).and_return(true)}
+        it "should return true" do
+          subject.should be_true
+        end
+      end
+      context "where nokogiri responds to the method" do
+        before(:each){nokogiri_node.stub(:respond_to?).with(:something_silly).and_return(false)}
+        it "should return true" do
+          subject.should be_false
+        end
+      end
+    end
+    
+    describe "each" do
+      let(:nokogiri_node)   {mock("nokogiri_node")}
+      let(:xpath)           {"/some/xpath"}
+      let(:node)            {Node.new(nokogiri_node)}
+      let(:blk)             {Proc.new {}}
+      let(:collection)      {mock "node set"}
+      let(:node_collection) {mock "node_collection"}
+      before(:each) do
+        nokogiri_node.stub(:xpath).and_return(collection)
+        NodeCollection.stub(:new).and_return(node_collection)
+
+      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)
+        end
+        subject{ node.each(xpath, &blk)}
+        it "should call to_node on the node_collection with the passed block" do
+          node_collection.should_receive(:as_node).with(&blk)
+          subject
+        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)
+      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)
+        subject
+      end
+      it "should return the parsed result" do
+        subject.should == parsed
+      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)
+        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)
+      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)
+        subject
+      end
+      it "should return the parsed result" do
+        subject.should == parsed
+      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)
+        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)
+      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)
+        subject
+      end
+      it "should return the parsed result" do
+        subject.should == parsed
+      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)
+        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
+      end
+      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)
+        end
+      end
+      context "where a block is passed" do
+        subject{node.get(xpath, &blk)}
+        it "should call the block with the node" do
+          node.get(xpath) do |block_node|
+            block_node.nokogiri_node.should == wanted_node
+          end
+        end
+      end
+    end
+    
+    describe "exists?" do
+      let(:nokogiri_node)   { mock("nokogiri_node") }
+      let(:xpath)           { "/some/xpath" }
+      let(:node)            { Node.new(nokogiri_node) }
+      let(:xpath_result)    {["something"]}
+      before(:each) do
+        nokogiri_node.stub(:xpath).and_return(xpath_result)
+      end
+      subject{ node.exists?(xpath) }
+      it "should get the xpath from the nokogiri_node" do
+        nokogiri_node.should_receive(:xpath).with(xpath)
+        subject
+      end
+      it "should return true for a non-empty node" do
+        subject.should be_true
+      end
+      context "where the results are not empty?" do
+        let(:xpath_result){[]}
+        it "should return false for an empty set" do
+          subject.should be_false
+        end
+      end
+    end
+    
+  end
+end

data/spec/dozuki/xml/parser_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Dozuki
+  module XML
+    describe Parser do
+      describe "to_text" do
+        let(:string){"something"}
+        let(:node){mock "node", :text => string}
+        subject{Parser.to_string(node)}
+        it "should get the text" do
+          subject.should == "something"
+        end
+        context "where the string has whitespace" do
+          let(:string){"\n\nsomething"}
+          it "should strip the whitespace" do
+            subject.should == "something"
+          end
+        end
+      end
+      describe "to_int" do
+        let(:string){"2"}
+        let(:node){mock "node", :text => string}
+        subject{Parser.to_int(node)}
+        it "should get the integer" do
+          subject.should == 2
+        end
+        context "where the string has whitespace" do
+          let(:string){"\n\n2"}
+          it "should strip the whitespace" do
+            subject.should == 2
+          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)
+            end
+          end
+          context "where there are dots" do
+            let(:string){"0.4"}
+            it "should raise an error" do
+              expect{subject}.to raise_error(InvalidFormat)
+            end
+          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
+          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)
+            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

data/spec/dozuki/xml_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Dozuki
+  describe XML do
+    
+    describe "parse" do
+      let(:string)        {"<lall><some xml='true' /></lall>"}
+      let(:nokogiri_node) {mock "nokogiri node"}
+      let(:dozuki_xml_node)  {mock "dozuki xml node"}
+      before(:each) do
+        Nokogiri::XML.stub(:parse).and_return(nokogiri_node)
+        XML::Node.stub(:new).and_return(dozuki_xml_node)
+      end
+      subject{XML.parse(string)}
+      it "should parse the xml using nokogiri" do
+        Nokogiri::XML.should_receive(:parse).with(string)
+        subject
+      end
+      it "should create a new Node with the nokogiri doc" do
+        XML::Node.should_receive(:new).with(nokogiri_node)
+        subject
+      end
+      it "should return the new node" do
+        subject.should == dozuki_xml_node
+      end
+    end
+    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require File.join(File.dirname(__FILE__),'../lib/dozuki')

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: dozuki
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Almond
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-31 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: A simple way of extracting various elements from an XML document using XPaths
+email: 
+- james@jamesalmond.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- dozuki.gemspec
+- features/each_accessor.feature
+- features/exists_accessor.feature
+- features/float_accessor.feature
+- features/get_accessor.feature
+- features/int_accessor.feature
+- features/steps/xml_steps.rb
+- features/string_accessor.feature
+- features/support/env.rb
+- lib/dozuki.rb
+- lib/dozuki/version.rb
+- lib/dozuki/xml.rb
+- lib/dozuki/xml/exceptions.rb
+- lib/dozuki/xml/node.rb
+- lib/dozuki/xml/node_collection.rb
+- lib/dozuki/xml/parser.rb
+- spec/dozuki/xml/node_collection_spec.rb
+- spec/dozuki/xml/node_spec.rb
+- spec/dozuki/xml/parser_spec.rb
+- spec/dozuki/xml_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/jamesalmond/dozuki
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: dozuki
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An XPath syntactic sugar wrapper for Nokogiri
+test_files: 
+- .autotest
+- features/each_accessor.feature
+- features/exists_accessor.feature
+- features/float_accessor.feature
+- features/get_accessor.feature
+- features/int_accessor.feature
+- features/steps/xml_steps.rb
+- features/string_accessor.feature
+- features/support/env.rb
+- spec/dozuki/xml/node_collection_spec.rb
+- spec/dozuki/xml/node_spec.rb
+- spec/dozuki/xml/parser_spec.rb
+- spec/dozuki/xml_spec.rb
+- spec/spec_helper.rb