allegro_api_client 0.0.1

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2013 Erik Michaels-Ober
+
+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/gems/ruby/2.1.0/gems/multi_xml-0.5.5/README.md

@@ -0,0 +1,97 @@
+# MultiXML
+
+[![Gem Version](https://badge.fury.io/rb/multi_xml.png)][gem]
+[![Build Status](https://secure.travis-ci.org/sferik/multi_xml.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/sferik/multi_xml.png?travis)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/sferik/multi_xml.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/sferik/multi_xml/badge.png?branch=master)][coveralls]
+
+[gem]: https://rubygems.org/gems/multi_xml
+[travis]: http://travis-ci.org/sferik/multi_xml
+[gemnasium]: https://gemnasium.com/sferik/multi_xml
+[codeclimate]: https://codeclimate.com/github/sferik/multi_xml
+[coveralls]: https://coveralls.io/r/sferik/multi_xml
+
+A generic swappable back-end for XML parsing
+
+## Installation
+    gem install multi_xml
+
+To ensure the code you're installing hasn't been tampered with, it's
+recommended that you verify the signature. To do this, you need to add my
+public key as a trusted certificate (you only need to do this once):
+
+    gem cert --add <(curl -Ls https://raw.github.com/sferik/multi_xml/master/certs/sferik.pem)
+
+Then, install the gem with the high security trust policy:
+
+    gem install multi_xml -P HighSecurity
+
+## Documentation
+[http://rdoc.info/gems/multi_xml][documentation]
+
+[documentation]: http://rdoc.info/gems/multi_xml
+
+## Usage Examples
+Lots of Ruby libraries utilize XML parsing in some form, and everyone has their
+favorite XML library. In order to best support multiple XML parsers and
+libraries, `multi_xml` is a general-purpose swappable XML backend library. You
+use it like so:
+```ruby
+require 'multi_xml'
+
+MultiXml.parser = :ox
+MultiXml.parser = MultiXml::Parsers::Ox # Same as above
+MultiXml.parse('<tag>This is the contents</tag>') # Parsed using Ox
+
+MultiXml.parser = :libxml
+MultiXml.parser = MultiXml::Parsers::Libxml # Same as above
+MultiXml.parse('<tag>This is the contents</tag>') # Parsed using LibXML
+
+MultiXml.parser = :nokogiri
+MultiXml.parser = MultiXml::Parsers::Nokogiri # Same as above
+MultiXml.parse('<tag>This is the contents</tag>') # Parsed using Nokogiri
+
+MultiXml.parser = :rexml
+MultiXml.parser = MultiXml::Parsers::Rexml # Same as above
+MultiXml.parse('<tag>This is the contents</tag>') # Parsed using REXML
+```
+The `parser` setter takes either a symbol or a class (to allow for custom XML
+parsers) that responds to `.parse` at the class level.
+
+MultiXML tries to have intelligent defaulting. That is, if you have any of the
+supported parsers already loaded, it will utilize them before attempting to
+load any. When loading, libraries are ordered by speed: first Ox, then LibXML,
+then Nokogiri, and finally REXML.
+
+## Supported Ruby Versions
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.8.7
+* Ruby 1.9.2
+* Ruby 1.9.3
+* Ruby 2.0.0
+
+If something doesn't work on one of these interpreters, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby
+implementations, however support will only be provided for the versions listed
+above.
+
+If you would like this library to support another Ruby version, you may
+volunteer to be a maintainer. Being a maintainer entails making sure all tests
+run and pass on that implementation. When something breaks on your
+implementation, you will be responsible for providing patches in a timely
+fashion. If critical issues for a particular implementation exist at the time
+of a major release, support for that Ruby version may be dropped.
+
+## Inspiration
+MultiXML was inspired by [MultiJSON][].
+
+[multijson]: https://github.com/intridea/multi_json/
+
+## Copyright
+Copyright (c) 2010-2013 Erik Michaels-Ober. See [LICENSE][] for details.
+
+[license]: LICENSE.md

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec
+
+namespace :doc do
+  require 'yard'
+  YARD::Rake::YardocTask.new do |task|
+    task.files   = ['lib/**/*.rb', '-', 'LICENSE.md']
+    task.options = [
+      '--no-private',
+      '--protected',
+      '--output-dir', 'doc/yard',
+      '--markup', 'markdown',
+    ]
+  end
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml.rb

@@ -0,0 +1,296 @@
+require 'base64'
+require 'bigdecimal'
+require 'date'
+require 'stringio'
+require 'time'
+require 'yaml'
+
+module MultiXml
+  class ParseError < StandardError; end
+  class DisallowedTypeError < StandardError
+    def initialize(type)
+      super "Disallowed type attribute: #{type.inspect}"
+    end
+  end
+
+  REQUIREMENT_MAP = [
+    ['ox', :ox],
+    ['libxml', :libxml],
+    ['nokogiri', :nokogiri],
+    ['rexml/document', :rexml]
+  ] unless defined?(REQUIREMENT_MAP)
+
+  CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+
+  unless defined?(PARSING)
+    PARSING = {
+      'symbol'       => Proc.new{|symbol| symbol.to_sym},
+      'date'         => Proc.new{|date| Date.parse(date)},
+      'datetime'     => Proc.new{|time| Time.parse(time).utc rescue DateTime.parse(time).utc},
+      'integer'      => Proc.new{|integer| integer.to_i},
+      'float'        => Proc.new{|float| float.to_f},
+      'decimal'      => Proc.new{|number| BigDecimal(number)},
+      'boolean'      => Proc.new{|boolean| !%w(0 false).include?(boolean.strip)},
+      'string'       => Proc.new{|string| string.to_s},
+      'yaml'         => Proc.new{|yaml| YAML::load(yaml) rescue yaml},
+      'base64Binary' => Proc.new{|binary| ::Base64.decode64(binary)},
+      'binary'       => Proc.new{|binary, entity| parse_binary(binary, entity)},
+      'file'         => Proc.new{|file, entity| parse_file(file, entity)},
+    }
+
+    PARSING.update(
+      'double'   => PARSING['float'],
+      'dateTime' => PARSING['datetime']
+    )
+  end
+
+  TYPE_NAMES = {
+    'Symbol'     => 'symbol',
+    'Fixnum'     => 'integer',
+    'Bignum'     => 'integer',
+    'BigDecimal' => 'decimal',
+    'Float'      => 'float',
+    'TrueClass'  => 'boolean',
+    'FalseClass' => 'boolean',
+    'Date'       => 'date',
+    'DateTime'   => 'datetime',
+    'Time'       => 'datetime',
+    'Array'      => 'array',
+    'Hash'       => 'hash'
+  } unless defined?(TYPE_NAMES)
+
+  DISALLOWED_XML_TYPES = %w(symbol yaml)
+
+  DEFAULT_OPTIONS = {
+    :typecast_xml_value => true,
+    :disallowed_types => DISALLOWED_XML_TYPES,
+    :symbolize_keys => false
+  }
+
+  class << self
+    # Get the current parser class.
+    def parser
+      return @parser if defined?(@parser)
+      self.parser = self.default_parser
+      @parser
+    end
+
+    # The default parser based on what you currently
+    # have loaded and installed. First checks to see
+    # if any parsers are already loaded, then checks
+    # to see which are installed if none are loaded.
+    def default_parser
+      return :ox if defined?(::Ox)
+      return :libxml if defined?(::LibXML)
+      return :nokogiri if defined?(::Nokogiri)
+
+      REQUIREMENT_MAP.each do |library, parser|
+        begin
+          require library
+          return parser
+        rescue LoadError
+          next
+        end
+      end
+    end
+
+    # Set the XML parser utilizing a symbol, string, or class.
+    # Supported by default are:
+    #
+    # * <tt>:libxml</tt>
+    # * <tt>:nokogiri</tt>
+    # * <tt>:ox</tt>
+    # * <tt>:rexml</tt>
+    def parser=(new_parser)
+      case new_parser
+      when String, Symbol
+        require "multi_xml/parsers/#{new_parser.to_s.downcase}"
+        @parser = MultiXml::Parsers.const_get("#{new_parser.to_s.split('_').map{|s| s.capitalize}.join('')}")
+      when Class, Module
+        @parser = new_parser
+      else
+        raise "Did not recognize your parser specification. Please specify either a symbol or a class."
+      end
+    end
+
+    # Parse an XML string or IO into Ruby.
+    #
+    # <b>Options</b>
+    #
+    # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
+    #
+    # <tt>:disallowed_types</tt> :: Types to disallow from being typecasted. Defaults to `['yaml', 'symbol']`. Use `[]` to allow all types.
+    #
+    # <tt>:typecast_xml_value</tt> :: If true, won't typecast values for parsed document
+    def parse(xml, options={})
+      xml ||= ''
+
+      options = DEFAULT_OPTIONS.merge(options)
+
+      xml.strip! if xml.respond_to?(:strip!)
+      begin
+        xml = StringIO.new(xml) unless xml.respond_to?(:read)
+
+        char = xml.getc
+        return {} if char.nil?
+        xml.ungetc(char)
+
+        hash = undasherize_keys(parser.parse(xml) || {})
+        hash = options[:typecast_xml_value] ? typecast_xml_value(hash, options[:disallowed_types]) : hash
+      rescue DisallowedTypeError
+        raise
+      rescue parser.parse_error => error
+        raise ParseError, error.message, error.backtrace
+      end
+      hash = symbolize_keys(hash) if options[:symbolize_keys]
+      hash
+    end
+
+    # This module decorates files with the <tt>original_filename</tt>
+    # and <tt>content_type</tt> methods.
+    module FileLike #:nodoc:
+      attr_writer :original_filename, :content_type
+
+      def original_filename
+        @original_filename || 'untitled'
+      end
+
+      def content_type
+        @content_type || 'application/octet-stream'
+      end
+    end
+
+    private
+
+    # TODO: Add support for other encodings
+    def parse_binary(binary, entity) #:nodoc:
+      case entity['encoding']
+      when 'base64'
+        Base64.decode64(binary)
+      else
+        binary
+      end
+    end
+
+    def parse_file(file, entity)
+      f = StringIO.new(Base64.decode64(file))
+      f.extend(FileLike)
+      f.original_filename = entity['name']
+      f.content_type = entity['content_type']
+      f
+    end
+
+    def symbolize_keys(params)
+      case params
+      when Hash
+        params.inject({}) do |result, (key, value)|
+          result.merge(key.to_sym => symbolize_keys(value))
+        end
+      when Array
+        params.map{|value| symbolize_keys(value)}
+      else
+        params
+      end
+    end
+
+    def undasherize_keys(params)
+      case params
+      when Hash
+        params.inject({}) do |hash, (key, value)|
+          hash[key.to_s.tr('-', '_')] = undasherize_keys(value)
+          hash
+        end
+      when Array
+        params.map{|value| undasherize_keys(value)}
+      else
+        params
+      end
+    end
+
+    def typecast_xml_value(value, disallowed_types=nil)
+      disallowed_types ||= DISALLOWED_XML_TYPES
+
+      case value
+      when Hash
+        if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
+          raise DisallowedTypeError, value['type']
+        end
+
+        if value['type'] == 'array'
+
+          # this commented-out suggestion helps to avoid the multiple attribute
+          # problem, but it breaks when there is only one item in the array.
+          #
+          # from: https://github.com/jnunemaker/httparty/issues/102
+          #
+          # _, entries = value.detect { |k, v| k != 'type' && v.is_a?(Array) }
+
+          # This attempt fails to consider the order that the detect method
+          # retrieves the entries.
+          #_, entries = value.detect {|key, _| key != 'type'}
+
+          # This approach ignores attribute entries that are not convertable
+          # to an Array which allows attributes to be ignored.
+          _, entries = value.detect {|k, v| k != 'type' && (v.is_a?(Array) || v.is_a?(Hash)) }
+
+          if entries.nil? || (entries.is_a?(String) && entries.strip.empty?)
+            []
+          else
+            case entries
+            when Array
+              entries.map {|entry| typecast_xml_value(entry, disallowed_types)}
+            when Hash
+              [typecast_xml_value(entries, disallowed_types)]
+            else
+              raise "can't typecast #{entries.class.name}: #{entries.inspect}"
+            end
+          end
+        elsif value.has_key?(CONTENT_ROOT)
+          content = value[CONTENT_ROOT]
+          if block = PARSING[value['type']]
+            if block.arity == 1
+              value.delete('type') if PARSING[value['type']]
+              if value.keys.size > 1
+                value[CONTENT_ROOT] = block.call(content)
+                value
+              else
+                block.call(content)
+              end
+            else
+              block.call(content, value)
+            end
+          else
+            value.keys.size > 1 ? value : content
+          end
+        elsif value['type'] == 'string' && value['nil'] != 'true'
+          ''
+        # blank or nil parsed values are represented by nil
+        elsif value.empty? || value['nil'] == 'true'
+          nil
+        # If the type is the only element which makes it then
+        # this still makes the value nil, except if type is
+        # a XML node(where type['value'] is a Hash)
+        elsif value['type'] && value.size == 1 && !value['type'].is_a?(Hash)
+          nil
+        else
+          xml_value = value.inject({}) do |hash, (k, v)|
+            hash[k] = typecast_xml_value(v, disallowed_types)
+            hash
+          end
+
+          # Turn {:files => {:file => #<StringIO>} into {:files => #<StringIO>} so it is compatible with
+          # how multipart uploaded files from HTML appear
+          xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
+        end
+      when Array
+        value.map!{|i| typecast_xml_value(i, disallowed_types)}
+        value.length > 1 ? value : value.first
+      when String
+        value
+      else
+        raise "can't typecast #{value.class.name}: #{value.inspect}"
+      end
+    end
+  end
+
+end

data/gems/ruby/2.1.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/libxml.rb

@@ -0,0 +1,30 @@
+require 'libxml' unless defined?(LibXML)
+require 'multi_xml/parsers/libxml2_parser'
+
+module MultiXml
+  module Parsers
+    module Libxml #:nodoc:
+      include Libxml2Parser
+
+      extend self
+
+      def parse_error() ::LibXML::XML::Error end
+
+      def parse(xml)
+        node_to_hash(LibXML::XML::Parser.io(xml).parse.root)
+      end
+
+      def each_child(node, &block)
+        node.each_child(&block)
+      end
+
+      def each_attr(node, &block)
+        node.each_attr(&block)
+      end
+
+      def node_name(node)
+        node.name
+      end
+    end
+  end
+end