ric 0.12.0 → 0.12.2

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/xml_mini/libxmlsax.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "libxml"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_LibXMLSAX #:nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder
+      include LibXML::XML::SaxParser::Callbacks
+
+      CONTENT_KEY   = "__content__".freeze
+      HASH_SIZE_KEY = "__hash_size__".freeze
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def on_start_document
+        @hash = { CONTENT_KEY => "".dup }
+        @hash_stack = [@hash]
+      end
+
+      def on_end_document
+        @hash = @hash_stack.pop
+        @hash.delete(CONTENT_KEY)
+      end
+
+      def on_start_element(name, attrs = {})
+        new_hash = { CONTENT_KEY => "".dup }.merge!(attrs)
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+        when Array then current_hash[name] << new_hash
+        when Hash  then current_hash[name] = [current_hash[name], new_hash]
+        when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def on_end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def on_characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :on_cdata_block, :on_characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
+        parser = LibXML::XML::SaxParser.io(data)
+        document = document_class.new
+
+        parser.callbacks = document
+        parser.parse
+        document.hash
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/xml_mini/nokogiri.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+begin
+  require "nokogiri"
+rescue LoadError => e
+  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_Nokogiri #:nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
+    # 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
+        doc = Nokogiri::XML(data)
+        raise doc.errors.first if doc.errors.length > 0
+        doc.to_hash
+      end
+    end
+
+    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
+          children.each 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 and there are child tags
+          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+            node_hash.delete(CONTENT_ROOT)
+          end
+
+          # Handle attributes
+          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+
+          hash
+        end
+      end
+    end
+
+    Nokogiri::XML::Document.include(Conversions::Document)
+    Nokogiri::XML::Node.include(Conversions::Node)
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/xml_mini/nokogirisax.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+begin
+  require "nokogiri"
+rescue LoadError => e
+  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_NokogiriSAX #:nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder < Nokogiri::XML::SAX::Document
+      CONTENT_KEY   = "__content__".freeze
+      HASH_SIZE_KEY = "__hash_size__".freeze
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def start_document
+        @hash = {}
+        @hash_stack = [@hash]
+      end
+
+      def end_document
+        raise "Parse stack not empty!" if @hash_stack.size > 1
+      end
+
+      def error(error_message)
+        raise error_message
+      end
+
+      def start_element(name, attrs = [])
+        new_hash = { CONTENT_KEY => "".dup }.merge!(Hash[attrs])
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+        when Array then current_hash[name] << new_hash
+        when Hash  then current_hash[name] = [current_hash[name], new_hash]
+        when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :cdata_block, :characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        document = document_class.new
+        parser = Nokogiri::XML::SAX::Parser.new(document)
+        parser.parse(data)
+        document.hash
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/xml_mini/rexml.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_REXML #:nodoc:
+    extend self
+
+    CONTENT_KEY = "__content__".freeze
+
+    # Parse an XML Document string or IO into a simple hash.
+    #
+    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
+    # and uses the defaults from Active Support.
+    #
+    # 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
+        silence_warnings { require "rexml/document" } unless defined?(REXML::Document)
+        doc = REXML::Document.new(data)
+
+        if doc.root
+          merge_element!({}, doc.root, XmlMini.depth)
+        else
+          raise REXML::ParseException,
+            "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      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 REXML::ParseException, "The document is too deep" if depth == 0
+        merge!(hash, element.name, collapse(element, depth))
+      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)
+
+        if element.has_elements?
+          element.each_element { |child| merge_element!(hash, child, depth - 1) }
+          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 = "".dup
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, CONTENT_KEY, 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.blank?
+      end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/allison-2.0.3/CHANGELOG

@@ -0,0 +1,18 @@
+
+v2.0.3. Remove wrong copyright notices (technomancy).
+
+v2.0.2. Let's not talk about that.
+
+v2.0.1. Remove PROJECT constant which isn't even used, gosh (Adam).
+
+v2.0. Visual redesign. Gem version. 'allison' command line tool.
+
+v1.5. RDoc.
+
+v1.4. Again.
+
+v1.3. Hack to make gem versioning work.
+
+v1.2. Caching in order to remove Markaby dependency.
+
+v1. First release.

data/vendor/bundle/ruby/2.5.0/gems/allison-2.0.3/LICENSE

@@ -0,0 +1,184 @@
+Academic Free License (AFL) v. 3.0
+
+This Academic Free License (the "License") applies to any original work
+of authorship (the "Original Work") whose owner (the "Licensor") has
+placed the following licensing notice adjacent to the copyright notice
+for the Original Work:
+
+Licensed under the Academic Free License version 3.0
+
+1) Grant of Copyright License. Licensor grants You a worldwide,
+royalty-free, non-exclusive, sublicensable license, for the duration of
+the copyright, to do the following:
+
+a) to reproduce the Original Work in copies, either alone or as part of
+a collective work;
+
+b) to translate, adapt, alter, transform, modify, or arrange the
+Original Work, thereby creating derivative works ("Derivative Works")
+based upon the Original Work;
+
+c) to distribute or communicate copies of the Original Work and
+Derivative Works to the public, under any license of your choice that
+does not contradict the terms and conditions, including Licensor's
+reserved rights and remedies, in this Academic Free License;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor grants You a worldwide,
+royalty-free, non-exclusive, sublicensable license, under patent claims
+owned or controlled by the Licensor that are embodied in the Original
+Work as furnished by the Licensor, for the duration of the patents, to
+make, use, sell, offer for sale, have made, and import the Original Work
+and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the
+preferred form of the Original Work for making modifications to it and
+all available documentation describing how to modify the Original Work.
+Licensor agrees to provide a machine-readable copy of the Source Code of
+the Original Work along with each copy of the Original Work that
+Licensor distributes. Licensor reserves the right to satisfy this
+obligation by placing a machine-readable copy of the Source Code in an
+information repository reasonably calculated to permit inexpensive and
+convenient access by You for as long as Licensor continues to distribute
+the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the
+names of any contributors to the Original Work, nor any of their
+trademarks or service marks, may be used to endorse or promote products
+derived from this Original Work without express prior permission of the
+Licensor. Except as expressly stated herein, nothing in this License
+grants any license to Licensor's trademarks, copyrights, patents, trade
+secrets or any other intellectual property. No patent license is granted
+to make, use, sell, offer for sale, have made, or import embodiments of
+any patent claims other than the licensed claims defined in Section 2.
+No license is granted to the trademarks of Licensor even if such marks
+are included in the Original Work. Nothing in this License shall be
+interpreted to prohibit Licensor from licensing under terms different
+from this License any Original Work that Licensor otherwise would have a
+right to license.
+
+5) External Deployment. The term "External Deployment" means the use,
+distribution, or communication of the Original Work or Derivative Works
+in any way such that the Original Work or Derivative Works may be used
+by anyone other than You, whether those works are distributed or
+communicated to those persons or made available as an application
+intended for use over a network. As an express condition for the grants
+of license hereunder, You must treat any External Deployment by You of
+the Original Work or a Derivative Work as a distribution under section
+1(c).
+
+6) Attribution Rights. You must retain, in the Source Code of any
+Derivative Works that You create, all copyright, patent, or trademark
+notices from the Source Code of the Original Work, as well as any
+notices of licensing and any descriptive text identified therein as an
+"Attribution Notice." You must cause the Source Code for any Derivative
+Works that You create to carry a prominent Attribution Notice reasonably
+calculated to inform recipients that You have modified the Original
+Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants
+that the copyright in and to the Original Work and the patent rights
+granted herein by Licensor are owned by the Licensor or are sublicensed
+to You under the terms of this License with the permission of the
+contributor(s) of those copyrights and patent rights. Except as
+expressly stated in the immediately preceding sentence, the Original
+Work is provided under this License on an "AS IS" BASIS and WITHOUT
+WARRANTY, either express or implied, including, without limitation, the
+warranties of non-infringement, merchantability or fitness for a
+particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL
+WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential
+part of this License. No license to the Original Work is granted by this
+License except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal
+theory, whether in tort (including negligence), contract, or otherwise,
+shall the Licensor be liable to anyone for any indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or the use of the Original Work including,
+without limitation, damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages
+or losses. This limitation of liability shall not apply to the extent
+applicable law prohibits such limitation.
+
+9) Acceptance and Termination. If, at any time, You expressly assented
+to this License, that assent indicates your clear and irrevocable
+acceptance of this License and all of its terms and conditions. If You
+distribute or communicate copies of the Original Work or a Derivative
+Work, You must make a reasonable effort under the circumstances to
+obtain the express assent of recipients to the terms of this License.
+This License conditions your rights to undertake the activities listed
+in Section 1, including your right to create Derivative Works based upon
+the Original Work, and doing so without honoring these terms and
+conditions is prohibited by copyright law and international treaty.
+Nothing in this License is intended to affect copyright exceptions and
+limitations (including "fair use" or "fair dealing"). This License shall
+terminate immediately and You may no longer exercise any of the rights
+granted to You by this License upon your failure to honor the conditions
+in Section 1(c).
+
+10) Termination for Patent Action. This License shall terminate
+automatically and You may no longer exercise any of the rights granted
+to You by this License as of the date You commence an action, including
+a cross-claim or counterclaim, against Licensor or any licensee alleging
+that the Original Work infringes a patent. This termination provision
+shall not apply for an action alleging patent infringement by
+combinations of the Original Work with other software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating
+to this License may be brought only in the courts of a jurisdiction
+wherein the Licensor resides or in which Licensor conducts its primary
+business, and under the laws of that jurisdiction excluding its
+conflict-of-law provisions. The application of the United Nations
+Convention on Contracts for the International Sale of Goods is expressly
+excluded. Any use of the Original Work outside the scope of this License
+or after its termination shall be subject to the requirements and
+penalties of copyright or patent law in the appropriate jurisdiction.
+This section shall survive the termination of this License.
+
+12) Attorneys' Fees. In any action to enforce the terms of this License
+or seeking damages relating thereto, the prevailing party shall be
+entitled to recover its costs and expenses, including, without
+limitation, reasonable attorneys' fees and costs incurred in connection
+with such action, including any appeal of such action. This section
+shall survive the termination of this License.
+
+13) Miscellaneous. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License,
+whether in upper or lower case, means an individual or a legal entity
+exercising rights under, and complying with all of the terms of, this
+License. For legal entities, "You" includes any entity that controls, is
+controlled by, or is under common control with you. For purposes of this
+definition, "control" means (i) the power, direct or indirect, to cause
+the direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not
+otherwise restricted or conditioned by this License or by law, and
+Licensor promises not to interfere with or be responsible for such uses
+by You.
+
+16) Modification of This License. This License is Copyright (c) 2005
+Lawrence Rosen. Permission is granted to copy, distribute, or
+communicate this License without modification. Nothing in this License
+permits You to modify this License as applied to the Original Work or to
+Derivative Works. However, You may modify the text of this License and
+copy, distribute or communicate your modified version (the "Modified
+License") and apply it to other original works of authorship subject to
+the following conditions: (i) You may not indicate in any way that your
+Modified License is the "Academic Free License" or "AFL" and you may not
+use those names in the name of your Modified License; (ii) You must
+replace the notice specified in the first paragraph above with the
+notice "Licensed under <insert your license name here>" or with a notice
+of your own that is not confusingly similar to the notice in this
+License; and (iii) You may not claim that your original works are open
+source software unless your Modified License has been approved by Open
+Source Initiative (OSI) and You comply with its license review and
+certification process.
+