ric 0.12.0 → 0.12.2

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/enumerable.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Enumerable
+  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
+  # when we omit an identity.
+  #
+  # We tried shimming it to attempt the fast native method, rescue TypeError,
+  # and fall back to the compatible implementation, but that's much slower than
+  # just calling the compat method in the first place.
+  if Enumerable.instance_methods(false).include?(:sum) && !((?a..?b).sum rescue false)
+    # :stopdoc:
+
+    # We can't use Refinements here because Refinements with Module which will be prepended
+    # doesn't work well https://bugs.ruby-lang.org/issues/13446
+    alias :_original_sum_with_required_identity :sum
+    private :_original_sum_with_required_identity
+
+    # :startdoc:
+
+    # Calculates a sum from the elements.
+    #
+    #  payments.sum { |p| p.price * p.tax_rate }
+    #  payments.sum(&:price)
+    #
+    # The latter is a shortcut for:
+    #
+    #  payments.inject(0) { |sum, p| sum + p.price }
+    #
+    # It can also calculate the sum without the use of a block.
+    #
+    #  [5, 15, 10].sum # => 30
+    #  ['foo', 'bar'].sum # => "foobar"
+    #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
+    #
+    # The default sum of an empty list is zero. You can override this default:
+    #
+    #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+    def sum(identity = nil, &block)
+      if identity
+        _original_sum_with_required_identity(identity, &block)
+      elsif block_given?
+        map(&block).sum(identity)
+      else
+        inject(:+) || 0
+      end
+    end
+  else
+    def sum(identity = nil, &block)
+      if block_given?
+        map(&block).sum(identity)
+      else
+        sum = identity ? inject(identity, :+) : inject(:+)
+        sum || identity || 0
+      end
+    end
+  end
+
+  # Convert an enumerable to a hash.
+  #
+  #   people.index_by(&:login)
+  #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
+  #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  def index_by
+    if block_given?
+      result = {}
+      each { |elem| result[yield(elem)] = elem }
+      result
+    else
+      to_enum(:index_by) { size if respond_to?(:size) }
+    end
+  end
+
+  # Returns +true+ if the enumerable has more than 1 element. Functionally
+  # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
+  # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
+  # if more than one person is over 26.
+  def many?
+    cnt = 0
+    if block_given?
+      any? do |element|
+        cnt += 1 if yield element
+        cnt > 1
+      end
+    else
+      any? { (cnt += 1) > 1 }
+    end
+  end
+
+  # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
+  # collection does not include the object.
+  def exclude?(object)
+    !include?(object)
+  end
+
+  # Returns a copy of the enumerable without the specified elements.
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].without "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
+  #
+  #   {foo: 1, bar: 2, baz: 3}.without :bar
+  #   # => {foo: 1, baz: 3}
+  def without(*elements)
+    reject { |element| elements.include?(element) }
+  end
+
+  # Convert an enumerable to an array based on the given key.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
+  #   # => ["David", "Rafael", "Aaron"]
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name)
+  #   # => [[1, "David"], [2, "Rafael"]]
+  def pluck(*keys)
+    if keys.many?
+      map { |element| keys.map { |key| element[key] } }
+    else
+      map { |element| element[keys.first] }
+    end
+  end
+end
+
+class Range #:nodoc:
+  # Optimize range sum to use arithmetic progression if a block is not given and
+  # we have a range of numeric values.
+  def sum(identity = nil)
+    if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
+      super
+    else
+      actual_last = exclude_end? ? (last - 1) : last
+      if actual_last >= first
+        sum = identity || 0
+        sum + (actual_last - first + 1) * (actual_last + first) / 2
+      else
+        identity || 0
+      end
+    end
+  end
+end
+
+# Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
+#
+# We tried shimming it to attempt the fast native method, rescue TypeError,
+# and fall back to the compatible implementation, but that's much slower than
+# just calling the compat method in the first place.
+if Array.instance_methods(false).include?(:sum) && !(%w[a].sum rescue false)
+  # Using Refinements here in order not to expose our internal method
+  using Module.new {
+    refine Array do
+      alias :orig_sum :sum
+    end
+  }
+
+  class Array
+    def sum(init = nil, &block) #:nodoc:
+      if init.is_a?(Numeric) || first.is_a?(Numeric)
+        init ||= 0
+        orig_sum(init, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/file.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/file/atomic"

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/file/atomic.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+class File
+  # Write to a file atomically. Useful for situations where you don't
+  # want other processes or threads to see half-written files.
+  #
+  #   File.atomic_write('important.file') do |file|
+  #     file.write('hello')
+  #   end
+  #
+  # This method needs to create a temporary file. By default it will create it
+  # in the same directory as the destination file. If you don't like this
+  # behavior you can provide a different directory but it must be on the
+  # same physical filesystem as the file you're trying to write.
+  #
+  #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
+  #     file.write('hello')
+  #   end
+  def self.atomic_write(file_name, temp_dir = dirname(file_name))
+    require "tempfile" unless defined?(Tempfile)
+
+    Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
+      temp_file.binmode
+      return_val = yield temp_file
+      temp_file.close
+
+      old_stat = if exist?(file_name)
+        # Get original file permissions
+        stat(file_name)
+      else
+        # If not possible, probe which are the default permissions in the
+        # destination directory.
+        probe_stat_in(dirname(file_name))
+      end
+
+      if old_stat
+        # Set correct permissions on new file
+        begin
+          chown(old_stat.uid, old_stat.gid, temp_file.path)
+          # This operation will affect filesystem ACL's
+          chmod(old_stat.mode, temp_file.path)
+        rescue Errno::EPERM, Errno::EACCES
+          # Changing file ownership failed, moving on.
+        end
+      end
+
+      # Overwrite original file with temp file
+      rename(temp_file.path, file_name)
+      return_val
+    end
+  end
+
+  # Private utility method.
+  def self.probe_stat_in(dir) #:nodoc:
+    basename = [
+      ".permissions_check",
+      Thread.current.object_id,
+      Process.pid,
+      rand(1000000)
+    ].join(".")
+
+    file_name = join(dir, basename)
+    FileUtils.touch(file_name)
+    stat(file_name)
+  ensure
+    FileUtils.rm_f(file_name) if file_name
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/compact"
+require "active_support/core_ext/hash/conversions"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/hash/transform_values"

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/hash/compact.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Hash
+  unless Hash.instance_methods(false).include?(:compact)
+    # Returns a hash with non +nil+ values.
+    #
+    #   hash = { a: true, b: false, c: nil }
+    #   hash.compact        # => { a: true, b: false }
+    #   hash                # => { a: true, b: false, c: nil }
+    #   { c: nil }.compact  # => {}
+    #   { c: true }.compact # => { c: true }
+    def compact
+      select { |_, value| !value.nil? }
+    end
+  end
+
+  unless Hash.instance_methods(false).include?(:compact!)
+    # Replaces current hash with non +nil+ values.
+    # Returns +nil+ if no changes were made, otherwise returns the hash.
+    #
+    #   hash = { a: true, b: false, c: nil }
+    #   hash.compact!        # => { a: true, b: false }
+    #   hash                 # => { a: true, b: false }
+    #   { c: true }.compact! # => nil
+    def compact!
+      reject! { |_, value| value.nil? }
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/hash/conversions.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "active_support/xml_mini"
+require "active_support/time"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/string/inflections"
+
+class Hash
+  # Returns a string containing an XML representation of its receiver:
+  #
+  #   { foo: 1, bar: 2 }.to_xml
+  #   # =>
+  #   # <?xml version="1.0" encoding="UTF-8"?>
+  #   # <hash>
+  #   #   <foo type="integer">1</foo>
+  #   #   <bar type="integer">2</bar>
+  #   # </hash>
+  #
+  # To do so, the method loops over the pairs and builds nodes that depend on
+  # the _values_. Given a pair +key+, +value+:
+  #
+  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
+  #
+  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
+  #   and +key+ singularized as <tt>:children</tt>.
+  #
+  # * If +value+ is a callable object it must expect one or two arguments. Depending
+  #   on the arity, the callable is invoked with the +options+ hash as first argument
+  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The
+  #   callable can add nodes by using <tt>options[:builder]</tt>.
+  #
+  #     {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
+  #     # => "<b>foo</b>"
+  #
+  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
+  #
+  #     class Foo
+  #       def to_xml(options)
+  #         options[:builder].bar 'fooing!'
+  #       end
+  #     end
+  #
+  #     { foo: Foo.new }.to_xml(skip_instruct: true)
+  #     # =>
+  #     # <hash>
+  #     #   <bar>fooing!</bar>
+  #     # </hash>
+  #
+  # * Otherwise, a node with +key+ as tag is created with a string representation of
+  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
+  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
+  #   added as well according to the following mapping:
+  #
+  #     XML_TYPE_NAMES = {
+  #       "Symbol"     => "symbol",
+  #       "Integer"    => "integer",
+  #       "BigDecimal" => "decimal",
+  #       "Float"      => "float",
+  #       "TrueClass"  => "boolean",
+  #       "FalseClass" => "boolean",
+  #       "Date"       => "date",
+  #       "DateTime"   => "dateTime",
+  #       "Time"       => "dateTime"
+  #     }
+  #
+  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
+  #
+  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
+  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
+  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
+  def to_xml(options = {})
+    require "active_support/builder" unless defined?(Builder)
+
+    options = options.dup
+    options[:indent]  ||= 2
+    options[:root]    ||= "hash"
+    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
+
+    builder = options[:builder]
+    builder.instruct! unless options.delete(:skip_instruct)
+
+    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
+
+    builder.tag!(root) do
+      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
+      yield builder if block_given?
+    end
+  end
+
+  class << self
+    # Returns a Hash containing a collection of pairs when the key is the node name and the value is
+    # its content
+    #
+    #   xml = <<-XML
+    #     <?xml version="1.0" encoding="UTF-8"?>
+    #       <hash>
+    #         <foo type="integer">1</foo>
+    #         <bar type="integer">2</bar>
+    #       </hash>
+    #   XML
+    #
+    #   hash = Hash.from_xml(xml)
+    #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
+    #
+    # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
+    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to
+    # parse this XML.
+    #
+    # Custom +disallowed_types+ can also be passed in the form of an
+    # array.
+    #
+    #   xml = <<-XML
+    #     <?xml version="1.0" encoding="UTF-8"?>
+    #       <hash>
+    #         <foo type="integer">1</foo>
+    #         <bar type="string">"David"</bar>
+    #       </hash>
+    #   XML
+    #
+    #   hash = Hash.from_xml(xml, ['integer'])
+    #   # => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"
+    #
+    # Note that passing custom disallowed types will override the default types,
+    # which are Symbol and YAML.
+    def from_xml(xml, disallowed_types = nil)
+      ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
+    end
+
+    # Builds a Hash from XML just like <tt>Hash.from_xml</tt>, but also allows Symbol and YAML.
+    def from_trusted_xml(xml)
+      from_xml xml, []
+    end
+  end
+end
+
+module ActiveSupport
+  class XMLConverter # :nodoc:
+    # Raised if the XML contains attributes with type="yaml" or
+    # type="symbol". Read Hash#from_xml for more details.
+    class DisallowedType < StandardError
+      def initialize(type)
+        super "Disallowed type attribute: #{type.inspect}"
+      end
+    end
+
+    DISALLOWED_TYPES = %w(symbol yaml)
+
+    def initialize(xml, disallowed_types = nil)
+      @xml = normalize_keys(XmlMini.parse(xml))
+      @disallowed_types = disallowed_types || DISALLOWED_TYPES
+    end
+
+    def to_h
+      deep_to_h(@xml)
+    end
+
+    private
+      def normalize_keys(params)
+        case params
+        when Hash
+          Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
+        when Array
+          params.map { |v| normalize_keys(v) }
+        else
+          params
+        end
+      end
+
+      def deep_to_h(value)
+        case value
+        when Hash
+          process_hash(value)
+        when Array
+          process_array(value)
+        when String
+          value
+        else
+          raise "can't typecast #{value.class.name} - #{value.inspect}"
+        end
+      end
+
+      def process_hash(value)
+        if value.include?("type") && !value["type"].is_a?(Hash) && @disallowed_types.include?(value["type"])
+          raise DisallowedType, value["type"]
+        end
+
+        if become_array?(value)
+          _, entries = Array.wrap(value.detect { |k, v| not v.is_a?(String) })
+          if entries.nil? || value["__content__"].try(:empty?)
+            []
+          else
+            case entries
+            when Array
+              entries.collect { |v| deep_to_h(v) }
+            when Hash
+              [deep_to_h(entries)]
+            else
+              raise "can't typecast #{entries.inspect}"
+            end
+          end
+        elsif become_content?(value)
+          process_content(value)
+
+        elsif become_empty_string?(value)
+          ""
+        elsif become_hash?(value)
+          xml_value = Hash[value.map { |k, v| [k, deep_to_h(v)] }]
+
+          # 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
+      end
+
+      def become_content?(value)
+        value["type"] == "file" || (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
+      end
+
+      def become_array?(value)
+        value["type"] == "array"
+      end
+
+      def become_empty_string?(value)
+        # { "string" => true }
+        # No tests fail when the second term is removed.
+        value["type"] == "string" && value["nil"] != "true"
+      end
+
+      def become_hash?(value)
+        !nothing?(value) && !garbage?(value)
+      end
+
+      def nothing?(value)
+        # blank or nil parsed values are represented by nil
+        value.blank? || value["nil"] == "true"
+      end
+
+      def garbage?(value)
+        # If the type is the only element which makes it then
+        # this still makes the value nil, except if type is
+        # an XML node(where type['value'] is a Hash)
+        value["type"] && !value["type"].is_a?(::Hash) && value.size == 1
+      end
+
+      def process_content(value)
+        content = value["__content__"]
+        if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
+          parser.arity == 1 ? parser.call(content) : parser.call(content, value)
+        else
+          content
+        end
+      end
+
+      def process_array(value)
+        value.map! { |i| deep_to_h(i) }
+        value.length > 1 ? value : value.first
+      end
+  end
+end