dusty-noko_parser 0.0.9 → 0.1.0

data/examples/monkey.rb

@@ -0,0 +1,51 @@
+module Fruits; end
+module Animals; end
+
+class Fruits::Banana
+  include NokoParser::Properties
+  nodes :xpath => '//banana'
+  
+  property :id, :xpath => 'id'
+  property :size, :xpath => 'size'
+  
+end
+
+
+class Animals::Monkey
+  include NokoParser::Properties
+  nodes :xpath => '//monkey'
+  
+  property :id, :xpath => '.', :attribute => 'id'
+
+  property :first_name, :xpath => 'contact/name[@type="first"]'
+  
+  property :last_name, :xpath => 'contact/name[@type="last"]'
+
+  property :age, :xpath => 'yrsold'
+        
+  property :funny, :xpath => 'personality', :attribute => :hilarious
+        
+  property :loud, :xpath => 'personality'
+        
+  property :street, :xpath => 'street'
+
+  property :city, :xpath => 'city'
+
+  property :state, :xpath => 'state'
+
+  property :zip, :xpath => 'zip'
+  
+  embed :bananas, :xpath => 'bananas', :class => 'Fruits::Banana'
+
+  def address
+    [street, city, state].compact.join(", ") + " #{zip}"
+  end
+  
+  def age
+    @age.to_i
+  end
+
+  def funny=(value)
+    @funny = (value == "true" ? true : false)
+  end
+end

data/examples/monkeys.xml

@@ -0,0 +1,52 @@
+<xml>
+  <animals>
+    <elephant id="3">
+      <name>elephant1</name>
+      <trunk>large</trunk>
+    </elephant>
+    <monkey id="1">
+      <contact>
+        <name type='first'>monkey1</name>
+        <name type='last'>monkeylastname</name>
+      </contact>
+      <bananas>
+        <banana>
+          <id>1</id>
+          <size>small</size>
+        </banana>
+        <banana>
+          <id>2</id>
+          <size>medium</size>
+        </banana>
+      </bananas>
+      <yrsold>23</yrsold>
+      <personality hilarious="true">quiet</personality>
+      <street>300 Monkey St</street>
+      <city>Cincinnati</city>
+      <state>Oh</state>
+      <zip>45219</zip>
+    </monkey>
+    <monkey id="2">
+      <contact>
+        <name type='first'>monkey2</name>
+        <name type='last'>monkeylastname</name>
+      </contact>
+      <bananas>
+        <banana>
+          <id>3</id>
+          <size>large</size>
+        </banana>
+        <banana>
+          <id>4</id>
+          <size>huge</size>
+        </banana>
+      </bananas>
+      <yrsold>33</yrsold>
+      <personality hilarious="false">loud</personality>
+      <street>301 Monkey St</street>
+      <city>Cincinnati</city>
+      <state>Oh</state>
+      <zip>45219</zip>
+    </monkey>
+  </animals>
+</xml>

data/lib/noko_parser.rb

@@ -0,0 +1,29 @@
+require 'nokogiri'
+
+module NokoParser
+  
+  class NokoParserError < StandardError; end
+
+  def self.version
+    "0.1.0"
+  end
+  
+end
+
+## Stolen from merb-core
+class Object
+  def full_const_get(name)
+    list = name.split("::")
+    list.shift if list.first.empty?
+    obj = self
+    list.each do |x| 
+      # This is required because const_get tries to look for constants in the 
+      # ancestor chain, but we only want constants that are HERE
+      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+    end
+    obj
+  end
+end
+
+require 'noko_parser/parser'
+require 'noko_parser/properties'

data/lib/noko_parser/parser.rb

@@ -0,0 +1,86 @@
+module NokoParser
+  
+  class Parser
+    
+    ##
+    # Initialize the parser by passing in a class that has included
+    # NokoParser::Properties
+    #
+    # @raises [NokoParserError] unless class included NokoParser::Properties
+    def initialize(klass, xml)
+      unless klass.respond_to?('_is_noko_parser?')
+        raise NokoParserError, 'Class must include NokoParser::Properties'
+      end
+      @object = klass
+      @xml = Nokogiri::XML(xml)
+      @nodes = []
+      @text_properties = klass._text_properties
+      @attribute_properties = klass._attribute_properties
+      @embedded_properties = klass._embedded_properties
+    end
+    
+    ##
+    # Runs the parser on the class.  First finds the nodes that match
+    # and then parses the text and attribute properties on it
+    #
+    # return [Array<Object>] an array of objects
+    def run
+      @xml.xpath(@object._nodes_xpath).each do |node|
+        object = @object.new
+        parse_text_properties(node,object)
+        parse_attribute_properties(node,object)
+        parse_embedded_properties(node,object)
+        @nodes << object
+      end
+      @nodes
+    end
+    
+    private
+    
+    ##
+    # Loop through the text properties of the class and use the defined
+    # xpath query to find the match.  If found add to the object using
+    # the setter.
+    def parse_text_properties(node,object)
+      @text_properties.each do |property|
+        if match = node.xpath(property.xpath).first
+          unless match.inner_text.empty?
+            object.send("#{property.name}=",match.inner_text)
+          end
+        end
+      end
+    end
+    
+    ##
+    # Loop through the attribute properties of the class and use the defined
+    # xpath query to find the match.  If found add to the object using
+    # the setter.
+    def parse_attribute_properties(node,object)
+      @attribute_properties.each do |property|
+        if match = node.xpath(property.xpath).first
+          object.send("#{property.name}=",match.attribute(property.attribute))
+        end
+      end
+    end
+    
+    ##
+    # Loop through the embedded properties of the class and use the defined
+    # xpath query to find the match.  If found add to the object using the
+    # setter.
+    def parse_embedded_properties(node,object)
+      @embedded_properties.each do |property|
+        unless parser = Object.full_const_get(property.class_name) rescue nil
+          raise NokoParserError, 
+          "Class #{property.class_name} not found for embed :#{property.name}"
+        end
+        if match = node.xpath(property.xpath).first
+          result = parser.parse(match.to_xml)
+          result = result.first if property.single
+          object.send("#{property.name}=", result)
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/noko_parser/properties.rb

@@ -0,0 +1,199 @@
+module NokoParser
+  
+  module Properties
+    
+    ##
+    # Text property is used to find the innerhtml of an element
+    class TextProperty
+      attr_reader :name, :xpath
+  
+      def initialize(name,xpath)
+        @name = name.to_s
+        @xpath = xpath.to_s
+      end
+  
+    end
+
+    ##
+    # Attribute property is used to find the value of an attribute of an
+    # element
+    class AttributeProperty
+      attr_reader :name, :xpath, :attribute
+  
+      def initialize(name,xpath,attribute)
+        @name = name.to_s.downcase
+        @xpath = xpath.to_s
+        @attribute = attribute.to_s
+      end
+  
+    end
+
+    ##
+    # Embedded property is used to find the value of sub-elements inside the
+    # element
+    #
+    # If single is present, only the first element will be returned
+    # otherwise an array is returned
+    class EmbeddedProperty
+      attr_reader :name, :xpath, :class_name, :single
+      
+      def initialize(name,xpath,class_name,single)
+        @name = name.to_s.downcase
+        @xpath = xpath.to_s
+        @class_name = class_name.to_s
+        @single = single || false
+      end
+      
+    end
+    
+    def self.included(base)
+      base.instance_variable_set(:@_text_properties,[])
+      base.instance_variable_set(:@_attribute_properties,[])
+      base.instance_variable_set(:@_embedded_properties,[])
+      base.send(:extend, ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+  
+    module ClassMethods
+    
+      ##
+      # Parse an xml string
+      #
+      # @return [Array<Object>] an array of objects
+      # @see NokoParser::Parser
+      def parse(xml)
+        parser = NokoParser::Parser.new(self,xml)
+        parser.run
+      end
+      
+      ##
+      # Parse an xml file
+      #
+      # @return [Array<Object>] an array of objects
+      # @see NokoParser::Parser
+      def parse_file(file)
+        parse(open(file))
+      end
+      
+      ##
+      # Make sure this class is a noko_parser compatible class
+      def _is_noko_parser?
+        true
+      end
+      
+      ##
+      # Returns the TextProperties defined on the class
+      #
+      # @return [Array<TextProperty>]
+      def _text_properties
+        @_text_properties
+      end
+    
+      ##
+      # Returns the AttributeProperties defined in the class
+      #
+      # @return [Array<AttributeProperty]
+      def _attribute_properties
+        @_attribute_properties
+      end
+      
+      ##
+      # Returns the EmbeddedProperties defined on the class
+      #
+      # @return [Array<EmbedProperty>]
+      def _embedded_properties
+        @_embedded_properties
+      end
+      
+      ##
+      # Returns the xpath required to find the nodes
+      def _nodes_xpath
+        @_nodes_xpath || (raise NokoParserError, 'nodes :xpath => "" is required')
+      end
+    
+      ##
+      # Set the xpath for finding the nodes.
+      #
+      # examples:
+      # nodes '//monkeys'
+      # nodes '//animals/monkeys/friendly'
+      def nodes(opts={})
+        unless opts[:xpath]
+          raise NokoParserError, ":xpath required for nodes definition"
+        end
+        @_nodes_xpath = opts[:xpath].to_s
+      end
+    
+      ##
+      # Sets a property on the object.  If :attribute is defined it will
+      # set an AttributeProperty.  Otherwise, it will set a TextProperty
+      # :xpath => 'somexpathstring' is required.  The xpath should be the
+      # query required to find this element inside the node.
+      #
+      # examples
+      # property :name, :xpath => 'MyName[@type="real_name"]'
+      # property :eye_color, :xpath => 'eyes', :attribute => 'color'
+      def property(name,opts={})
+        unless opts[:xpath]
+          raise NokoParserError, ":xpath required for #{name}"
+        end
+        if opts[:attribute]
+          _add_attribute_property(name,opts[:xpath],opts[:attribute])
+        else
+          _add_text_property(name,opts[:xpath])
+        end
+      end
+      
+      ##
+      # Sets an embedded property on the option.
+      #
+      # examples:
+      # embed :names, :xpath => 'names', :class => Name
+      def embed(name,opts={})
+        unless opts[:class]
+          raise NokoParserError, ":xpath and :class required for #{name}"
+        end
+        _add_embedded_property(name,opts[:xpath],opts[:class],opts[:single])
+      end
+
+      ##
+      # Adds to the class variable @text_properties in addition to
+      # creating an accessor for this property
+      def _add_text_property(name,xpath)
+        @_text_properties << TextProperty.new(name,xpath)
+        send(:attr_accessor, name)
+      end
+    
+      ##
+      # Adds to the class variable @attribute_properties in addition to
+      # creating an accessor for this property
+      def _add_attribute_property(name,xpath,attribute)
+        @_attribute_properties << AttributeProperty.new(
+          name,xpath,attribute
+        )
+        send(:attr_accessor, name)
+      end
+      
+      ##
+      # Adds to the class variable @embedded_properties in addition to
+      # creating a reader for this property
+      def _add_embedded_property(name,xpath,class_name,single)
+        @_embedded_properties << EmbeddedProperty.new(
+          name,xpath,class_name,single
+        )
+        send(:attr_accessor, name)
+      end
+    
+    end # ClassMethods
+  
+    module InstanceMethods
+    
+      # def _something
+      #   true
+      # end
+    
+    end
+    
+  end
+  
+end # NokoParser

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dusty-noko_parser
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Dusty Doris
@@ -30,10 +30,17 @@ extensions: []
 
 extra_rdoc_files: 
 - README.txt
-files: []
-
+files: 
+- README.txt
+- examples/monkey.rb
+- examples/monkeys.xml
+- lib/noko_parser.rb
+- lib/noko_parser/parser.rb
+- lib/noko_parser/properties.rb
+- test/test_noko_parser.rb
 has_rdoc: true
 homepage: http://code.dusty.name
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -54,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: none
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Wrapper around Nokogiri to easily parse xml files with xpath