ukoyg 1.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ff90c95ea012b4f4d758ecd2a0bd412f6a202f9
+  data.tar.gz: e46bfe2880291b6edeff7ea2dd186989c98a7a99
+SHA512:
+  metadata.gz: de9f264a8abd31fd1f66d371bc80307db69d233e5bf81ac08adf8c1d72f53ad2cd4103aa986a805e30445c07263f8f716dbdb06bfd7599a21b540550d8fe4b77
+  data.tar.gz: c3614922b185dbf2d2a1d8beee510ef35f4dd8a0050d5c6df077ac0b0dd72b55c2afaa34ed0e4e5c8450963dc73a36f0bd88595766081909ae83af0f961a4ebe

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Daniel Harrington
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,192 @@
+# Ukoyg
+
+Ukoyg translates Ruby Hashes to XML.
+
+``` ruby
+Ukoyg.xml(:find_user => { :id => 123, "v1:Key" => "api" })
+# => "<findUser><id>123</id><v1:Key>api</v1:Key></findUser>"
+```
+
+[![Build Status](https://secure.travis-ci.org/savonrb/ukoyg.png?branch=master)](http://travis-ci.org/savonrb/ukoyg)
+[![Gem Version](https://badge.fury.io/rb/ukoyg.png)](http://badge.fury.io/rb/ukoyg)
+[![Code Climate](https://codeclimate.com/github/savonrb/ukoyg.png)](https://codeclimate.com/github/savonrb/ukoyg)
+[![Coverage Status](https://coveralls.io/repos/savonrb/ukoyg/badge.png?branch=master)](https://coveralls.io/r/savonrb/ukoyg)
+
+
+## Installation
+
+Ukoyg is available through [Rubygems](http://rubygems.org/gems/ukoyg) and can be installed via:
+
+``` bash
+$ gem install ukoyg
+```
+
+or add it to your Gemfile like this:
+
+``` ruby
+gem 'ukoyg', '~> 1.0'
+```
+
+
+## Hash keys
+
+Hash key Symbols are converted to lowerCamelCase Strings.
+
+``` ruby
+Ukoyg.xml(:lower_camel_case => "key")
+# => "<lowerCamelCase>key</lowerCamelCase>"
+```
+
+You can change the default conversion formula to `:camelcase`, `:upcase` or `:none`.  
+Note that options are passed as a second Hash to the `.xml` method.
+
+``` ruby
+Ukoyg.xml({ :camel_case => "key" }, { :key_converter => :camelcase })
+# => "<CamelCase>key</CamelCase>"
+```
+
+Hash key Strings are not converted and may contain namespaces.
+
+``` ruby
+Ukoyg.xml("XML" => "key")
+# => "<XML>key</XML>"
+```
+
+
+## Hash values
+
+* DateTime objects are converted to xs:dateTime Strings
+* Objects responding to :to_datetime (except Strings) are converted to xs:dateTime Strings
+* TrueClass and FalseClass objects are converted to "true" and "false" Strings
+* NilClass objects are converted to xsi:nil tags
+* These conventions are also applied to the return value of objects responding to :call
+* All other objects are converted to Strings using :to_s
+
+
+## Special characters
+
+Ukoyg escapes special characters unless the Hash key ends with an exclamation mark.
+
+``` ruby
+Ukoyg.xml(:escaped => "<tag />", :not_escaped! => "<tag />")
+# => "<escaped>&lt;tag /&gt;</escaped><notEscaped><tag /></notEscaped>"
+```
+
+
+## Self-closing tags
+
+Hash Keys ending with a forward slash create self-closing tags.
+
+``` ruby
+Ukoyg.xml(:"self_closing/" => "", "selfClosing/" => nil)
+# => "<selfClosing/><selfClosing/>"
+```
+
+
+## Sort XML tags
+
+In case you need the XML tags to be in a specific order, you can specify the order  
+through an additional Array stored under the `:order!` key.
+
+``` ruby
+Ukoyg.xml(:name => "Eve", :id => 1, :order! => [:id, :name])
+# => "<id>1</id><name>Eve</name>"
+```
+
+
+## XML attributes
+
+Adding XML attributes is rather ugly, but it can be done by specifying an additional  
+Hash stored under the`:attributes!` key.
+
+``` ruby
+Ukoyg.xml(:person => "Eve", :attributes! => { :person => { :id => 1 } })
+# => "<person id=\"1\">Eve</person>"
+```
+
+## Explicit XML Attributes
+
+In addition to using the `:attributes!` key, you may also specify attributes through keys beginning with an "@" sign.
+Since you'll need to set the attribute within the hash containing the node's contents, a `:content!` key can be used
+to explicity set the content of the node. The `:content!` value may be a String, Hash, or Array.
+
+This is particularly useful for self-closing tags.
+
+**Using :attributes!**
+
+``` ruby
+Ukoyg.xml(
+  "foo/" => "", 
+  :attributes! => {
+    "foo/" => {
+      "bar" => "1", 
+      "biz" => "2", 
+      "baz" => "3"
+    }
+  }
+)
+# => "<foo baz=\"3\" bar=\"1\" biz=\"2\"/>"
+```
+
+**Using "@" keys and ":content!"**
+
+``` ruby
+Ukoyg.xml(
+  "foo/" => {
+    :@bar => "1",
+    :@biz => "2",
+    :@baz => "3",
+    :content! => ""
+  })
+# => "<foo baz=\"3\" bar=\"1\" biz=\"2\"/>"
+```
+
+**Example using "@" to get Array of parent tags each with @attributes & :content!**
+
+``` ruby
+Ukoyg.xml(
+  "foo" => [
+    {:@name => "bar", :content! => 'ukoyg'}
+    {:@name => "baz", :@some => "attr", :content! => 'rocks!'}
+  ])
+# => "<foo name=\"bar\">ukoyg</foo><foo name=\"baz\" some=\"attr\">rocks!</foo>"
+```
+
+Naturally, it would ignore :content! if tag is self-closing:
+
+``` ruby
+Ukoyg.xml(
+  "foo/" => [
+    {:@name => "bar", :content! => 'ukoyg'}
+    {:@name => "baz", :@some => "attr", :content! => 'rocks!'}
+  ])
+# => "<foo name=\"bar\"/><foo name=\"baz\" some=\"attr\"/>"
+```
+
+This seems a bit more explicit with the attributes rather than having to maintain a hash of attributes.
+
+For backward compatibility, `:attributes!` will still work. However, "@" keys will override `:attributes!` keys
+if there is a conflict.
+
+``` ruby
+Ukoyg.xml(:person => {:content! => "Adam", :@id! => 0})
+# => "<person id=\"0\">Adam</person>"
+```
+
+**Example with ":content!", :attributes! and "@" keys**
+
+``` ruby
+Ukoyg.xml({ 
+  :subtitle => { 
+    :@lang => "en", 
+    :content! => "It's Godzilla!" 
+  }, 
+  :attributes! => { :subtitle => { "lang" => "jp" } } 
+}
+# => "<subtitle lang=\"en\">It's Godzilla!</subtitle>"
+```
+
+The example above shows an example of how you can use all three at the same time. 
+
+Notice that we have the attribute "lang" defined twice.
+The `@lang` value takes precedence over the `:attribute![:subtitle]["lang"]` value.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler"
+require "bundler/setup"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-c)
+end
+
+task :default => :spec
+task :test => :spec

data/lib/ukoyg.rb

@@ -0,0 +1,16 @@
+require "ukoyg/version"
+require "ukoyg/hash"
+
+module Ukoyg
+
+  # 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/lib/ukoyg/array.rb

@@ -0,0 +1,89 @@
+require "builder"
+
+require "ukoyg/hash"
+require "ukoyg/xml_value"
+
+module Ukoyg
+  class Array
+
+    NESTED_ELEMENT_NAME = "element"
+
+    # 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.to_xml(array, key, escape_xml = true, attributes = {}, options = {})
+
+      self_closing = options.delete(:self_closing)
+      unwrap = options[:unwrap] || false 
+
+      iterate_with_xml array, key, attributes, options do |xml, item, attrs, index|
+        if self_closing
+          xml.tag!(key, attrs)
+        else
+          case item
+            when ::Hash       then 
+              if unwrap
+                xml << Hash.to_xml(item, options)
+              else
+                xml.tag!(key, attrs) { xml << Hash.to_xml(item, options) }
+              end
+            when ::Array      then 
+              xml.tag!(key, attrs) { xml << Array.to_xml(item, NESTED_ELEMENT_NAME) }
+            when NilClass     then 
+              xml.tag!(key, "xsi:nil" => "true")
+            else              
+              xml.tag!(key, attrs) { xml << XMLValue.create(item, escape_xml) }
+          end
+        end
+      end
+    end
+
+  private
+
+    # 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 self.iterate_with_xml(array, key, attributes, options, &block)
+
+      xml = Builder::XmlMarkup.new
+      unwrap = options[:unwrap] || false
+
+      if (unwrap)
+        xml.tag!(key) { iterate_array(xml, array, attributes, &block) }
+      else
+        iterate_array(xml, array, attributes, &block)
+      end
+
+      xml.target!
+    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 self.iterate_array(xml, array, attributes, &block)
+      array.each_with_index do |item, index|
+        if item.respond_to?(:keys)
+          attrs = item.reduce({}) do |st, v|
+            k = v[0].to_s
+            st[k[1..-1]] = v[1].to_s if k =~ /^@/
+            st
+          end
+        else
+          attrs = {}
+        end
+        yield xml, item, tag_attributes(attributes, index).merge(attrs), index
+      end
+    end
+
+
+    # Takes a Hash of +attributes+ and the +index+ for which to return attributes
+    # for duplicate tags.
+    def self.tag_attributes(attributes, index)
+      return {} if attributes.empty?
+
+      attributes.inject({}) do |hash, (key, value)|
+        value = value[index] if value.kind_of? ::Array
+        value ? hash.merge(key => value) : hash
+      end
+    end
+
+  end
+end

data/lib/ukoyg/hash.rb

@@ -0,0 +1,85 @@
+require "builder"
+
+require "ukoyg/array"
+require "ukoyg/xml_key"
+require "ukoyg/xml_value"
+
+module Ukoyg
+  class Hash
+
+    # Translates a given +hash+ with +options+ to XML.
+    def self.to_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
+
+        case
+          when :content! === key  then xml << XMLValue.create(value, escape_xml)
+          when ::Array === value  then xml << Array.to_xml(value, xml_key, escape_xml, attributes, options.merge(:self_closing => self_closing))
+          when ::Hash === value   then xml.tag!(xml_key, attributes) { xml << Hash.to_xml(value, options) }
+          when self_closing       then xml.tag!(xml_key, attributes)
+          when NilClass === value then xml.tag!(xml_key, "xsi:nil" => "true")
+          else                         xml.tag!(xml_key, attributes) { xml << XMLValue.create(value, escape_xml) }
+        end
+      end
+    end
+
+  private
+
+    # 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 self.iterate_with_xml(hash)
+      xml = Builder::XmlMarkup.new
+      attributes = hash[:attributes!] || {}
+      hash_without_attributes = hash.reject { |key, value| key == :attributes! }
+
+      order(hash_without_attributes).each do |key| 
+        node_attr = attributes[key] || {}
+        # node_attr must be kind of ActiveSupport::HashWithIndifferentAccess
+        node_attr = ::Hash[node_attr.map { |k,v| [k.to_s, v] }]
+        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| k.to_s =~ /^@/ }
+          explicit_attr = {}
+          explicit_keys.each{|k| explicit_attr[k.to_s[1..-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
+
+    # 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 self.order(hash)
+      order = hash[:order!] || hash.delete('order!')
+      hash_without_order = hash.reject { |key, value| key == :order! }
+      order = hash_without_order.keys unless order.kind_of? ::Array
+
+      # Ignore Explicit Attributes
+      orderable = order.delete_if{|k| k.to_s =~ /^@/ }
+      hashable = hash_without_order.keys.select{|k| !(k.to_s =~ /^@/) }
+
+      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
+
+  end
+end

data/lib/ukoyg/version.rb

@@ -0,0 +1,3 @@
+module Ukoyg
+  VERSION = '1.2.3'
+end

data/lib/ukoyg/xml_key.rb

@@ -0,0 +1,69 @@
+module Ukoyg
+  module XMLKey
+    class << self
+
+      CAMELCASE       = lambda { |key| key.gsub(/\/(.?)/) { |m| "::#{m.split('').last.upcase}" }.gsub(/(?:^|_)(.)/) { |m| m.split('').last.upcase } }
+      LOWER_CAMELCASE = lambda { |key| key[0].chr.downcase + CAMELCASE.call(key)[1..-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]
+        if (defined_key != nil) && (defined_key == xml_key)
+          key_converter = options[:key_converter]
+        elsif defined_key != nil
+          key_converter = :lower_camelcase
+        elsif (options[:except] == xml_key)
+          key_converter = :lower_camelcase
+        else
+          key_converter = 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/ukoyg/xml_value.rb

@@ -0,0 +1,38 @@
+require "cgi"
+require "date"
+
+module Ukoyg
+  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)
+        if Time === object
+          object.strftime XS_TIME_FORMAT
+        elsif DateTime === object
+          object.strftime XS_DATETIME_FORMAT
+        elsif Date === object
+          object.strftime XS_DATE_FORMAT
+        elsif String === object
+          escape_xml ? CGI.escapeHTML(object) : object
+        elsif 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

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ukoyg
+version: !ruby/object:Gem::Version
+  version: 1.2.3
+platform: ruby
+authors:
+- Daniel Harrington
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ukoyg translates Ruby Hashes to XML
+email: me@rubiii.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/ukoyg.rb
+- lib/ukoyg/array.rb
+- lib/ukoyg/hash.rb
+- lib/ukoyg/version.rb
+- lib/ukoyg/xml_key.rb
+- lib/ukoyg/xml_value.rb
+homepage: https://github.com/savonrb/ukoyg
+licenses:
+- MIT
+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: ukoyg
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Translates Ruby Hashes to XML
+test_files: []