lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/version.rb

@@ -1,8 +0,0 @@
-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/gems/activesupport-5.0.2/lib/active_support/xml_mini.rb

@@ -1,209 +0,0 @@
-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
-
-    protected
-
-    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) #:nodoc:
-      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
-
-    private
-
-      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/gems/activesupport-5.0.2/lib/active_support/xml_mini/jdom.rb

@@ -1,181 +0,0 @@
-raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFORM =~ /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
-        # http://www.ibm.com/developerworks/xml/library/x-tipcfsx/index.html
-        @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 = ''
-      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/gems/activesupport-5.0.2/lib/active_support/xml_mini/libxml.rb

@@ -1,79 +0,0 @@
-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
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        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] ||= ''
-            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
-
-LibXML::XML::Document.include(LibXML::Conversions::Document)
-LibXML::XML::Node.include(LibXML::Conversions::Node)