chef-gyoku 1.4.1

data/lib/gyoku/array.rb

@@ -0,0 +1,96 @@
+module Gyoku
+  module Array
+    module_function
+
+    NESTED_ELEMENT_NAME = "element"
+
+    # Builds XML and prettifies it if +pretty_print+ option is set to +true+
+    def to_xml(array, key, escape_xml = true, attributes = {}, options = {})
+      xml = build_xml(array, key, escape_xml, attributes, options)
+
+      if options[:pretty_print] && options[:unwrap]
+        Prettifier.prettify(xml, options)
+      else
+        xml
+      end
+    end
+
+    # Translates a given +array+ to XML. Accepts the XML +key+ to add the elements to,
+    # whether to +escape_xml+ and an optional Hash of +attributes+.
+    def self.build_xml(array, key, escape_xml = true, attributes = {}, options = {})
+      self_closing = options.delete(:self_closing)
+      unwrap = unwrap?(options.fetch(:unwrap, false), key)
+
+      iterate_with_xml array, key, attributes, options do |xml, item, attrs, index|
+        if self_closing
+          xml.tag!(key, attrs)
+        else
+          case item
+          when ::Hash
+            if unwrap
+              xml << Hash.to_xml(item, options)
+            else
+              xml.tag!(key, attrs) { xml << Hash.build_xml(item, options) }
+            end
+          when ::Array
+            xml.tag!(key, attrs) { xml << Array.build_xml(item, NESTED_ELEMENT_NAME) }
+          when NilClass
+            xml.tag!(key, "xsi:nil" => "true")
+          else
+            xml.tag!(key, attrs) { xml << XMLValue.create(item, escape_xml) }
+          end
+        end
+      end
+    end
+
+    # Iterates over a given +array+ with a Hash of +attributes+ and yields a builder +xml+
+    # instance, the current +item+, any XML +attributes+ and the current +index+.
+    def iterate_with_xml(array, key, attributes, options, &block)
+      xml = Builder::XmlMarkup.new
+      unwrap = unwrap?(options.fetch(:unwrap, false), key)
+
+      if unwrap
+        xml.tag!(key, attributes) { iterate_array(xml, array, attributes, &block) }
+      else
+        iterate_array(xml, array, attributes, &block)
+      end
+
+      xml.target!
+    end
+    private_class_method :iterate_with_xml
+
+    # Iterates over a given +array+ with a Hash of +attributes+ and yields a builder +xml+
+    # instance, the current +item+, any XML +attributes+ and the current +index+.
+    def iterate_array(xml, array, attributes, &block)
+      array.each_with_index do |item, index|
+        attrs = if item.respond_to?(:keys)
+          item.each_with_object({}) do |v, st|
+            k = v[0].to_s
+            st[k[1..]] = v[1].to_s if Hash.explicit_attribute?(k)
+          end
+        else
+          {}
+        end
+        yield xml, item, tag_attributes(attributes, index).merge(attrs), index
+      end
+    end
+    private_class_method :iterate_array
+
+    # Takes a Hash of +attributes+ and the +index+ for which to return attributes
+    # for duplicate tags.
+    def tag_attributes(attributes, index)
+      return {} if attributes.empty?
+
+      attributes.inject({}) do |hash, (key, value)|
+        value = value[index] if value.is_a? ::Array
+        value ? hash.merge(key => value) : hash
+      end
+    end
+    private_class_method :tag_attributes
+
+    def unwrap?(unwrap, key)
+      unwrap.is_a?(::Array) ? unwrap.include?(key.to_sym) : unwrap
+    end
+    private_class_method :unwrap?
+  end
+end

data/lib/gyoku/hash.rb

@@ -0,0 +1,105 @@
+require "builder"
+require "gyoku/prettifier"
+require "gyoku/array"
+require "gyoku/xml_key"
+require "gyoku/xml_value"
+
+module Gyoku
+  module Hash
+    module_function
+
+    # Builds XML and prettifies it if +pretty_print+ option is set to +true+
+    def to_xml(hash, options = {})
+      xml = build_xml(hash, options)
+
+      if options[:pretty_print]
+        Prettifier.prettify(xml, options)
+      else
+        xml
+      end
+    end
+
+    # Translates a given +hash+ with +options+ to XML.
+    def build_xml(hash, options = {})
+      iterate_with_xml hash do |xml, key, value, attributes|
+        self_closing = key.to_s[-1, 1] == "/"
+        escape_xml = key.to_s[-1, 1] != "!"
+        xml_key = XMLKey.create key, options
+
+        if :content! === key
+          xml << XMLValue.create(value, escape_xml, options)
+        elsif ::Array === value
+          xml << Array.build_xml(value, xml_key, escape_xml, attributes, options.merge(self_closing: self_closing))
+        elsif ::Hash === value
+          xml.tag!(xml_key, attributes) { xml << build_xml(value, options) }
+        elsif self_closing
+          xml.tag!(xml_key, attributes)
+        elsif NilClass === value
+          xml.tag!(xml_key, "xsi:nil" => "true")
+        else
+          xml.tag!(xml_key, attributes) { xml << XMLValue.create(value, escape_xml, options) }
+        end
+      end
+    end
+
+    def explicit_attribute?(key)
+      key.to_s.start_with?("@")
+    end
+
+    # Iterates over a given +hash+ and yields a builder +xml+ instance, the current
+    # Hash +key+ and any XML +attributes+.
+    #
+    # Keys beginning with "@" are treated as explicit attributes for their container.
+    # You can use both :attributes! and "@" keys to specify attributes.
+    # In the event of a conflict, the "@" key takes precedence.
+    def iterate_with_xml(hash)
+      xml = Builder::XmlMarkup.new
+      attributes = hash[:attributes!] || {}
+      hash_without_attributes = hash.except(:attributes!)
+
+      order(hash_without_attributes).each do |key|
+        node_attr = attributes[key] || {}
+        # node_attr must be kind of ActiveSupport::HashWithIndifferentAccess
+        node_attr = node_attr.map { |k, v| [k.to_s, v] }.to_h
+        node_value = hash[key].respond_to?(:keys) ? hash[key].clone : hash[key]
+
+        if node_value.respond_to?(:keys)
+          explicit_keys = node_value.keys.select { |k| explicit_attribute?(k) }
+          explicit_attr = {}
+          explicit_keys.each { |k| explicit_attr[k.to_s[1..]] = node_value[k] }
+          node_attr.merge!(explicit_attr)
+          explicit_keys.each { |k| node_value.delete(k) }
+
+          tmp_node_value = node_value.delete(:content!)
+          node_value = tmp_node_value unless tmp_node_value.nil?
+          node_value = "" if node_value.respond_to?(:empty?) && node_value.empty?
+        end
+
+        yield xml, key, node_value, node_attr
+      end
+
+      xml.target!
+    end
+    private_class_method :iterate_with_xml
+
+    # Deletes and returns an Array of keys stored under the :order! key of a given +hash+.
+    # Defaults to return the actual keys of the Hash if no :order! key could be found.
+    # Raises an ArgumentError in case the :order! Array does not match the Hash keys.
+    def order(hash)
+      order = hash[:order!] || hash.delete("order!")
+      hash_without_order = hash.except(:order!)
+      order = hash_without_order.keys unless order.is_a? ::Array
+
+      # Ignore Explicit Attributes
+      orderable = order.delete_if { |k| explicit_attribute?(k) }
+      hashable = hash_without_order.keys.select { |k| !explicit_attribute?(k) }
+
+      missing, spurious = hashable - orderable, orderable - hashable
+      raise ArgumentError, "Missing elements in :order! #{missing.inspect}" unless missing.empty?
+      raise ArgumentError, "Spurious elements in :order! #{spurious.inspect}" unless spurious.empty?
+
+      order
+    end
+    private_class_method :order
+  end
+end

data/lib/gyoku/prettifier.rb

@@ -0,0 +1,29 @@
+require "rexml/document"
+
+module Gyoku
+  class Prettifier
+    DEFAULT_INDENT = 2
+    DEFAULT_COMPACT = true
+
+    attr_accessor :indent, :compact
+
+    def self.prettify(xml, options = {})
+      new(options).prettify(xml)
+    end
+
+    def initialize(options = {})
+      @indent = options[:indent] || DEFAULT_INDENT
+      @compact = options[:compact].nil? ? DEFAULT_COMPACT : options[:compact]
+    end
+
+    # Adds intendations and newlines to +xml+ to make it more readable
+    def prettify(xml)
+      result = ""
+      formatter = REXML::Formatters::Pretty.new indent
+      formatter.compact = compact
+      doc = REXML::Document.new xml
+      formatter.write doc, result
+      result
+    end
+  end
+end

data/lib/gyoku/version.rb

@@ -0,0 +1,3 @@
+module Gyoku
+  VERSION = "1.4.1"
+end

data/lib/gyoku/xml_key.rb

@@ -0,0 +1,67 @@
+module Gyoku
+  module XMLKey
+    class << self
+      CAMELCASE = lambda { |key| key.gsub(/\/(.?)/) { |m| "::#{m[-1].upcase}" }.gsub(/(?:^|_)(.)/) { |m| m[-1].upcase } }
+      LOWER_CAMELCASE = lambda { |key| key[0].chr.downcase + CAMELCASE.call(key)[1..] }
+      UPCASE = lambda { |key| key.upcase }
+
+      FORMULAS = {
+        lower_camelcase: lambda { |key| LOWER_CAMELCASE.call(key) },
+        camelcase: lambda { |key| CAMELCASE.call(key) },
+        upcase: lambda { |key| UPCASE.call(key) },
+        none: lambda { |key| key }
+      }
+
+      # Converts a given +object+ with +options+ to an XML key.
+      def create(key, options = {})
+        xml_key = chop_special_characters key.to_s
+
+        if unqualified = unqualify?(xml_key)
+          xml_key = xml_key.split(":").last
+        end
+
+        xml_key = key_converter(options, xml_key).call(xml_key) if Symbol === key
+
+        if !unqualified && qualify?(options) && !xml_key.include?(":")
+          xml_key = "#{options[:namespace]}:#{xml_key}"
+        end
+
+        xml_key
+      end
+
+      private
+
+      # Returns the formula for converting Symbol keys.
+      def key_converter(options, xml_key)
+        return options[:key_converter] if options[:key_converter].is_a? Proc
+
+        defined_key = options[:key_to_convert]
+        key_converter = if !defined_key.nil? && (defined_key == xml_key)
+          options[:key_converter]
+        elsif !defined_key.nil?
+          :lower_camelcase
+        elsif options[:except] == xml_key
+          :lower_camelcase
+        else
+          options[:key_converter] || :lower_camelcase
+        end
+        FORMULAS[key_converter]
+      end
+
+      # Chops special characters from the end of a given +string+.
+      def chop_special_characters(string)
+        ["!", "/"].include?(string[-1, 1]) ? string.chop : string
+      end
+
+      # Returns whether to remove the namespace from a given +key+.
+      def unqualify?(key)
+        key[0, 1] == ":"
+      end
+
+      # Returns whether to namespace all keys (elementFormDefault).
+      def qualify?(options)
+        options[:element_form_default] == :qualified && options[:namespace]
+      end
+    end
+  end
+end

data/lib/gyoku/xml_value.rb

@@ -0,0 +1,41 @@
+require "cgi"
+require "date"
+
+module Gyoku
+  module XMLValue
+    class << self
+      # xs:date format
+      XS_DATE_FORMAT = "%Y-%m-%d"
+
+      # xs:time format
+      XS_TIME_FORMAT = "%H:%M:%S"
+
+      # xs:dateTime format
+      XS_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S%Z"
+
+      # Converts a given +object+ to an XML value.
+      def create(object, escape_xml = true, options = {})
+        case object
+        when Time
+          object.strftime XS_TIME_FORMAT
+        when DateTime
+          object.strftime XS_DATETIME_FORMAT
+        when Date
+          object.strftime XS_DATE_FORMAT
+        when String
+          escape_xml ? CGI.escapeHTML(object) : object
+        when ::Hash
+          Gyoku::Hash.to_xml(object, options)
+        else
+          if object.respond_to?(:to_datetime)
+            create object.to_datetime
+          elsif object.respond_to?(:call)
+            create object.call
+          else
+            object.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gyoku.rb

@@ -0,0 +1,14 @@
+require "gyoku/version"
+require "gyoku/hash"
+
+module Gyoku
+  # Converts a given Hash +key+ with +options+ into an XML tag.
+  def self.xml_tag(key, options = {})
+    XMLKey.create(key, options)
+  end
+
+  # Translates a given +hash+ with +options+ to XML.
+  def self.xml(hash, options = {})
+    Hash.to_xml hash.dup, options
+  end
+end

data/spec/gyoku/array_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+describe Gyoku::Array do
+  describe ".to_xml" do
+    it "returns the XML for an Array of Hashes" do
+      array = [{name: "adam"}, {name: "eve"}]
+      result = "<user><name>adam</name></user><user><name>eve</name></user>"
+
+      expect(to_xml(array, "user")).to eq(result)
+    end
+
+    it "returns the XML for an Array of Hashes unwrapped" do
+      array = [{name: "adam"}, {name: "eve"}]
+      result = "<user><name>adam</name><name>eve</name></user>"
+
+      expect(to_xml(array, "user", true, {}, unwrap: true)).to eq(result)
+    end
+
+    it "returns the XML for an Array of different Objects" do
+      array = [:symbol, "string", 123]
+      result = "<value>symbol</value><value>string</value><value>123</value>"
+
+      expect(to_xml(array, "value")).to eq(result)
+    end
+
+    it "defaults to escape special characters" do
+      array = ["<tag />", "adam & eve"]
+      result = "<value>&lt;tag /&gt;</value><value>adam &amp; eve</value>"
+
+      expect(to_xml(array, "value")).to eq(result)
+    end
+
+    it "does not escape special characters when told to" do
+      array = ["<tag />", "adam & eve"]
+      result = "<value><tag /></value><value>adam & eve</value>"
+
+      expect(to_xml(array, "value", false)).to eq(result)
+    end
+
+    it "adds attributes to a given tag" do
+      array = ["adam", "eve"]
+      result = '<value active="true">adam</value><value active="true">eve</value>'
+
+      expect(to_xml(array, "value", :escape_xml, active: true)).to eq(result)
+    end
+
+    it "adds attributes to tags when :unwrap is true" do
+      array = [{item: "abc"}]
+      key = "items"
+      escape_xml = :escape_xml
+      attributes = {"amount" => "1"}
+      options = {unwrap: true}
+      result = "<items amount=\"1\"><item>abc</item></items>"
+
+      expect(to_xml(array, key, escape_xml, attributes, options)).to eq result
+    end
+
+    it "adds attributes to duplicate tags" do
+      array = ["adam", "eve"]
+      result = '<value id="1">adam</value><value id="2">eve</value>'
+
+      expect(to_xml(array, "value", :escape_xml, id: [1, 2])).to eq(result)
+    end
+
+    it "skips attribute for element without attributes if there are fewer attributes than elements" do
+      array = ["adam", "eve", "serpent"]
+      result = '<value id="1">adam</value><value id="2">eve</value><value>serpent</value>'
+
+      expect(to_xml(array, "value", :escape_xml, id: [1, 2])).to eq(result)
+    end
+
+    it "handles nested Arrays" do
+      array = [["one", "two"]]
+      result = "<value><element>one</element><element>two</element></value>"
+
+      expect(to_xml(array, "value")).to eq(result)
+    end
+
+    context "when :pretty_print option is set to true" do
+      context "when :unwrap option is set to true" do
+        it "returns prettified xml" do
+          array = ["one", "two", {"three" => "four"}]
+          options = {pretty_print: true, unwrap: true}
+          result = "<test>\n  <test>one</test>\n  <test>two</test>\n  <three>four</three>\n</test>"
+          expect(to_xml(array, "test", true, {}, options)).to eq(result)
+        end
+
+        context "when :indent option is specified" do
+          it "returns prettified xml with specified indent" do
+            array = ["one", "two", {"three" => "four"}]
+            options = {pretty_print: true, indent: 3, unwrap: true}
+            result = "<test>\n   <test>one</test>\n   <test>two</test>\n   <three>four</three>\n</test>"
+            expect(to_xml(array, "test", true, {}, options)).to eq(result)
+          end
+        end
+
+        context "when :compact option is specified" do
+          it "returns prettified xml with specified compact mode" do
+            array = ["one", {"two" => "three"}]
+            options = {pretty_print: true, compact: false, unwrap: true}
+            result = "<test>\n  <test>\n    one\n  </test>\n  <two>\n     three \n  </two>\n</test>"
+            expect(to_xml(array, "test", true, {}, options)).to eq(result)
+          end
+        end
+      end
+
+      context "when :unwrap option is not set" do
+        it "returns non-prettified xml" do
+          array = ["one", "two", {"three" => "four"}]
+          options = {pretty_print: true}
+          result = "<test>one</test><test>two</test><test><three>four</three></test>"
+          expect(to_xml(array, "test", true, {}, options)).to eq(result)
+        end
+      end
+    end
+  end
+
+  def to_xml(*args)
+    Gyoku::Array.to_xml(*args)
+  end
+end