xml-mixup 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5d422e3cab772172b48772aa775c71c7362f3459c4315b28a48180832160dca
+  data.tar.gz: 12d50f74beb943f993fbd52b89913e9696c9240893fb14bcca81a434bc569d0c
+SHA512:
+  metadata.gz: 1896aa7cec980baf9779ca87aaad386de815879406f24ca04cc92d9a5b00b995e4a785edbd7d625b4954435f3b248b69f997f429eb55d76d1dbef4538f38f0da
+  data.tar.gz: 1648c19729fcd0a56504c046d11e4c2def65c2cc287ee371fbb24e837c8fe499991ad763c51ec9abaa060d3e34718c8db69d74bb16c3299c6da8c5266532eee0

data/.gitignore

@@ -0,0 +1,15 @@
+syntax: glob
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+.\#*
+\#*\#
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in mixup.gemspec
+gemspec

data/README.md

@@ -0,0 +1,191 @@
+# XML::Mixup: A mixin for XML markup
+
+```ruby
+require 'xml-mixup'
+
+class Anything
+  include XML::Mixup
+end
+
+something = Anything.new
+
+# generate a structure
+node = something.markup spec: [
+  { '#pi'   => 'xml-stylesheet', type: 'text/xsl', href: '/transform' },
+  { '#dtd'  => :html },
+  { '#html' => [
+    { '#head' => [
+      { '#title' => 'look ma, title' },
+      { '#elem'  => :base, href: 'http://the.base/url' },
+    ] },
+    { '#body' => [
+      { '#h1' => 'Illustrious Heading' },
+      { '#p'  => :lolwut },
+    ] },
+  ], xmlns: 'http://www.w3.org/1999/xhtml' }
+]
+
+# `node` will correspond to the last thing generated. In this
+# case, it will be a text node containing 'lolwut'.
+
+doc = node.document
+puts doc.to_xml
+```
+
+## Yet another XML markup generator?
+
+Some time ago, [I](https://doriantaylor.com/) wrote a Perl module called
+[Role::Markup::XML](https://metacpan.org/pod/Role::Markup::XML). I did this
+because I had a lot of XML to generate, and was dissatisfied with what
+was currently on offer. Now I have a lot of XML to generate using
+Ruby, and found a lot of the same things:
+
+### Structure is generated by procedure calls
+
+Granted it's a lot nicer to do this sort of thing in Ruby, but at the
+end of the day, the thing generating the XML is a nested list of
+method calls---_not_ a declarative data structure.
+
+### Document has to be generated all in one shot
+
+It's not super-easy to generate a piece of the target document and
+then go back and generate some more (although
+{Nokogiri::XML::Builder.with} is a nice start). This plus the last
+point leads to all sorts of cockamamy constructs which are almost as
+life-sucking as writing raw DOM routines.
+
+### Hard to do surgery on existing documents
+
+This comes up a lot: you have an existing document and you want to add
+even just a single node to it---say, in between two nodes just for
+fun. Good luck with that.
+
+### Enter `XML::Mixup`
+
+* __The input consists of ordinary Ruby data objects__ so you can
+  build them up ahead of time, in bulk, transform them, etc.,
+* __Sprinkle pre-built XML subtrees anywhere into the spec__ so you
+  can memoize repeating elements, or otherwise compile a document
+  incrementally,
+* __Attach new generated content anywhere:__ underneath a parent node,
+  or before, after, or _instead of_ a node at the sibling level.
+
+## The spec format
+
+At the heart of this module is a single method called `markup`, which,
+among other things, takes a `:spec`. The spec can be any composite
+
+### Hashes
+
+The principal construct in `XML::Mixup` is the {Hash}. You can
+generate pretty much any node with it:
+
+#### Elements
+
+```ruby
+{ '#tag' => 'foo' }                 # => <foo/>
+
+# or
+{ '#elem' => 'foo' }                # => <foo/>
+
+# or, with the element name as a symbol
+{ '#element' => :foo }              # => <foo/>
+
+# or, with nil as a key
+{ nil => :foo }                     # => <foo/>
+
+# or, with attributes
+{ nil => :foo, bar: :hi }           # => <foo bar="hi"/>
+
+# or, with namespaces
+{ nil => :foo, xmlns: 'urn:x-bar' } # => <foo xmlns="urn:x-bar"/>
+
+# or, with more namespaces
+{ nil => :foo, xmlns: 'urn:x-bar', 'xmlns:hurr' => 'urn:x-durr' }
+# => <foo xmlns="urn:x-bar" xmlns:hurr="urn:x-durr"/>
+
+# or, with content
+{ nil => [:foo, :hi] }              # => <foo>hi</foo>
+
+# or, shove your child nodes into an otherwise content-less key
+{ [:hi] => :foo, bar: :hurr }       # => <foo bar="hurr">hi</foo>
+```
+
+Attributes are sorted lexically. Composite attribute values get
+flattened like this:
+
+```ruby
+{ nil => :foo, array: [:a :b], hash: { e: :f, c: :d } }
+# => <foo array="a b" hash="c: d e: f"/>
+```
+
+#### Processing instructions
+
+```ruby
+{ '#pi' => 'xml-stylesheet', type: 'text/xsl', href: '/transform' }
+# => <?xml-stylesheet type="text/xsl" href="/transform"?>
+
+# or, if you like typing
+{ '#processing-instruction' => :hurr } # => <?hurr?>
+```
+
+#### `DOCTYPE` declarations
+
+```ruby
+{ '#dtd' => :html } # => <!DOCTYPE html>
+
+# or (note either :public or :system can be nil)
+{ '#dtd' => [:html, :public, :system] }
+# => <!DOCTYPE html PUBLIC "public" SYSTEM "system">
+
+# or, same thing
+{ '#doctype' => :html, public: :public, system: :system }
+```
+
+#### Comments and `CDATA` sections
+
+Comments and `CDATA` are flattened into string literals:
+
+```ruby
+{ '#comment' => :whatever }     # => <!-- whatever -->
+
+{ '#cdata' => '<what-everrr>' } # => <![CDATA[<what-everrr>]]>
+```
+
+Pretty straight forward?
+
+### Arrays
+
+Parts of a spec that are arrays (or really anything that can be turned
+into one) are attached at the same level of the document in the
+sequence given, as you might expect.
+
+### `Nokogiri::XML::Node` objects
+
+These are automatically cloned, but otherwise passed in as-is.
+
+### `Proc`s, lambdas etc.
+
+These are executed with any supplied `:args`, and then `markup` is run
+again over the result. (Take care not to supply a `Proc` that produces
+another `Proc`.)
+
+### Everything else
+
+Turned into a text node.
+
+## Installation
+
+Come on, you know how to do this:
+
+    $ gem install xml-mixup
+
+## Contributing
+
+Bug reports and pull requests are welcome at
+https://github.com/doriantaylor/rb-xml-mixup.
+
+## License
+
+This software is provided under
+the [Apache License, 2.0](https://www.apache.org/licenses/LICENSE-2.0).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/xml/mixup/version.rb

@@ -0,0 +1,5 @@
+module XML
+  module Mixup
+    VERSION = "0.1.0"
+  end
+end

data/lib/xml/mixup.rb

@@ -0,0 +1,505 @@
+require 'xml/mixup/version'
+require 'nokogiri'
+
+module XML::Mixup
+
+  # 
+
+  # these are node attachment protocols
+  private
+  
+  ADJACENT = {
+              parent:  lambda do |node, parent|
+                if parent.node_type == 9 and node.node_type == 1
+                  parent.root = node
+                elsif node.node_type == 11
+                  node.children.each do |child|
+                    parent.add_child(child)
+                  end
+                else
+                  parent.add_child(node)
+                end
+              end,
+              before:  lambda do |node, sibling|
+                sibling.add_previous_sibling node
+              end,
+              after:   lambda { |node, sibling| sibling.add_next_sibling node },
+              replace: lambda { |node, target|  target.replace node },
+             }.freeze
+
+  RESERVED = %w{comment cdata doctype dtd elem element
+              pi processing-instruction tag}.map {|x| "##{x}"}.to_set.freeze
+
+  public
+
+  # Generate a handy blank document.
+  #
+  # @param version [Numeric, nil]
+  #
+  # @return [Nokogiri::XML::Document] a Nokogiri XML document.
+
+  def xml_doc version = nil
+    Nokogiri::XML::Document.new version
+  end
+
+  # Generates an XML tree from a given specification.
+  #
+  #  require 'xml-mixup'
+  #
+  #  class Anything
+  #    include XML::Mixup
+  #  end
+  #
+  #  something = Anything.new
+  #
+  #  # generate a structure
+  #  node = something.markup spec: [
+  #    { '#pi'   => 'xml-stylesheet', type: 'text/xsl', href: '/transform' },
+  #    { '#dtd'  => :html },
+  #    { '#html' => [
+  #      { '#head' => [
+  #        { '#title' => 'look ma, title' },
+  #        { '#elem'  => :base, href: 'http://the.base/url' },
+  #      ] },
+  #      { '#body' => [
+  #        { '#h1' => 'Illustrious Heading' },
+  #        { '#p'  => :lolwut },
+  #      ] },
+  #    ], xmlns: 'http://www.w3.org/1999/xhtml' }
+  #  ]
+  #
+  #  # `node` will correspond to the last thing generated. In this
+  #  # case, it will be a text node containing 'lolwut'.
+  #
+  #  doc = node.document
+  #  puts doc.to_xml  
+  #
+  # @param spec [Hash, Array, Nokogiri::XML::Node, Proc, #to_s] An XML
+  #  tree specification. May be composed of multiple hashes and
+  #  arrays. See the spec spec.
+  # 
+  # @param doc [Nokogiri::XML::Document, nil] an optional XML document
+  #  instance; will be supplied if none given.
+  #
+  # @param args [#to_a] Any arguments to be passed to any callbacks
+  #  anywhere in the spec. Assumed to be an array.
+  # 
+  # @param parent [Nokogiri::XML::Node] The node under which the
+  #  evaluation result of the spec is to be attached. This is the
+  #  default adjacent node, which in turn defaults to the document if
+  #  it or no other adjacent node is given. Conflicts with other
+  #  adjacent nodes.
+  #
+  # @param before [Nokogiri::XML::Node] This represents a _sibling_
+  #  node which the spec is to be inserted _before_. Conflicts with
+  #  other adjacent nodes.
+  #
+  # @param after [Nokogiri::XML::Node] This represents a _sibling_
+  #  node which the spec is to be inserted _after_. Conflicts with
+  #  other adjacent nodes.
+  #
+  # @param replace [Nokogiri::XML::Node] This represents a _sibling_
+  #  node which the spec is intended to _replace_. Conflicts with
+  #  other adjacent nodes.
+  #
+  # @return [Nokogiri::XML::Node] the last node generated, in document
+  #  order. Will return a {Nokogiri::XML::Document} when called
+  #  without arguments.
+
+  def markup spec: nil, doc: nil, args: [], **nodes
+    # handle adjacent node declaration
+    adj = nil
+    ADJACENT.keys do |k|
+      if nodes[k]
+        if adj
+          raise
+        end
+        unless nodes[k].is_a? Nokogiri::XML::Node
+          raise
+        end
+        adj = k
+      end
+    end
+
+    # generate doc/parent
+    if adj
+      doc ||= nodes[adj].document
+      unless adj == 'parent'
+        unless (nodes[:parent] = nodes[adj].parent)
+          raise
+        end
+      end
+    else
+      doc ||= Nokogiri::XML::Document.new
+      nodes[adj = :parent] ||= doc
+    end
+
+    node = nodes[adj]
+
+    # dispatch based on spec type
+    if spec and not (spec.respond_to? :empty? and spec.empty?)
+      if spec.is_a? Array
+        par = adj == :parent ? nodes[:parent] : doc.fragment
+        out = spec.map do |x|
+          markup(spec: x, parent: par, pseudo: nodes[:parent], doc: doc,
+                 args: nodes[:args])
+        end
+
+        # only run this if there is something to run
+        if out.length > 0
+          # this is already attached if the adjacent node is the parent
+          ADJACENT[adj].call(par, nodes[adj]) unless adj == :parent
+          node = out.last
+        end
+        # node otherwise defaults to adjacent
+
+      elsif spec.respond_to? :call
+        # handle proc/lambda/whatever
+        node = markup(spec: spec.call(*args), args: args,
+                      doc: doc, adj => nodes[adj])
+      elsif spec.is_a? Hash
+        # maybe element, maybe something else
+
+        # find the nil key which should contain a viable node name
+        # (and maybe children)
+        name     = nil
+        children = []
+        if x = spec[nil]
+          if x.respond_to? :to_a
+            x = x.to_a
+            name = x.shift
+            children = x
+          else 
+            name = x
+          end
+        elsif (compact = spec.select { |k, _|
+                 k.respond_to?(:to_a) or k.is_a?(Nokogiri::XML::Node)}) and
+            not compact.empty?
+          # compact syntax eliminates the `nil` key
+          raise %q{Spec can't have duplicate compact keys} if compact.count > 1
+          children, name = compact.first
+          children = children.respond_to?(:to_a) ? children.to_a : [children]
+        elsif (special = spec.select { |k, _|
+                 k.respond_to? :to_s and k.to_s.start_with? '#' }) and
+            not special.empty?
+          # these are special keys 
+          raise %q{Spec can't have multiple special keys} if special.count > 1
+          name, children = special.first
+
+          if %w{# #elem #element #tag}.any? name
+            # then the name is in the `children` slot
+            raise "Value of #{name} shorthand formulation" +
+              "must be a valid element name" unless children.to_s
+            name = children
+            # set children to empty array
+            children = []
+          elsif not RESERVED.any? name
+            # then the name is encoded into the key and we have to
+            # remove the octothorpe
+            name = name[1..name.length]
+          end
+
+          # don't forget to reset the child nodes
+          children = children.respond_to?(:to_a) ? children.to_a : [children]
+        end
+
+        # note the name can be nil because it can be inferred
+
+        # now we pull out "attributes" which are the rest of the keys;
+        # these should be amenable to being turned into symbols
+        attr = spec.select { |k, _|
+          k and k.respond_to? :to_sym and not k.to_s.start_with? '#'
+        }.transform_keys(&:to_sym)
+
+        # now we dispatch based on the name
+        if name == '#comment'
+          # first up, comments
+          node = doc.create_comment flatten(children, args)
+
+          # attach it
+          ADJACENT[adj].call node, nodes[adj]
+
+        elsif name == '#pi' or name == '#processing-instruction'
+          # now processing instructions
+          if children.empty?
+            raise
+          end
+          target  = children[0]
+          content = ''
+          if (c = children[1..children.length]) and c.length > 0
+            #warn c.inspect
+            content = flatten(c, args)
+          else
+            content = attr.sort.map { |pair|
+              "#{pair[0].to_s}=\"#{flatten(pair[1], args)}\""
+            }.join(' ')
+          end
+              
+          node = Nokogiri::XML::ProcessingInstruction.new(doc, target, content)
+
+          #warn node.inspect, content
+
+          # attach it
+          ADJACENT[adj].call node, nodes[adj]
+
+        elsif name == '#dtd' or name == '#doctype'
+          # now doctype declarations
+          if children.empty?
+            raise
+          end
+
+          # assign as if these are args
+          root, pub, sys = children
+          # supplant with attributes if present
+          pub ||= attr[:public] if attr[:public]
+          sys ||= attr[:system] if attr[:system]
+
+          # XXX for some reason this is an *internal* subset?
+          node = doc.create_internal_subset(root, pub, sys)
+
+          # at any rate it doesn't have to be explicitly attached
+
+          # attach it to the document
+          #doc.add_child node
+
+          # attach it (?)
+          #ADJACENT[adj].call node, nodes[adj]
+        elsif name == '#cdata'
+          # let's not forget cdata sections
+          node = doc.create_cdata flatten(children, args)
+          # attach it
+          ADJACENT[adj].call node, nodes[adj]
+
+        else
+          # finally, an element
+
+          raise 'Element name inference NOT IMPLEMENTED' unless name
+
+          # first check the name
+          prefix = local = nil
+          if name and (md = /^(?:([^:]+):)?(.+)/.match(name.to_s))
+            # XXX match actual qname/ncname here
+            prefix, local = md.captures
+          end
+
+          # next pull apart the namespaces and ordinary attributes
+          ns = {}
+          at = {}
+          attr.each do |k, v|
+            v = flatten(v, args)
+            if (md = /^xmlns(?::(.*))?$/i.match(k.to_s))
+              ns[md[1]] = v
+            else
+              at[k.to_s] = v
+            end
+          end
+
+          # now go over the attributes and set any missing namespaces to nil
+          at.keys.each do |k|
+            p, _ = /^(?:([^:]+):)?(.+)$/.match(k).captures
+            ns[p] ||= nil
+          end
+          # also do the tag prefix but only if there is a local name
+          ns[prefix] ||= nil if local
+
+          # pseudo is a stand-in for non-parent adjacent nodes
+          pseudo = nodes[:pseudo] || nodes[:parent]
+
+          # now get the final namespace mapping
+          ns.keys.each do |k|
+            pk = k ? "xmlns:#{k}" : "xmlns"
+            if pseudo.namespaces.has_key? pk
+              ns[k] ||= pseudo.namespaces[pk]
+            end
+          end
+          # delete nil => nil
+          if ns.has_key? nil and ns[nil].nil?
+            ns.delete(nil)
+          end
+
+          # there should be no nil namespace declarations now
+          if ns.has_value? nil
+            raise
+          end
+
+          # generate the node
+          node = element name, doc: doc, ns: ns, attr: at, args: args
+
+          # attach it 
+          ADJACENT[adj].call node, nodes[adj]
+
+          # don't forget the children!
+          if children.length > 0
+            #warn node.inspect, children.inspect
+            node = markup(spec: children, doc: doc, parent: node, args: args)
+          end
+        end
+      else
+        if spec.is_a? Nokogiri::XML::Node
+          # existing node
+          node = spec.dup
+        else
+          # text node
+          node = doc.create_text_node spec.to_s
+        end
+
+        # attach it
+        ADJACENT[adj].call node, nodes[adj]
+      end
+    end
+
+    # return the node
+    node
+  end
+
+  # Generates an XHTML stub, with optional RDFa attributes. All
+  # parameters are optional.
+  #
+  # @param doc [Nokogiri::XML::Document, nil] an optional document.
+  #
+  # @param base [#to_s] the contents of +<base href=""/>+.
+  #
+  # @param prefix [Hash] the contents of the root node's +prefix=+
+  #  and +xmlns:*+ attributes.
+  # 
+  # @param vocab [#to_s] the contents of the root node's +vocab=+.
+  #
+  # @param lang [#to_s] the contents of +lang=+ and when applicable, +xml:lang+.
+  #
+  # @param title [#to_s, #to_a, Hash] the contents of the +<title>+
+  #  tag. When given as an array-like object, all elements after the
+  #  first one will be flattened to a single string and inserted into
+  #  the +property=+ attribute. When given as a {Hash}, it will be
+  #  coerced into a snippet of spec that produces the appropriate tag.
+  #
+  # @param link [#to_a, Hash] A spec describing one or more +<link/>+ elements.
+  #
+  # @param meta [#to_a, Hash] A spec describing one or more +<meta/>+ elements.
+  #
+  # @param style [#to_a, Hash] A spec describing one or more
+  #  +<style/>+ elements.
+  #
+  # @param script [#to_a, Hash] A spec describing one or more
+  #  +<script/>+ elements.
+  #
+  # @param attr [Hash] A spec containing attributes for the +<body>+.
+  #
+  # @param content [Hash, Array, Nokogiri::XML::Node, ...] A spec which
+  #  will be attached underneath the +<body>+.
+  #
+  # @param head [Hash] A spec which overrides the entire +<head>+.
+  #
+  # @param body [Hash] A spec which overrides the entire +<body>+.
+  #
+  # @param transform [#to_s] An optional XSLT transform.
+  #
+  # @param dtd [true, false, nil, #to_a] Whether or not to attach a
+  #  +<!DOCTYPE html>+ declaration. Can be given as an array-like
+  #  thing containing two stringlike things which serve as public and
+  #  system identifiers. Defaults to +true+.
+  #
+  # @param xmlns [true, false, nil, Hash] Whether or not to include
+  #  XML namespace declarations, including the XHTML declaration. When
+  #  given as a {Hash}, it will set _only the hash contents_ as
+  #  namespaces. Defaults to +true+.
+  #
+  # @param args [#to_a] Arguments for any callbacks in the spec.
+  # 
+  # @return [Nokogiri::XML::Node] the last node generated, in document order.
+
+  def xhtml_stub doc: nil, base: nil, ns: {}, prefix: {}, vocab: nil,
+      lang: nil, title: nil, link: [], meta: [], style: [], script: [],
+      head: {}, body: {}, attr: {}, content: [],
+      transform: nil, dtd: true, xmlns: true, args: []
+
+    spec = []
+
+    # add xslt stylesheet
+    if transform
+      spec << (transform.is_a? Hash ? transform :
+               { nil => ['#pi', 'xml-stylesheet'],
+                type: 'text/xsl', href: transform.to_s })
+    end
+
+    # add doctype declaration
+    if dtd
+      ps = dtd.respond_to?(:to_a) ? dtd.to_a : []
+      spec << { nil => %w{#dtd html} + ps }
+    end
+
+    # construct document tree
+
+    head ||= {}
+    if head.empty? 
+      head[nil] = [:head, title, base, link, meta, style, script]
+    end
+
+    body ||= {}
+    if body.empty?
+      
+      body[nil] = [:body, content]
+    end
+
+    root = { nil => [:html, [head, body]] }
+    root[:vocab] = vocab if vocab
+    root[:lang]  = lang  if lang
+
+    # deal with namespaces
+    if xmlns
+      root['xmlns'] = 'http://www.w3.org/1999/xhtml'
+
+      # namespaced language attribute
+      root['xml:lang'] = lang if lang
+    end
+
+    # deal with prefixes distinct from namespaces
+    if prefix
+    end
+
+    # add the document structure to the spec
+    spec << root
+
+    # as usual this will return the last innermost node
+    markup spec: spec, doc: doc
+  end
+
+  private
+
+  def element tag, doc: nil, ns: {}, attr: {}, args: []
+    raise unless doc
+    prefix = local = nil
+    if tag.respond_to? :to_a
+      prefix, local = tag
+      tag = tag.join ':'
+    end
+    elem = doc.create_element tag.to_s
+    ns.sort.each do |p, u|
+      elem.add_namespace((p.nil? ? p : p.to_s), u.to_s)
+    end
+    attr.sort.each do |k, v|
+      elem[k.to_s] = flatten(v, args)
+    end
+
+    elem
+  end
+
+  ATOMS = [String, Symbol, Numeric, NilClass, FalseClass, TrueClass]
+
+  # yo dawg
+
+  def flatten obj, args
+    # early bailout for most likely condition
+    if ATOMS.any? { |x| obj.is_a? x }
+      obj.to_s
+    elsif obj.is_a? Hash
+      obj.sort.map { |kv| "#{kv[0].to_s}: #{flatten(kv[1], args)}" }.join(' ')
+    elsif obj.respond_to? :call
+      obj.call(*args)
+    elsif obj.respond_to? :map
+      obj.map { |x| flatten(x, args) }.join(' ')
+    else
+      obj.to_s
+    end
+  end
+
+end

data/lib/xml-mixup.rb

@@ -0,0 +1,3 @@
+require 'xml/mixup'
+
+# See {xml/mixup}

data/xml-mixup.gemspec

@@ -0,0 +1,38 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "xml/mixup/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "xml-mixup"
+  spec.version       = XML::Mixup::VERSION
+  spec.authors       = ["Dorian Taylor"]
+  spec.email         = ["code@doriantaylor.com"]
+  spec.license       = 'Apache-2.0'
+  spec.summary       = %q{A mixin for (XML) markup}
+  spec.description   = %q{XML::Mixup uses declarative data structures to incrementally generate XML.}
+  spec.homepage      = "https://github.com/doriantaylor/rb-xml-mixup"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "nokogiri", "~> 1.8.2"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: xml-mixup
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dorian Taylor
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+description: XML::Mixup uses declarative data structures to incrementally generate
+  XML.
+email:
+- code@doriantaylor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/xml-mixup.rb
+- lib/xml/mixup.rb
+- lib/xml/mixup/version.rb
+- xml-mixup.gemspec
+homepage: https://github.com/doriantaylor/rb-xml-mixup
+licenses:
+- Apache-2.0
+metadata: {}
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A mixin for (XML) markup
+test_files: []