dozuki 0.0.1 → 0.0.3

data/features/get_accessor.feature

@@ -2,9 +2,9 @@ Feature: Getting nodes from the document
   In order to provide a unified interface to the xml objects
   As a traverser
   I want to access nodes using the get method and an xpath
-  
-  Scenario: getting a single node
-    When I parse the XML:
+
+  Background:
+    Given I have parsed the XML:
       """
         <root>
           <name>St. George's Arms</name>
@@ -16,53 +16,24 @@ Feature: Getting nodes from the document
           </rooms>
         </root>
       """
-    And I call "get('//rooms')" on the document
-    Then the result should be a "Dozuki::XML::Node"
+
+  Scenario: getting a single node
+    When I call "get('//rooms')" on the document
+    Then the result should be a "Dozuki::Node"
     And the result should have 2 elements
 
-  Scenario: getting a single node but accessing it with a block
-    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>
-          <rooms>
-            <room>SINGLE</room>
-            <room>Double</room>
-          </rooms>
-        </root>
-      """
-    And I call "get('//rooms')" on the document with a block
-    Then the block parameter should be a "Dozuki::XML::Node"
-    And the parameter should have 2 elements
-    
   Scenario: getting the first of multiple nodes
-    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>
-          <rooms>
-            <room>SINGLE</room>
-            <room>Double</room>
-          </rooms>
-        </root>
-      """
-    And I call "get('//rooms/room')" on the document
+    When I call "get('//rooms/room')" on the document
     Then the result should have the text "SINGLE"
-    
+
+  Scenario: getting a single node but accessing it with a block
+    When I call "get('//rooms')" on the document with a block
+    Then the block parameter should be a "Dozuki::Node"
+    And the parameter should have 2 elements
+
   Scenario: getting 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 "get('//something/missing')" on the document should raise a "NotFound" error
+    When I call "get('//something/missing')" on the document
+    Then it should raise a "NotFound" error
     And the error should have the xpath "//something/missing"
     And the error should have a stored node
-    And the error should have a stored node
+    And the error should have a stored node

data/features/int_accessor.feature

@@ -2,42 +2,36 @@ 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:
+
+  Background:
+    Given I have parsed the XML:
       """
         <root>
           <name>St. George's Arms</name>
           <average_price>20.32</average_price>
           <number_of_beers>2</number_of_beers>
+          <number_of_ciders>
+            5
+          </number_of_ciders>
         </root>
       """
-    And I call "int('/root/number_of_beers')" on the document
+
+  Scenario: getting the int of a single node
+    When 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
-    
+    When I call "int('/root/number_of_ciders')" on the document
+    Then the result should be 5
+
+  Scenario: getting the int of a node that doesn't contain an int
+    When I call "int('/root/name')" on the document
+    Then it should raise an "InvalidFormat" error
+    And the error should have the value "St. George's Arms"
+    And the error should have the format "integer"
+
   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
+    When I call "int('//something/missing')" on the document
+    Then it should raise a "NotFound" error
     And the error should have the xpath "//something/missing"
-    And the error should have a stored node
+    And the error should have a stored node

data/features/steps/collection_steps.rb

@@ -0,0 +1,11 @@
+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/steps/error_steps.rb

@@ -0,0 +1,11 @@
+Then /^it should raise an? "([^"]*)" error$/ do |error|
+  @error.should be_a Dozuki.const_get(error)
+end
+
+Then /^the error should have the (\w+) "([^"]*)"$/ do |method, value|
+  @error.send(method).should == value
+end
+
+Then /^the error should have a stored node$/ do
+  @error.node.should_not be_nil
+end

data/features/steps/format_steps.rb

@@ -0,0 +1,19 @@
+Then /^the result should be "([^"]*)"$/ do |string|
+  @result.should == string
+end
+
+Then /^the result should be (\d+)$/ do |int|
+  @result.should == int.to_i
+end
+
+Then /^the result should be (\d+\.\d+)$/ do |float|
+  @result.should == float.to_f
+end
+
+Then /^the result should be true$/ do
+  @result.should == true
+end
+
+Then /^the result should be false$/ do
+  @result.should == false
+end

data/features/steps/xml_steps.rb

@@ -1,32 +1,15 @@
-When /^I parse the XML:$/ do |string|
+When /^I (?:have )?parsed? 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|
+When /^I call "([^"]*)" on the document$/ do |code|
   begin
-    @doc.instance_eval(code)
-    fail "Expected error #{error}, nothing raised"
-  rescue Dozuki::XML.const_get(error) => e
+    @result = @doc.instance_eval(code)
+  rescue StandardError => 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
@@ -35,30 +18,10 @@ 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
@@ -70,15 +33,3 @@ 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

@@ -2,40 +2,29 @@ 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:
+
+  Background:
+    Given I have parsed the XML:
       """
         <root>
           <name>St. George's Arms</name>
-          <average_cost>20.32</average_cost>
+          <address>
+            1 Main Street
+          </address>
           <number_of_beers>2</number_of_beers>
         </root>
       """
-    And I call "string('/root/name')" on the document
+
+  Scenario: getting the string of a single node
+    When 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"
-    
+    When I call "string('/root/address')" on the document
+    Then the result should be "1 Main Street"
+
   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
+    When I call "string('//something/missing')" on the document
+    Then it should raise a "NotFound" error
     And the error should have the xpath "//something/missing"
-    And the error should have a stored node
+    And the error should have a stored node

data/lib/dozuki.rb

@@ -1,3 +1,7 @@
 require 'nokogiri'
 
-require 'dozuki/xml'
+require 'dozuki/exceptions'
+require 'dozuki/parsers'
+require 'dozuki/node'
+require 'dozuki/node_collection'
+require 'dozuki/xml'

data/lib/dozuki/exceptions.rb

@@ -0,0 +1,23 @@
+module Dozuki
+  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(opts={})
+      super "Cannot parse '#{opts[:value]}' to #{opts[:format]}"
+      self.format = opts[:format]
+      self.node = opts[:node]
+      self.value = opts[:value]
+    end
+  end
+end

data/lib/dozuki/node.rb

@@ -0,0 +1,53 @@
+require 'dozuki/parsers'
+module Dozuki
+  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)
+      Parsers::String.parse(get_first_node(xpath))
+    end
+
+    def int(xpath)
+      Parsers::Integer.parse(get_first_node(xpath))
+    end
+
+    def float(xpath)
+      Parsers::Float.parse(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

data/lib/dozuki/node_collection.rb

@@ -0,0 +1,25 @@
+module Dozuki
+  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(Parsers::String.parse(item))}
+    end
+
+    def as_int(&blk)
+      collection.each{|item| blk.call(Parsers::Integer.parse(item))}
+    end
+
+    def as_float(&blk)
+      collection.each{|item| blk.call(Parsers::Float.parse(item))}
+    end
+  end
+end