plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/ox.rb

@@ -0,0 +1,97 @@
+require 'ox' unless defined?(Ox)
+
+# Each MultiXml parser is expected to parse an XML document into a Hash. The
+# conversion rules are:
+#
+# - Each document starts out as an empty Hash.
+#
+# - Reading an element created an entry in the parent Hash that has a key of
+#   the element name and a value of a Hash with attributes as key value
+#   pairs. Children are added as described by this rule.
+#
+# - Text and CDATE is stored in the parent element Hash with a key of
+#   MultiXml::CONTENT_ROOT and a value of the text itself.
+#
+# - If a key already exists in the Hash then the value associated with the key
+#   is converted to an Array with the old and new value in it.
+#
+# - Other elements such as the xml prolog, doctype, and comments are ignored.
+#
+
+module MultiXml
+  module Parsers
+    module Ox #:nodoc:
+
+      extend self
+
+      def parse_error
+        Exception
+      end
+
+      def parse(io)
+        handler = Handler.new
+        ::Ox.sax_parse(handler, io, :convert_special => true)
+        handler.doc
+      end
+
+      class Handler
+        attr_accessor :stack
+
+        def initialize()
+          @stack = []
+        end
+
+        def doc
+          @stack[0]
+        end
+
+        def attr(name, value)
+          unless @stack.empty?
+            append(name, value)
+          end
+        end
+
+        def text(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def cdata(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def start_element(name)
+          if @stack.empty?
+            @stack.push(Hash.new)
+          end
+          h = Hash.new
+          append(name, h)
+          @stack.push(h)
+        end
+
+        def end_element(name)
+          @stack.pop()
+        end
+
+        def error(message, line, column)
+          raise Exception.new("#{message} at #{line}:#{column}")
+        end
+
+        def append(key, value)
+          key = key.to_s
+          h = @stack.last
+          if h.has_key?(key)
+            v = h[key]
+            if v.is_a?(Array)
+              v << value
+            else
+              h[key] = [v, value]
+            end
+          else
+            h[key] = value
+          end
+        end
+
+      end # Handler
+    end # Ox
+  end # Parsers
+end # MultiXml

data/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/lib/multi_xml/parsers/rexml.rb

@@ -0,0 +1,113 @@
+require 'rexml/document' unless defined?(REXML::Document)
+
+module MultiXml
+  module Parsers
+    module Rexml #:nodoc:
+      extend self
+      def parse_error; ::REXML::ParseException; end
+
+      # Parse an XML Document IO into a simple hash using REXML
+      #
+      # xml::
+      #   XML Document IO to parse
+      def parse(xml)
+        doc = REXML::Document.new(xml)
+        if doc.root
+          merge_element!({}, doc.root)
+        else
+          raise REXML::ParseException, "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
+
+      private
+
+      # Convert an XML element and merge into the hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      # element::
+      #   XML element to merge into hash
+      def merge_element!(hash, element)
+        merge!(hash, element.name, collapse(element))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element {|child| merge_element!(hash, child) }
+          merge_texts!(hash, element) unless empty_content?(element)
+          hash
+        else
+          merge_texts!(hash, element)
+        end
+      end
+
+      # Merge all the texts of an element into the hash
+      #
+      # hash::
+      #   Hash to add the converted element to.
+      # element::
+      #   XML element whose texts are to me merged into the hash
+      def merge_texts!(hash, element)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, MultiXml::CONTENT_ROOT, texts)
+        end
+      end
+
+      # Adds a new key/value pair to an existing Hash. If the key to be added
+      # already exists and the existing value associated with key is not
+      # an Array, it will be wrapped in an Array. Then the new value is
+      # appended to that Array.
+      #
+      # hash::
+      #   Hash to add key/value pair to.
+      # key::
+      #   Key to be added.
+      # value::
+      #   Value to be associated with key.
+      def merge!(hash, key, value)
+        if hash.has_key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Converts the attributes array of an XML element into a hash.
+      # Returns an empty Hash if node has no attributes.
+      #
+      # element::
+      #   XML element to extract attributes from.
+      def get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n,v| attributes[n] = v }
+        attributes
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        element.texts.join.strip.empty?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/lib/multi_xml/version.rb

@@ -0,0 +1,3 @@
+module MultiXml
+  VERSION = "0.5.5" unless defined?(MultiXML::VERSION)
+end

data/vendor/bundle/ruby/2.0.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/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/multi_xml.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_xml/version'
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.author = "Erik Michaels-Ober"
+  spec.cert_chain = ['certs/sferik.pem']
+  spec.description = %q{Provides swappable XML backends utilizing LibXML, Nokogiri, Ox, or REXML.}
+  spec.email = 'sferik@gmail.com'
+  spec.files = %w(.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile multi_xml.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("spec/**/*")
+  spec.homepage = 'https://github.com/sferik/multi_xml'
+  spec.licenses = ['MIT']
+  spec.name = 'multi_xml'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.signing_key = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
+  spec.summary = %q{A generic swappable back-end for XML parsing}
+  spec.test_files = Dir.glob("spec/**/*")
+  spec.version = MultiXml::VERSION
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/spec/helper.rb

@@ -0,0 +1,17 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'multi_xml'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_xml-0.5.5/spec/multi_xml_spec.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'parser_shared_example'
+
+class MockDecoder; end
+
+describe "MultiXml" do
+  context "Parsers" do
+    it "picks a default parser" do
+      expect(MultiXml.parser).to be_kind_of(Module)
+      expect(MultiXml.parser).to respond_to(:parse)
+    end
+
+    it "defaults to the best available gem" do
+      # Clear cache variable already set by previous tests
+      MultiXml.send(:remove_instance_variable, :@parser)
+      expect(MultiXml.parser.name).to eq('MultiXml::Parsers::Ox')
+    end
+
+    it "is settable via a symbol" do
+      MultiXml.parser = :rexml
+      expect(MultiXml.parser.name).to eq('MultiXml::Parsers::Rexml')
+    end
+
+    it "is settable via a class" do
+      MultiXml.parser = MockDecoder
+      expect(MultiXml.parser.name).to eq('MockDecoder')
+    end
+  end
+
+  [['LibXML', 'libxml'],
+   ['REXML', 'rexml/document'],
+   ['Nokogiri', 'nokogiri'],
+   ['Ox', 'ox']].each do |parser|
+    begin
+      require parser.last
+      context "#{parser.first} parser" do
+        it_behaves_like "a parser", parser.first
+      end
+    rescue LoadError => e
+      puts "Tests not run for #{parser.first} due to a LoadError"
+    end
+  end
+end