naws_xml 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43f5d536a660673e5bdbddcc9a7a3c6ee25937ab
+  data.tar.gz: ac5592fd8c834de4f138d35367c35a61886bfb71
+SHA512:
+  metadata.gz: b3ea0cbc23601fc28ae76bfafb7b5be4b204933eb6eca767c714dc4ce18795999e9a8a58362cd80a005d857346ad511f38103d770840bf1faee5a85d320bf16f
+  data.tar.gz: 5b652f12ba158ec6f1e4b68132f5d4cbd115a3b39c581d34422aa2d7a13e8d4c3fb3c89dabf56c8047781f2c371ea4bee0e2b5ca9790b7a08bbcd2e16649779e

data/lib/naws_xml/engines/ox_engine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'ox'
+
+module NawsXml
+  # @api private
+  module Engines
+    # @api private
+    class OxEngine
+
+      def parse(xml)
+        doc = Ox.parse(xml)
+        doc = doc.nodes.first if doc.is_a?(Ox::Document)
+        raise "no XML element found: #{xml.inspect}" unless doc
+        parse_node(doc)
+      rescue StandardError => error
+        raise ParseError.new(error)
+      end
+
+      def self.parse(xml)
+        new.parse(xml)
+      end
+
+      private
+
+      def parse_node(ox_node)
+        node = Node.new(ox_node.name)
+        ox_node.attributes.each_pair do |key, value|
+          node.attributes[key.to_s] = value
+        end
+        parse_node_content(node, ox_node)
+        node
+      end
+
+      def parse_node_content(node, ox_node)
+        ox_node.nodes.each do |value|
+          if value.is_a?(String)
+            node << value
+          else
+            node << parse_node(value)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/naws_xml/engines/rexml_engine.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module NawsXml
+  # @api private
+  module Engines
+    # @api private
+    class RexmlEngine
+
+      def parse(xml)
+        doc = REXML::Document.new(xml.strip)
+        raise "no XML element found: #{xml.inspect}" unless doc.root
+        parse_node(doc.root)
+      rescue StandardError => error
+        raise ParseError.new(error)
+      end
+
+      def self.parse(xml)
+        new.parse(xml)
+      end
+
+      private
+
+      def parse_node(rexml_node)
+        node = Node.new(rexml_node.name)
+        apply_attributes(node, rexml_node)
+        apply_text(node, rexml_node)
+        apply_child_nodes(node, rexml_node)
+        node
+      end
+
+      def apply_attributes(node, rexml_node)
+        rexml_node.attributes.each_attribute do |attr|
+          node.attributes[attr.name] = attr.value
+        end
+      end
+
+      def apply_text(node, rexml_node)
+        text = rexml_node.text
+        return if text.nil?
+        return if text.strip.empty?
+        node << text
+      end
+
+      def apply_child_nodes(node, rexml_node)
+        rexml_node.each_element do |value|
+          node.append(parse_node(value))
+        end
+      end
+
+    end
+  end
+end

data/lib/naws_xml/formatter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module NawsXml
+  class Formatter
+
+    NEGATIVE_INDENT = 'indent must be greater than or equal to zero'
+
+    # @param [String] indent
+    #   When `indent` is non-empty whitespace, then the XML will
+    #   be pretty-formatted with each level of nodes indented by
+    #   `indent`.
+    # @raise [ArgumentError] when indent is not a String.
+    def initialize(indent: '')
+      if !indent.is_a?(String)
+        raise ArgumentError, "expected a String, got #{indent.class}"
+      end
+      @indent = indent
+      @eol = indent.empty? ? '' : "\n"
+    end
+
+    # @param [Node] node
+    # @return [String<XML>]
+    def format(node)
+      buffer = StringIO.new
+      serialize(buffer, node, '')
+      buffer.string
+    end
+
+    private
+
+    def serialize(buffer, node, pad)
+      return buffer.write(self_close_node(node, pad)) if node.empty?
+      return buffer.write(text_node(node, pad)) if node.text
+      serialize_nested(buffer, node, pad)
+    end
+
+    def self_close_node(node, pad)
+      "#{pad}<#{node.name}#{attrs(node)}/>#{@eol}"
+    end
+
+    def text_node(node, pad)
+      "#{pad}<#{node.name}#{attrs(node)}>#{node.text.encode(xml: :text)}</#{node.name}>#{@eol}"
+    end
+
+    def serialize_nested(buffer, node, pad)
+      buffer.write("#{pad}<#{node.name}#{attrs(node)}>#{@eol}")
+      nested_pad = "#{pad}#{@indent}"
+      node.child_nodes.each do |child_node|
+        serialize(buffer, child_node, nested_pad)
+      end
+      buffer.write("#{pad}</#{node.name}>#{@eol}")
+    end
+
+    def attrs(node)
+      node.attributes.map do |key, value|
+        " #{key}=#{value.to_s.encode(xml: :attr)}"
+      end.join
+    end
+
+  end
+end

data/lib/naws_xml/node.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module NawsXml
+  class Node
+
+    # @api private
+    BOTH_TYPES = 'Nodes may not have both text and child nodes'
+
+    # @param [String] name
+    def initialize(name, *children)
+      @name = name
+      @attributes = {}
+      @child_nodes = []
+      @child_node_map = {}
+      @text = []
+      append(*children)
+    end
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Hash<String, String>]
+    attr_reader :attributes
+
+    # @return [Array<Node, String>]
+    attr_reader :children
+
+    def append(*children)
+      children.flatten.each do |child|
+        case child
+        when Node
+          raise ArgumentError, BOTH_TYPES unless @text.empty?
+          @child_nodes << child
+          @child_node_map[child.name] ||= []
+          @child_node_map[child.name] << child
+        when String
+          raise ArgumentError, BOTH_TYPES unless @child_nodes.empty?
+          @text << child
+        else
+          raise ArgumentError, 'expected NawsXml::Node or String, ' \
+            "got #{child.class}"
+        end
+      end
+    end
+    alias << append
+
+    # @return [String, nil]
+    def text
+      @text.empty? ? nil : @text.join('')
+    end
+
+    # @param [String] node_name
+    # @return [Array<Node>]
+    def [](node_name)
+      children(node_name)
+    end
+
+    # @overload children()
+    #   @return [Array<Node>] Returns an array of all child nodes.
+    # @overload children(child_name)
+    #   @param [String] child_name
+    #   @return [Array<Node>] Returns an array of child nodes with the given name.
+    def children(*args)
+      nodes =
+        case args.count
+        when 0 then @child_nodes
+        when 1 then @child_node_map.fetch(args.first, [])
+        else raise ArgumentError, "expected 0 or 1 arguments"
+        end
+      yield(nodes) if block_given? && !nodes.empty?
+      nodes
+    end
+    alias child_nodes children
+
+    # @return [Boolean]
+    def empty?
+      @child_nodes.empty? && @text.empty?
+    end
+
+    # @return [Array<String>]
+    def child_node_names
+      @child_node_map.keys
+    end
+
+    # @return [Boolean]
+    def child_node?(name)
+      @child_node_map.key?(name)
+    end
+
+    # @yield [child]
+    # @yieldparam child [Node]
+    # @return [Node, nil]
+    def child(child_name)
+      child = @child_node_map[child_name].first
+      yield(child) if block_given? && !child.nil?
+      child
+    end
+    alias at child
+
+    # @yield [text]
+    # @yieldparam text [String]
+    # @return [String, nil]
+    def text_at(child_name)
+      text = @child_node_map[child_name].first&.text
+      yield(text) if block_given? && !text.nil?
+      text
+    end
+
+    # @option options [String] :indent ('')
+    #   When `indent` is non-empty whitespace, then the XML will
+    #   be pretty-formatted with each level of nodes indented by
+    #   `indent`.
+    # @return [String<XML>]
+    def to_xml(indent: '')
+      Formatter.new(indent: indent).format(self)
+    end
+    alias to_str to_xml
+    alias to_s to_xml
+
+  end
+end

data/lib/naws_xml/node_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module NawsXml
+  class NodeParser
+
+    # @param [NawsXml::Node, String<XML>] xml
+    def initialize(xml:)
+      @node = xml.is_a?(NawsXml::Node) ? xml : Parser.parse(xml)
+      @data = {}
+    end
+
+    # @return [Hash]
+    attr_reader :data
+
+    def parse_string(node_name:, key:)
+      node = @node[node_name].first
+      return if node.nil?
+      @data[key] = string_value(node)
+    end
+
+    def parse_flat_list(node_name:, key:)
+      @data[key] = []
+      @node[node_name].each do |node|
+        # need to support non-flat lists
+        # need to support multiple formats, Time.parse, Float(), etc
+        # need to support nested nodes
+        yield
+        @data[key] << node.text.to_s
+      end
+    end
+
+  end
+end

data/lib/naws_xml/parse_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module NawsXml
+  class ParseError < StandardError
+
+    def initialize(error_or_message)
+      if error_or_message.is_a?(StandardError)
+        @original_error = error_or_message
+        super(error_or_message.message)
+      else
+        super(error_or_message)
+      end
+    end
+
+    # @return [StandardError, nil]
+    attr_reader :original_error
+
+  end
+end

data/lib/naws_xml/parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module NawsXml
+  # @api private
+  class Parser
+
+    def initialize(engine: nil)
+      @engine = engine || Parser.default_engine
+    end
+
+    # @param [String<XML>] xml
+    # @return [Node]
+    def parse(xml)
+      @engine.parse(xml)
+    end
+
+    class << self
+
+      def parse(xml)
+        new(engine: default_engine).parse(xml)
+      end
+
+      def set_default_engine(engine)
+        @engine = engine
+      end
+
+      def default_engine
+        @engine
+      end
+
+      def ox_engine
+        require_relative 'engines/ox_engine'
+        Engines::OxEngine.new
+      end
+
+      def rexml_engine
+        require_relative 'engines/rexml_engine'
+        Engines::RexmlEngine.new
+      end
+
+    end
+
+    begin
+      set_default_engine(ox_engine)
+    rescue LoadError
+      set_default_engine(rexml_engine)
+    end
+
+  end
+end

data/lib/naws_xml.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'naws_xml/formatter'
+require_relative 'naws_xml/node'
+require_relative 'naws_xml/parse_error'
+require_relative 'naws_xml/parser'
+
+# NawsXml is a purpose-built set of utilities for working with
+# XML. It does not support many/most features of generic XML
+# parsing and serialization.
+# @api private
+module NawsXml
+  class << self
+
+    # @param [String] xml
+    # @return [Node]
+    def parse(xml, engine: Parser.default_engine)
+      Parser.new(engine: engine).parse(xml)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: naws_xml
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: ruby
+authors:
+- The Incognito Coder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+- !ruby/object:Gem::Dependency
+  name: semver-string
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: yard-sitemap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- theincognitocoder@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/naws_xml.rb
+- lib/naws_xml/engines/ox_engine.rb
+- lib/naws_xml/engines/rexml_engine.rb
+- lib/naws_xml/formatter.rb
+- lib/naws_xml/node.rb
+- lib/naws_xml/node_parser.rb
+- lib/naws_xml/parse_error.rb
+- lib/naws_xml/parser.rb
+homepage: https://github.com/theincognitocoder/naws_xml
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/theincognitocoder/naws_xml/issues
+  changelog_uri: https://github.com/theincognitocoder/naws_xml/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/github/theincognitocoder/naws_xml/master
+  homepage_uri: https://github.com/theincognitocoder/naws_xml
+  mailing_list_uri: https://gitter.im/theincognitocoder
+  source_code_uri: https://github.com/theincognitocoder/naws_xml
+  wiki_uri: https://github.com/theincognitocoder/naws_xml/wiki
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Naws Xml
+test_files: []