dozuki 0.0.1

data/features/int_accessor.feature

@@ -0,0 +1,43 @@
+Feature: Getting integers from the document
+  In order to provide simpler way of getting integers from a node
+  As a traverser
+  I want to access nodes using the int method and an xpath
+  
+  Scenario: getting the int of a single node
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_price>20.32</average_price>
+          <number_of_beers>2</number_of_beers>
+        </root>
+      """
+    And I call "int('/root/number_of_beers')" on the document
+    Then the result should be 2
+    
+  Scenario: getting the int of a single node with whitespace
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_price>20.32</average_price>
+          <number_of_beers>
+            2
+          </number_of_beers>
+        </root>
+      """
+    And I call "int('/root/number_of_beers')" on the document
+    Then the result should be 2
+    
+  Scenario: getting the int of a non-existent node
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_price>20.32</average_price>
+          <number_of_beers>2</number_of_beers>
+        </root>
+      """
+    Then calling "int('//something/missing')" on the document should raise a "NotFound" error
+    And the error should have the xpath "//something/missing"
+    And the error should have a stored node

data/features/steps/xml_steps.rb

@@ -0,0 +1,84 @@
+When /^I parse the XML:$/ do |string|
+  @doc = Dozuki::XML.parse(string)
+end
+
+Then /^the float result should be (\d+\.\d+)$/ do |float|
+  @result.should == float.to_f
+end
+
+Then /^the error should have the xpath "([^"]*)"$/ do |xpath|
+  @error.xpath.should == xpath
+end
+
+Then /^the error should have a stored node$/ do
+  @error.node.should_not be_nil
+end
+
+Then /^calling "([^"]*)" on the document should raise a "([^"]*)" error$/ do |code, error|
+  begin
+    @doc.instance_eval(code)
+    fail "Expected error #{error}, nothing raised"
+  rescue Dozuki::XML.const_get(error) => e
+    @error = e
+  end
+end
+
+When /^I call "([^"]*)" on the document$/ do |code|
+  @result = @doc.instance_eval(code)
+end
+
+When /^I call "([^"]*)" on the document with a block$/ do |code|
+  @result = @doc.instance_eval(code + "{|res| res}") # returns the variable passed to the block
+end
+
+When /^I call "([^"]*)" on the document and collect the results$/ do |code|
+  @results = @doc.instance_eval("results = [];" + code + "{|res| results << res}; results;")
+end
+
+Then /^the result should be (\d+)$/ do |int|
+  @result.should == int.to_i
+end
+
+Then /^the result should be "([^"]*)"$/ do |string|
+  @result.should == string
+end
+
+Then /^the result should be (\d+\.\d+)$/ do |float|
+  @result.should == float.to_f
+end
+
+Then /^the (?:result|block parameter) should be a "([^"]*)"$/ do |type|
+  @result.class.to_s.should == type
+end
+
+Then /^the result should be true$/ do
+  @result.should be_true
+end
+
+Then /^the result should be false$/ do
+  @result.should be_false
+end
+
+Then /^the (?:result|parameter) should have (\d+) elements$/ do |count|
+  @result.children.select{|e| e.is_a?(Nokogiri::XML::Element)}.count.should == count.to_i
+end
+
+Then /^the result should have the (.*) "([^"]*)"$/ do |method, value|
+  @result.send(method).should == value
+end
+
+Then /^the results should contain a node with the text "([^"]*)"$/ do |text|
+  @results.any?{|n| n.text == text}.should be_true
+end
+
+Then /^the results should contain "([^"]*)"$/ do |string|
+  @results.should include(string)
+end
+
+Then /^the results should contain (\d+)$/ do |int|
+  @results.should include(int.to_i)
+end
+
+Then /^the results should contain (\d+\.\d+)$/ do |float|
+  @results.should include(float.to_f)
+end

data/features/string_accessor.feature

@@ -0,0 +1,41 @@
+Feature: Getting strings from the document
+  In order to provide simpler way of getting strings from a node
+  As a traverser
+  I want to access nodes using the string method and an xpath
+  
+  Scenario: getting the string of a single node
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_cost>20.32</average_cost>
+          <number_of_beers>2</number_of_beers>
+        </root>
+      """
+    And I call "string('/root/name')" on the document
+    Then the result should be "St. George's Arms"
+    
+  Scenario: getting the text of a single node with whitespace
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_cost>20.32</average_cost>
+          <number_of_beers>2</number_of_beers>
+        </root>
+      """
+    And I call "string('/root/name')" on the document
+    Then the result should be "St. George's Arms"
+    
+  Scenario: getting a non-existent node
+    When I parse the XML:
+      """
+        <root>
+          <name>St. George's Arms</name>
+          <average_cost>20.32</average_cost>
+          <number_of_beers>2</number_of_beers>
+        </root>
+      """
+    Then calling "string('//something/missing')" on the document should raise a "NotFound" error
+    And the error should have the xpath "//something/missing"
+    And the error should have a stored node

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'dozuki'

data/lib/dozuki.rb

@@ -0,0 +1,3 @@
+require 'nokogiri'
+
+require 'dozuki/xml'

data/lib/dozuki/version.rb

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

data/lib/dozuki/xml.rb

@@ -0,0 +1,12 @@
+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))
+    end
+  end
+end

data/lib/dozuki/xml/exceptions.rb

@@ -0,0 +1,27 @@
+module Dozuki
+  module XML
+    
+    class NotFound < StandardError
+      attr_accessor :xpath, :node
+      
+      def initialize(msg=nil, opts={})
+        super msg
+        self.xpath = opts[:xpath]
+        self.node = opts[:node]
+      end
+      
+    end
+    
+    class InvalidFormat < StandardError
+      attr_accessor :format, :node, :value
+      
+      def initialize(msg=nil, opts={})
+        super msg
+        self.format = opts[:format]
+        self.node = opts[:node]
+        self.value = opts[:value]
+      end  
+    end
+    
+  end
+end

data/lib/dozuki/xml/node.rb

@@ -0,0 +1,54 @@
+module Dozuki
+  module XML
+    class Node
+      attr_accessor :nokogiri_node
+      
+      def initialize(nokogiri_node)
+        self.nokogiri_node = nokogiri_node
+      end
+      
+      def method_missing(method, *args, &blk)
+        nokogiri_node.send(method, *args, &blk)
+      end
+      
+      def respond_to?(method)
+        nokogiri_node.respond_to?(method) ? true : super
+      end
+      
+      def each(xpath, &blk)
+        collection = NodeCollection.new(nokogiri_node.xpath(xpath))
+        block_given? ? collection.as_node(&blk) : collection
+      end
+      
+      def string(xpath)
+        Parser.to_string(get_first_node(xpath))
+      end
+      
+      def int(xpath)
+        Parser.to_int(get_first_node(xpath))
+      end
+      
+      def float(xpath)
+        Parser.to_float(get_first_node(xpath))
+      end
+      
+      def get(xpath)
+        node = Node.new(get_first_node(xpath))
+        yield node if block_given?
+        node
+      end
+      
+      def exists?(xpath)
+        !nokogiri_node.xpath(xpath).empty?
+      end
+      
+      private 
+        def get_first_node(xpath)
+          node = nokogiri_node.xpath(xpath)
+          raise NotFound.new("Node not found", :xpath => xpath, :node => nokogiri_node) if node.empty?
+          node.first
+        end
+        
+    end
+  end
+end

data/lib/dozuki/xml/node_collection.rb

@@ -0,0 +1,27 @@
+module Dozuki
+  module XML
+    class NodeCollection
+      attr_accessor :collection
+      
+      def initialize(collection)
+        self.collection = collection
+      end
+      
+      def as_node(&blk)
+        collection.each{|item| blk.call(Node.new(item))}
+      end
+      
+      def as_string(&blk)
+        collection.each{|item| blk.call(Parser.to_string(item))}
+      end
+      
+      def as_int(&blk)
+        collection.each{|item| blk.call(Parser.to_int(item))}
+      end
+      
+      def as_float(&blk)
+        collection.each{|item| blk.call(Parser.to_float(item))}
+      end
+    end
+  end
+end

data/lib/dozuki/xml/parser.rb

@@ -0,0 +1,23 @@
+module Dozuki
+  module XML
+    module Parser
+    
+      def self.to_string(node)
+        node.text.strip
+      end
+      
+      def self.to_int(node)
+        string = to_string(node)
+        raise InvalidFormat.new("Parsing error", :node => node, :value => string, :format => "int") unless string =~ /^-?[0-9]+$/
+        string.to_i
+      end
+      
+      def self.to_float(node)
+        string = to_string(node)
+        raise InvalidFormat.new("Parsing error", :node => node, :value => string, :format => "float") unless string =~ /^-?[0-9]+(\.[0-9]+)?$/
+        string.to_f
+      end
+      
+    end
+  end
+end

data/spec/dozuki/xml/node_collection_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+module Dozuki
+  module XML
+    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)
+          Parser.stub(:to_string).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
+          Parser.should_receive(:to_string).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)
+          Parser.stub(:to_int).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
+          Parser.should_receive(:to_int).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)
+          Parser.stub(:to_float).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
+          Parser.should_receive(:to_float).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
+end