vagrant-unbundled 2.2.19.0 → 2.3.3.0

data/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/README.md

@@ -1,192 +0,0 @@
-# Gyoku
-
-Gyoku translates Ruby Hashes to XML.
-
-``` ruby
-Gyoku.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/gyoku.png?branch=master)](http://travis-ci.org/savonrb/gyoku)
-[![Gem Version](https://badge.fury.io/rb/gyoku.png)](http://badge.fury.io/rb/gyoku)
-[![Code Climate](https://codeclimate.com/github/savonrb/gyoku.png)](https://codeclimate.com/github/savonrb/gyoku)
-[![Coverage Status](https://coveralls.io/repos/savonrb/gyoku/badge.png?branch=master)](https://coveralls.io/r/savonrb/gyoku)
-
-
-## Installation
-
-Gyoku is available through [Rubygems](http://rubygems.org/gems/gyoku) and can be installed via:
-
-``` bash
-$ gem install gyoku
-```
-
-or add it to your Gemfile like this:
-
-``` ruby
-gem 'gyoku', '~> 1.0'
-```
-
-
-## Hash keys
-
-Hash key Symbols are converted to lowerCamelCase Strings.
-
-``` ruby
-Gyoku.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
-Gyoku.xml({ :camel_case => "key" }, { :key_converter => :camelcase })
-# => "<CamelCase>key</CamelCase>"
-```
-
-Hash key Strings are not converted and may contain namespaces.
-
-``` ruby
-Gyoku.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
-
-Gyoku escapes special characters unless the Hash key ends with an exclamation mark.
-
-``` ruby
-Gyoku.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
-Gyoku.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
-Gyoku.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
-Gyoku.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
-Gyoku.xml(
-  "foo/" => "", 
-  :attributes! => {
-    "foo/" => {
-      "bar" => "1", 
-      "biz" => "2", 
-      "baz" => "3"
-    }
-  }
-)
-# => "<foo baz=\"3\" bar=\"1\" biz=\"2\"/>"
-```
-
-**Using "@" keys and ":content!"**
-
-``` ruby
-Gyoku.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
-Gyoku.xml(
-  "foo" => [
-    {:@name => "bar", :content! => 'gyoku'}
-    {:@name => "baz", :@some => "attr", :content! => 'rocks!'}
-  ])
-# => "<foo name=\"bar\">gyoku</foo><foo name=\"baz\" some=\"attr\">rocks!</foo>"
-```
-
-Naturally, it would ignore :content! if tag is self-closing:
-
-``` ruby
-Gyoku.xml(
-  "foo/" => [
-    {:@name => "bar", :content! => 'gyoku'}
-    {:@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
-Gyoku.xml(:person => {:content! => "Adam", :@id! => 0})
-# => "<person id=\"0\">Adam</person>"
-```
-
-**Example with ":content!", :attributes! and "@" keys**
-
-``` ruby
-Gyoku.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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/Rakefile

@@ -1,12 +0,0 @@
-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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/gyoku.gemspec

@@ -1,27 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "gyoku/version"
-
-Gem::Specification.new do |s|
-  s.name        = "gyoku"
-  s.version     = Gyoku::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = "Daniel Harrington"
-  s.email       = "me@rubiii.com"
-  s.homepage    = "https://github.com/savonrb/#{s.name}"
-  s.summary     = "Translates Ruby Hashes to XML"
-  s.description = "Gyoku translates Ruby Hashes to XML"
-  s.required_ruby_version = '>= 1.9.2'
-
-  s.rubyforge_project = "gyoku"
-  s.license = "MIT"
-
-  s.add_dependency "builder", ">= 2.1.2"
-
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end

data/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku/array.rb

@@ -1,89 +0,0 @@
-require "builder"
-
-require "gyoku/hash"
-require "gyoku/xml_value"
-
-module Gyoku
-  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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku/hash.rb

@@ -1,85 +0,0 @@
-require "builder"
-
-require "gyoku/array"
-require "gyoku/xml_key"
-require "gyoku/xml_value"
-
-module Gyoku
-  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, options)
-          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, options) }
-        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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku/version.rb

@@ -1,3 +0,0 @@
-module Gyoku
-  VERSION = '1.3.1'
-end

data/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku/xml_key.rb

@@ -1,69 +0,0 @@
-module Gyoku
-  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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku/xml_value.rb

@@ -1,40 +0,0 @@
-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 = {})
-        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
-        elsif ::Hash === object
-          Gyoku::Hash.to_xml(object, options)
-        else
-          object.to_s
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/lib/gyoku.rb

@@ -1,16 +0,0 @@
-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/vendor/bundle/ruby/3.0.0/gems/gyoku-1.3.1/spec/gyoku/array_spec.rb

@@ -1,74 +0,0 @@
-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 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
-  end
-
-  def to_xml(*args)
-    Gyoku::Array.to_xml *args
-  end
-
-end