monero_wallet_gen 0.1.0

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActiveSupport
+  # Returns the version of the currently loaded ActiveSupport as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/xml_mini.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "time"
+require "base64"
+require "bigdecimal"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/date_time/calculations"
+
+module ActiveSupport
+  # = XmlMini
+  #
+  # To use the much faster libxml parser:
+  #   gem 'libxml-ruby', '=0.9.7'
+  #   XmlMini.backend = 'LibXML'
+  module XmlMini
+    extend self
+
+    # This module decorates files deserialized using Hash.from_xml 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
+
+    DEFAULT_ENCODINGS = {
+      "binary" => "base64"
+    } unless defined?(DEFAULT_ENCODINGS)
+
+    unless defined?(TYPE_NAMES)
+      TYPE_NAMES = {
+        "Symbol"     => "symbol",
+        "Integer"    => "integer",
+        "BigDecimal" => "decimal",
+        "Float"      => "float",
+        "TrueClass"  => "boolean",
+        "FalseClass" => "boolean",
+        "Date"       => "date",
+        "DateTime"   => "dateTime",
+        "Time"       => "dateTime",
+        "Array"      => "array",
+        "Hash"       => "hash"
+      }
+
+      # No need to map these on Ruby 2.4+
+      TYPE_NAMES["Fixnum"] = "integer" unless 0.class == Integer
+      TYPE_NAMES["Bignum"] = "integer" unless 0.class == Integer
+    end
+
+    FORMATTING = {
+      "symbol"   => Proc.new { |symbol| symbol.to_s },
+      "date"     => Proc.new { |date| date.to_s(:db) },
+      "dateTime" => Proc.new { |time| time.xmlschema },
+      "binary"   => Proc.new { |binary| ::Base64.encode64(binary) },
+      "yaml"     => Proc.new { |yaml| yaml.to_yaml }
+    } unless defined?(FORMATTING)
+
+    # TODO use regexp instead of Date.parse
+    unless defined?(PARSING)
+      PARSING = {
+        "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
+        "date"         => Proc.new { |date|    ::Date.parse(date) },
+        "datetime"     => Proc.new { |time|    Time.xmlschema(time).utc rescue ::DateTime.parse(time).utc },
+        "integer"      => Proc.new { |integer| integer.to_i },
+        "float"        => Proc.new { |float|   float.to_f },
+        "decimal"      => Proc.new do |number|
+          if String === number
+            begin
+              BigDecimal(number)
+            rescue ArgumentError
+              BigDecimal("0")
+            end
+          else
+            BigDecimal(number)
+          end
+        end,
+        "boolean"      => Proc.new { |boolean| %w(1 true).include?(boolean.to_s.strip) },
+        "string"       => Proc.new { |string|  string.to_s },
+        "yaml"         => Proc.new { |yaml|    YAML.load(yaml) rescue yaml },
+        "base64Binary" => Proc.new { |bin|     ::Base64.decode64(bin) },
+        "binary"       => Proc.new { |bin, entity| _parse_binary(bin, entity) },
+        "file"         => Proc.new { |file, entity| _parse_file(file, entity) }
+      }
+
+      PARSING.update(
+        "double"   => PARSING["float"],
+        "dateTime" => PARSING["datetime"]
+      )
+    end
+
+    attr_accessor :depth
+    self.depth = 100
+
+    delegate :parse, to: :backend
+
+    def backend
+      current_thread_backend || @backend
+    end
+
+    def backend=(name)
+      backend = name && cast_backend_name_to_module(name)
+      self.current_thread_backend = backend if current_thread_backend
+      @backend = backend
+    end
+
+    def with_backend(name)
+      old_backend = current_thread_backend
+      self.current_thread_backend = name && cast_backend_name_to_module(name)
+      yield
+    ensure
+      self.current_thread_backend = old_backend
+    end
+
+    def to_tag(key, value, options)
+      type_name = options.delete(:type)
+      merged_options = options.merge(root: key, skip_instruct: true)
+
+      if value.is_a?(::Method) || value.is_a?(::Proc)
+        if value.arity == 1
+          value.call(merged_options)
+        else
+          value.call(merged_options, key.to_s.singularize)
+        end
+      elsif value.respond_to?(:to_xml)
+        value.to_xml(merged_options)
+      else
+        type_name ||= TYPE_NAMES[value.class.name]
+        type_name ||= value.class.name if value && !value.respond_to?(:to_str)
+        type_name   = type_name.to_s   if type_name
+        type_name   = "dateTime" if type_name == "datetime"
+
+        key = rename_key(key.to_s, options)
+
+        attributes = options[:skip_types] || type_name.nil? ? {} : { type: type_name }
+        attributes[:nil] = true if value.nil?
+
+        encoding = options[:encoding] || DEFAULT_ENCODINGS[type_name]
+        attributes[:encoding] = encoding if encoding
+
+        formatted_value = FORMATTING[type_name] && !value.nil? ?
+          FORMATTING[type_name].call(value) : value
+
+        options[:builder].tag!(key, formatted_value, attributes)
+      end
+    end
+
+    def rename_key(key, options = {})
+      camelize  = options[:camelize]
+      dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+      if camelize
+        key = true == camelize ? key.camelize : key.camelize(camelize)
+      end
+      key = _dasherize(key) if dasherize
+      key
+    end
+
+    private
+
+      def _dasherize(key)
+        # $2 must be a non-greedy regex for this to work
+        left, middle, right = /\A(_*)(.*?)(_*)\Z/.match(key.strip)[1, 3]
+        "#{left}#{middle.tr('_ ', '--')}#{right}"
+      end
+
+      # TODO: Add support for other encodings
+      def _parse_binary(bin, entity)
+        case entity["encoding"]
+        when "base64"
+          ::Base64.decode64(bin)
+        else
+          bin
+        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 current_thread_backend
+        Thread.current[:xml_mini_backend]
+      end
+
+      def current_thread_backend=(name)
+        Thread.current[:xml_mini_backend] = name && cast_backend_name_to_module(name)
+      end
+
+      def cast_backend_name_to_module(name)
+        if name.is_a?(Module)
+          name
+        else
+          require "active_support/xml_mini/#{name.downcase}"
+          ActiveSupport.const_get("XmlMini_#{name}")
+        end
+      end
+  end
+
+  XmlMini.backend = "REXML"
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/xml_mini/jdom.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFORM.include?("java")
+
+require "jruby"
+include Java
+
+require "active_support/core_ext/object/blank"
+
+java_import javax.xml.parsers.DocumentBuilder unless defined? DocumentBuilder
+java_import javax.xml.parsers.DocumentBuilderFactory unless defined? DocumentBuilderFactory
+java_import java.io.StringReader unless defined? StringReader
+java_import org.xml.sax.InputSource unless defined? InputSource
+java_import org.xml.sax.Attributes unless defined? Attributes
+java_import org.w3c.dom.Node unless defined? Node
+
+module ActiveSupport
+  module XmlMini_JDOM #:nodoc:
+    extend self
+
+    CONTENT_KEY = "__content__".freeze
+
+    NODE_TYPE_NAMES = %w{ATTRIBUTE_NODE CDATA_SECTION_NODE COMMENT_NODE DOCUMENT_FRAGMENT_NODE
+    DOCUMENT_NODE DOCUMENT_TYPE_NODE ELEMENT_NODE ENTITY_NODE ENTITY_REFERENCE_NODE NOTATION_NODE
+    PROCESSING_INSTRUCTION_NODE TEXT_NODE}
+
+    node_type_map = {}
+    NODE_TYPE_NAMES.each { |type| node_type_map[Node.send(type)] = type }
+
+    # Parse an XML Document string or IO into a simple hash using Java's jdom.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if data.respond_to?(:read)
+        data = data.read
+      end
+
+      if data.blank?
+        {}
+      else
+        @dbf = DocumentBuilderFactory.new_instance
+        # secure processing of java xml
+        # https://archive.is/9xcQQ
+        @dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
+        @dbf.setFeature("http://xml.org/sax/features/external-general-entities", false)
+        @dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false)
+        @dbf.setFeature(javax.xml.XMLConstants::FEATURE_SECURE_PROCESSING, true)
+        xml_string_reader = StringReader.new(data)
+        xml_input_source = InputSource.new(xml_string_reader)
+        doc = @dbf.new_document_builder.parse(xml_input_source)
+        merge_element!({ CONTENT_KEY => "" }, doc.document_element, XmlMini.depth)
+      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, depth)
+        raise "Document too deep!" if depth == 0
+        delete_empty(hash)
+        merge!(hash, element.tag_name, collapse(element, depth))
+      end
+
+      def delete_empty(hash)
+        hash.delete(CONTENT_KEY) if hash[CONTENT_KEY] == ""
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element, depth)
+        hash = get_attributes(element)
+
+        child_nodes = element.child_nodes
+        if child_nodes.length > 0
+          (0...child_nodes.length).each do |i|
+            child = child_nodes.item(i)
+            merge_element!(hash, child, depth - 1) unless child.node_type == Node.TEXT_NODE
+          end
+          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)
+        delete_empty(hash)
+        text_children = texts(element)
+        if text_children.join.empty?
+          hash
+        else
+          # must use value to prevent double-escaping
+          merge!(hash, CONTENT_KEY, text_children.join)
+        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)
+        attribute_hash = {}
+        attributes = element.attributes
+        (0...attributes.length).each do |i|
+          attribute_hash[CONTENT_KEY] ||= ""
+          attribute_hash[attributes.item(i).name] = attributes.item(i).value
+        end
+        attribute_hash
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def texts(element)
+        texts = []
+        child_nodes = element.child_nodes
+        (0...child_nodes.length).each do |i|
+          item = child_nodes.item(i)
+          if item.node_type == Node.TEXT_NODE
+            texts << item.get_data
+          end
+        end
+        texts
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        text = "".dup
+        child_nodes = element.child_nodes
+        (0...child_nodes.length).each do |i|
+          item = child_nodes.item(i)
+          if item.node_type == Node.TEXT_NODE
+            text << item.get_data.strip
+          end
+        end
+        text.strip.length == 0
+      end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/activesupport-5.2.0/lib/active_support/xml_mini/libxml.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "libxml"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_LibXML #:nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        LibXML::XML::Parser.io(data).parse.to_hash
+      end
+    end
+  end
+end
+
+module LibXML #:nodoc:
+  module Conversions #:nodoc:
+    module Document #:nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node #:nodoc:
+      CONTENT_ROOT = "__content__".freeze
+
+      # Convert XML document to hash.
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def to_hash(hash = {})
+        node_hash = {}
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+        when Array then hash[name] << node_hash
+        when Hash  then hash[name] = [hash[name], node_hash]
+        when nil   then hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child do |c|
+          if c.element?
+            c.to_hash(node_hash)
+          elsif c.text? || c.cdata?
+            node_hash[CONTENT_ROOT] ||= "".dup
+            node_hash[CONTENT_ROOT] << c.content
+          end
+        end
+
+        # Remove content node if it is blank
+        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+          node_hash.delete(CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr { |a| node_hash[a.name] = a.value }
+
+        hash
+      end
+    end
+  end
+end
+
+# :enddoc:
+
+LibXML::XML::Document.include(LibXML::Conversions::Document)
+LibXML::XML::Node.include(LibXML::Conversions::Node)