awesome_xml 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c56c2831ab0626cb308dc5dea679f2f854077101
-  data.tar.gz: f25a4b311f2cad636f5deba9797cfd48fb014e8d
+  metadata.gz: '09184adda9b06ea9f6219d70c4a73639e1f24a82'
+  data.tar.gz: e6fa8cb7358a7e0eef58e3c5ba312e104c5df4a4
 SHA512:
-  metadata.gz: 27448af39a7950d1c96a3e1d814037acaeb63dc08ac2cd2d2034889899feefacd3fc1702ffffdbdd6d409262a7034dbc531ea5b7b0e393f75db57eaf70997d85
-  data.tar.gz: 84179c85be80e1543a7b53e3c7a1d823086126c99322b7cce5f6916564caedb0b1fdcf6d8d342c4bc5fb626fe5fd5d884db389ec0e935e40c58729ca77324f65
+  metadata.gz: 0334bed7e8863a5ce46ccc245e72266f66e561f200d610a7d79868454f5761a7742055ebe6fc8f4d147d194742eca7c144155f4117e9a53dd169be8cb3669b59
+  data.tar.gz: 68870e318cbba35b3046d5a9acd411e9d77c300e611340b4616343f79c0dc04043352749973282133a0beffc921c13c91be19d35596fadbfd92d988512e191c4

data/README.md

@@ -42,7 +42,7 @@ Its arguments are
   - an options hash (optional)
 
 The type can either be a native type given in the form of a symbol (currently supported are `:text`,
-`:integer`, `:float`, `:duration` and `:date_time`), or a custom class. You can also pass in a string containing
+`:integer`, `:float`, `:duration`, `:date_time` and `:void`), or a custom class. You can also pass in a string containing
 a class name in case the class constant is not yet defined at the time you run the `.node` method.
 More about that later.
 
@@ -271,6 +271,48 @@ class MyDocument
 end
 ```
 
+## Node names
+
+There are three options you can use in case you want to parse not the content of an element or attribute,
+but the name of it: `:element_name`, `:attribute_name`, `:self_name`. Those will parse the name of the element or
+the attribute specified by the name of the node or by an `:xpath` option, or the name of the current node itself.
+
+Let's look at an example:
+
+```xml
+<document>
+  <heap1>
+    <item ref='a'/>
+  </heap1>
+  <heap2>
+    <item ref='b'/>
+  </heap2>
+</document>
+```
+
+Now let's assume you want your hash to equal
+```ruby
+{ items: [ { ref: 'a', heap: 'heap1' }, { ref: 'b', heap: 'heap2' } ] }
+```
+
+You can solve this by using `element_name: true`:
+
+```ruby
+class MyDocument
+  include AwesomeXML
+
+  set_context 'document'
+  node :items, 'Item', array: true, xpath: '//item'
+
+  class Item
+    include AwesomeXML
+
+    node :ref, :text, attribute: true
+    node :heap, :text, element_name: true, xpath: '../'
+  end
+end
+```
+
 Awesome, right? You've got a few more notches you can kick it up, though.
 
 ## Passing blocks
@@ -477,7 +519,9 @@ or doesn't even exist. For the former, use `:default_empty`, for the latter, use
 
 ## More node types
 
-Let's talk about duration nodes. As you may remember, `:duration` is of the native types for `.node`.
+### Duration nodes
+
+As you may remember, `:duration` is of the native types for `.node`.
 They return `ActiveSupport::Duration` objects, which interact freely with each other and with `Time` and
 `DateTime` objects.
 The special thing about them is that they take a *mandatory* `:format` option. There, you can specify the
@@ -496,3 +540,35 @@ but when the numbers are single digit, it looks like `'2m1'`. In this case, just
 `parse_length`. Everything up to the following character (or the end of the duration string) will be
 treated as going into the parsed value. The format string that would parse you the correct duration
 would be `'{M}m{S}'`.
+
+### Void nodes
+
+This type is used if you don't actually want to parse anything. For example, if you simply want to count the
+occurrence of a tag. The result of the parsing operation is simply the node(s) itself. Suppose your XML document
+is this:
+
+```xml
+<document>
+  <items>
+    <item>1234</item>
+    <item>4321</item>
+    <item>5678</item>
+  </items>
+</document>
+```
+
+And you want your ruby hash to be
+```ruby
+{ number_of_items: 3 }
+```
+
+This will do it for you:
+
+```ruby
+class MyDocument
+  include AwesomeXML
+
+  set_context 'document/items'
+  node(:number_of_items, :void, element: 'item', array: true) { |nodes| nodes.size }
+end
+```

data/lib/awesome_xml.rb

@@ -9,6 +9,7 @@ FILES = %w(
   types/float
   types/duration
   types/date_time
+  types/void
   type
   class_methods
   duration/chunk_parser

data/lib/awesome_xml/class_methods.rb

@@ -70,6 +70,10 @@ module AwesomeXML
       @public_nodes ||= []
     end
 
+    def parsing_type?
+      false
+    end
+
   private
 
     def register(node_name, privateness)

data/lib/awesome_xml/native_type.rb

@@ -4,12 +4,18 @@
 # interface for types that the `AwesomeXML::NodeEvaluator` expects.
 module AwesomeXML
   module NativeType
+    def self.included(base)
+      base.class_eval do
+        base.extend(AwesomeXML::NativeType::ClassMethods)
+      end
+    end
+
     attr_reader :string, :options
     private :string, :options
 
     # Native type instances are initialized with a `Nokogiri::XML` object and an options hash.
-    def initialize(node, options = {})
-      @string = node&.text
+    def initialize(string, options)
+      @string = string
       @options = options
     end
 
@@ -19,6 +25,12 @@ module AwesomeXML
       @value ||= with_defaults { parse_value }
     end
 
+    module ClassMethods
+      def parsing_type?
+        true
+      end
+    end
+
   private
 
     def with_defaults(&block)

data/lib/awesome_xml/node_evaluator.rb

@@ -21,14 +21,19 @@ module AwesomeXML
     # type passed in in the form of a class that handles the conversion.
     def call
       if options[:array]
-        all_nodes.map { |node| type_class.new(node, options).evaluate }
+        all_nodes.map { |node| type_class.new(content(node), options).evaluate }
       else
-        type_class.new(first_node, options).evaluate
+        type_class.new(content(first_node), options).evaluate
       end
     end
 
   private
 
+    def content(node)
+      return node unless type_class.parsing_type?
+      (options[:element_name] || options[:attribute_name] || options[:self_name]) ? node&.name : node&.text
+    end
+
     def all_nodes
       xml_in_context&.xpath(xpath)
     end

data/lib/awesome_xml/node_xpath.rb

@@ -3,40 +3,39 @@
 # This class's responsibility is to build an XPath from specified options.
 module AwesomeXML
   class NodeXPath
-    attr_reader :node_name, :specific_xpath, :element_option, :attribute_option, :self_option, :array
-    private :node_name, :specific_xpath, :element_option, :attribute_option, :self_option, :array
+    attr_reader :node_name, :options
+    private :node_name, :options
 
     # Initialize this class by providing the name of the `AwesomeXML` node and an options hash.
     # For more information on how the options work, please refer to the README.
     def initialize(node_name, options)
       @node_name = node_name
-      @specific_xpath = options[:xpath]
-      @element_option = options[:element]
-      @attribute_option = options[:attribute]
-      @self_option = options[:self]
-      @look_for = options[:look_for]
-      @array = options[:array]
+      @options = options
     end
 
     # Returns a String representing an XPath built from the options passed in at initialization time.
     def xpath
-      specific_xpath || xpath_by_tag_type
+      options[:xpath] || xpath_by_tag_type
     end
 
   private
 
     def xpath_by_tag_type
-      if attribute_option
-        "./@#{tag_name(attribute_option)}"
-      elsif self_option
+      if options[:attribute]
+        "./@#{tag_name(options[:attribute])}"
+      elsif options[:attribute_name]
+        "./@#{tag_name(true)}"
+      elsif options[:self] || options[:self_name]
         "."
+      elsif options[:element_name]
+        "./#{tag_name(true)}"
       else
-        "./#{tag_name(element_option)}"
+        "./#{tag_name(options[:element])}"
       end
     end
 
     def node_name_singular
-      array ? node_name.to_s.singularize.to_sym : node_name
+      options[:array] ? node_name.to_s.singularize.to_sym : node_name
     end
 
     def tag_name(option)

data/lib/awesome_xml/type.rb

@@ -9,7 +9,8 @@ module AwesomeXML
       integer: AwesomeXML::Integer,
       float: AwesomeXML::Float,
       duration: AwesomeXML::Duration,
-      date_time: AwesomeXML::DateTime
+      date_time: AwesomeXML::DateTime,
+      void: AwesomeXML::Void
     }.freeze
 
     # Takes a type (Symbol, String or Class) passed in from a `.node` method call and the

data/lib/awesome_xml/types/void.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# A class that knows how to not parse but simply pass on a node.
+module AwesomeXML
+  class Void
+    attr_reader :node
+    private :node
+
+    def initialize(node, options)
+      @node = node
+      @options = options
+    end
+
+    def evaluate
+      node
+    end
+
+    def self.parsing_type?
+      false
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: awesome_xml
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Felix Lublasser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-01 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -121,6 +121,7 @@ files:
 - lib/awesome_xml/types/float.rb
 - lib/awesome_xml/types/integer.rb
 - lib/awesome_xml/types/text.rb
+- lib/awesome_xml/types/void.rb
 homepage: https://github.com/fromAtoB/awesome_xml
 licenses:
 - MIT