cloudsmith-api 0.49.94 → 0.51.37

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/lib/ffi/tools/types_generator.rb

@@ -1,135 +0,0 @@
-require 'tempfile'
-
-module FFI
-
-  # @private
-  class TypesGenerator
-
-    ##
-    # Maps different C types to the C type representations we use
-
-    TYPE_MAP = {
-               "char" => :char,
-        "signed char" => :char,
-      "__signed char" => :char,
-      "unsigned char" => :uchar,
-
-               "short"     => :short,
-        "signed short"     => :short,
-        "signed short int" => :short,
-      "unsigned short"     => :ushort,
-      "unsigned short int" => :ushort,
-
-               "int" => :int,
-        "signed int" => :int,
-      "unsigned int" => :uint,
-
-               "long" => :long,
-               "long int" => :long,
-        "signed long" => :long,
-        "signed long int" => :long,
-      "unsigned long" => :ulong,
-      "unsigned long int" => :ulong,
-      "long unsigned int" => :ulong,
-
-               "long long"     => :long_long,
-               "long long int" => :long_long,
-        "signed long long"     => :long_long,
-        "signed long long int" => :long_long,
-      "unsigned long long"     => :ulong_long,
-      "unsigned long long int" => :ulong_long,
-
-      "char *" => :string,
-      "void *" => :pointer,
-    }
-
-    def self.generate(options = {})
-      typedefs = nil
-      Tempfile.open 'ffi_types_generator' do |io|
-        io.puts <<-C
-#include <sys/types.h>
-#if !(defined(WIN32))
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <sys/resource.h>
-#endif
-        C
-
-        io.close
-        cc = ENV['CC'] || 'gcc'
-        cmd = "#{cc} -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c"
-        if options[:input]
-          typedefs = File.read(options[:input])
-        elsif options[:remote]
-          typedefs = `ssh #{options[:remote]} #{cmd} - < #{io.path}`
-        else
-          typedefs = `#{cmd} #{io.path}`
-        end
-      end
-
-      code = []
-
-      typedefs.each_line do |type|
-        # We only care about single line typedef
-        next unless type =~ /typedef/
-        # Ignore unions or structs
-        next if type =~ /union|struct/
-
-        # strip off the starting typedef and ending ;
-        type.gsub!(/^(.*typedef\s*)/, "")
-        type.gsub!(/\s*;\s*$/, "")
-
-        parts = type.split(/\s+/)
-        def_type   = parts.join(" ")
-
-        # GCC does mapping with __attribute__ stuf, also see
-        # http://hal.cs.berkeley.edu/cil/cil016.html section 16.2.7.  Problem
-        # with this is that the __attribute__ stuff can either occur before or
-        # after the new type that is defined...
-        if type =~ /__attribute__/
-          if parts.last =~ /__QI__|__HI__|__SI__|__DI__|__word__/
-
-            # In this case, the new type is BEFORE __attribute__ we need to
-            # find the final_type as the type before the part that starts with
-            # __attribute__
-            final_type = ""
-            parts.each do |p|
-              break if p =~ /__attribute__/
-              final_type = p
-            end
-          else
-            final_type = parts.pop
-          end
-
-          def_type = case type
-                     when /__QI__/   then "char"
-                     when /__HI__/   then "short"
-                     when /__SI__/   then "int"
-                     when /__DI__/   then "long long"
-                     when /__word__/ then "long"
-                     else                 "int"
-                     end
-
-          def_type = "unsigned #{def_type}" if type =~ /unsigned/
-        else
-          final_type = parts.pop
-          def_type   = parts.join(" ")
-        end
-
-        if type = TYPE_MAP[def_type]
-          code << "rbx.platform.typedef.#{final_type} = #{type}"
-          TYPE_MAP[final_type] = TYPE_MAP[def_type]
-        else
-          # Fallback to an ordinary pointer if we don't know the type
-          if def_type =~ /\*/
-            code << "rbx.platform.typedef.#{final_type} = pointer"
-            TYPE_MAP[final_type] = :pointer
-          end
-        end
-      end
-
-      code.sort.join("\n")
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/lib/ffi/version.rb

@@ -1,3 +0,0 @@
-module FFI
-  VERSION = '1.12.2'
-end

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/getlogin.rb

@@ -1,8 +0,0 @@
-require 'rubygems'
-require 'ffi'
-module Foo
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  attach_function :getlogin, [ ], :string
-end
-puts "getlogin=#{Foo.getlogin}"

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/getpid.rb

@@ -1,8 +0,0 @@
-require 'rubygems'
-require 'ffi'
-module Foo
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  attach_function :getpid, [ ], :int
-end
-puts "My pid=#{Foo.getpid}"

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/gettimeofday.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'ffi'
-class Timeval < FFI::Struct
-  rb_maj, rb_min, rb_micro = RUBY_VERSION.split('.')
-  if rb_maj.to_i >= 1 && rb_min.to_i >= 9 || RUBY_PLATFORM =~ /java/
-    layout :tv_sec => :ulong, :tv_usec => :ulong
-  else
-    layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4
-  end
-end
-module LibC
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  attach_function :gettimeofday, [ :pointer, :pointer ], :int
-end
-t = Timeval.new
-LibC.gettimeofday(t.pointer, nil)
-puts "t.tv_sec=#{t[:tv_sec]} t.tv_usec=#{t[:tv_usec]}"

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/hello.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "sample_helper"))
-module Foo
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  attach_function("cputs", "puts", [ :string ], :int)
-end
-Foo.cputs("Hello, World via libc puts using FFI on MRI ruby")

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/inotify.rb

@@ -1,60 +0,0 @@
-require 'rubygems'
-require 'ffi'
-module Inotify
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  class Event < FFI::Struct
-    layout \
-      :wd, :int,
-      :mask, :uint,
-      :cookie, :uint,
-      :len, :uint
-  end
-  attach_function :init, :inotify_init, [ ], :int
-  attach_function :add_watch, :inotify_add_watch, [ :int, :string, :uint ], :int
-  attach_function :rm_watch, :inotify_rm_watch, [ :int, :uint ], :int
-  attach_function :read, [ :int, :buffer_out, :uint ], :int
-  IN_ACCESS=0x00000001
-  IN_MODIFY=0x00000002
-  IN_ATTRIB=0x00000004
-  IN_CLOSE_WRITE=0x00000008
-  IN_CLOSE_NOWRITE=0x00000010
-  IN_CLOSE=(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
-  IN_OPEN=0x00000020
-  IN_MOVED_FROM=0x00000040
-  IN_MOVED_TO=0x00000080
-  IN_MOVE= (IN_MOVED_FROM | IN_MOVED_TO)
-  IN_CREATE=0x00000100
-  IN_DELETE=0x00000200
-  IN_DELETE_SELF=0x00000400
-  IN_MOVE_SELF=0x00000800
-  # Events sent by the kernel.
-  IN_UNMOUNT=0x00002000
-  IN_Q_OVERFLOW=0x00004000
-  IN_IGNORED=0x00008000
-  IN_ONLYDIR=0x01000000
-  IN_DONT_FOLLOW=0x02000000
-  IN_MASK_ADD=0x20000000
-  IN_ISDIR=0x40000000
-  IN_ONESHOT=0x80000000
-  IN_ALL_EVENTS=(IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE \
-                          | IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM \
-                          | IN_MOVED_TO | IN_CREATE | IN_DELETE \
-                          | IN_DELETE_SELF | IN_MOVE_SELF)
-
-end
-if $0 == __FILE__
-  fd = Inotify.init
-  puts "fd=#{fd}"
-  wd = Inotify.add_watch(fd, "/tmp/", Inotify::IN_ALL_EVENTS)
-  fp = FFI::IO.for_fd(fd)
-  puts "wfp=#{fp}"
-  while true
-    buf = FFI::Buffer.alloc_out(Inotify::Event.size + 4096, 1, false)
-    ev = Inotify::Event.new buf
-    ready = IO.select([ fp ], nil, nil, nil)
-    n = Inotify.read(fd, buf, buf.total)
-    puts "Read #{n} bytes from inotify fd"
-    puts "event.wd=#{ev[:wd]} mask=#{ev[:mask]} len=#{ev[:len]} name=#{ev[:len] > 0 ? buf.get_string(16) : 'unknown'}"
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/pty.rb

@@ -1,76 +0,0 @@
-require 'ffi'
-
-
-module PTY
-  private
-  module LibC
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-    attach_function :forkpty, [ :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
-    attach_function :openpty, [ :buffer_out, :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
-    attach_function :login_tty, [ :int ], :int
-    attach_function :close, [ :int ], :int
-    attach_function :strerror, [ :int ], :string
-    attach_function :fork, [], :int
-    attach_function :execv, [ :string, :buffer_in ], :int
-    attach_function :execvp, [ :string, :buffer_in ], :int
-    attach_function :dup2, [ :int, :int ], :int
-    attach_function :dup, [ :int ], :int
-  end
-  Buffer = FFI::Buffer
-  def self.build_args(args)
-    cmd = args.shift
-    cmd_args = args.map do |arg|
-      MemoryPointer.from_string(arg)
-    end
-    exec_args = MemoryPointer.new(:pointer, 1 + cmd_args.length + 1)
-    exec_cmd = MemoryPointer.from_string(cmd)
-    exec_args[0].put_pointer(0, exec_cmd)
-    cmd_args.each_with_index do |arg, i|
-      exec_args[i + 1].put_pointer(0, arg)
-    end
-    [ cmd, exec_args ]
-  end
-  public
-  def self.getpty(*args)
-    mfdp = Buffer.new :int
-    name = Buffer.new 1024
-    #
-    # All the execv setup is done in the parent, since doing anything other than
-    # execv in the child after fork is really flakey
-    #
-    exec_cmd, exec_args = build_args(args)
-    pid = LibC.forkpty(mfdp, name, nil, nil)
-    raise "forkpty failed: #{LibC.strerror(FFI.errno)}" if pid < 0    
-    if pid == 0
-      LibC.execvp(exec_cmd, exec_args)
-      exit 1
-    end
-    masterfd = mfdp.get_int(0)
-    rfp = FFI::IO.for_fd(masterfd, "r")
-    wfp = FFI::IO.for_fd(LibC.dup(masterfd), "w")
-    if block_given?
-      yield rfp, wfp, pid
-      rfp.close unless rfp.closed?
-      wfp.close unless wfp.closed?
-    else
-      [ rfp, wfp, pid ]
-    end
-  end
-  def self.spawn(*args, &block)
-    self.getpty("/bin/sh", "-c", args[0], &block)
-  end
-end
-module LibC
-  extend FFI::Library
-  attach_function :close, [ :int ], :int
-  attach_function :write, [ :int, :buffer_in, :ulong ], :long
-  attach_function :read, [ :int, :buffer_out, :ulong ], :long
-end
-PTY.getpty("/bin/ls", "-alR", "/") { |rfd, wfd, pid|
-#PTY.spawn("ls -laR /") { |rfd, wfd, pid|
-  puts "child pid=#{pid}"
-  while !rfd.eof? && (buf = rfd.gets)
-    puts "child: '#{buf.strip}'"
-  end
-}

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/qsort.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'ffi'
-
-module LibC
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
-  callback :qsort_cmp, [ :pointer, :pointer ], :int
-  attach_function :qsort, [ :pointer, :ulong, :ulong, :qsort_cmp ], :int
-end
-
-p = FFI::MemoryPointer.new(:int, 2)
-p.put_array_of_int32(0, [ 2, 1 ])
-puts "ptr=#{p.inspect}"
-puts "Before qsort #{p.get_array_of_int32(0, 2).join(', ')}"
-LibC.qsort(p, 2, 4) do |p1, p2|
-  i1 = p1.get_int32(0)
-  i2 = p2.get_int32(0)
-  puts "In block: comparing #{i1} and #{i2}"
-  i1 < i2 ? -1 : i1 > i2 ? 1 : 0
-end
-puts "After qsort #{p.get_array_of_int32(0, 2).join(', ')}"

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.12.2/samples/sample_helper.rb

@@ -1,6 +0,0 @@
-require 'rubygems'
-require 'spec'
-
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib"), File.join(File.dirname(__FILE__), "..", "build", RUBY_VERSION) unless RUBY_PLATFORM =~ /java/
-require "ffi"
-

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.0.0/.rubocop.yml

@@ -1,28 +0,0 @@
-require: rubocop-rspec
-Metrics/PerceivedComplexity:
-  Enabled: false
-Metrics/CyclomaticComplexity:
-  Enabled: false
-Metrics/MethodLength:
-  Enabled: false
-Metrics/AbcSize:
-  Enabled: false
-Metrics/LineLength:
-  Enabled: false
-Metrics/ClassLength:
-  Enabled: false
-Metrics/BlockLength:
-  Enabled: false
-Metrics/ModuleLength:
-  Enabled: false
-Style/Documentation:
-  Enabled: false
-Style/FrozenStringLiteralComment:
-  Enabled: true
-  EnforcedStyle: always
-Style/NumericPredicate:
-  Enabled: false
-Style/RedundantFreeze:
-  Enabled: false
-RSpec/ExampleLength:
-  Enabled: false

data/vendor/bundle/ruby/2.6.0/gems/hashdiff-1.0.0/README.md

@@ -1,272 +0,0 @@
-# Hashdiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.svg)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
-
-Hashdiff is a ruby library to compute the smallest difference between two hashes.
-
-It also supports comparing two arrays.
-
-Hashdiff does not monkey-patch any existing class. All features are contained inside the `Hashdiff` module.
-
-**Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
-
-
-__WARNING__: Don't use the library for comparing large arrays, say ~10K (see #49).
-
-## Why Hashdiff?
-
-Given two Hashes A and B, sometimes you face the question: what's the smallest modification that can be made to change A into B?
-
-An algorithm that responds to this question has to do following:
-
-* Generate a list of additions, deletions and changes, so that `A + ChangeSet = B` and `B - ChangeSet = A`.
-* Compute recursively -- Arrays and Hashes may be nested arbitrarily in A or B.
-* Compute the smallest change -- it should recognize similar child Hashes or child Arrays between A and B.
-
-Hashdiff answers the question above using an opinionated approach:
-
-* Hash can be represented as a list of (dot-syntax-path, value) pairs. For example, `{a:[{c:2}]}` can be represented as `["a[0].c", 2]`.
-* The change set can be represented using the dot-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
-* It compares Arrays using the [LCS(longest common subsequence)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
-* It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
-
-## Usage
-
-To use the gem, add the following to your Gemfile:
-
-```ruby
-gem 'hashdiff'
-```
-
-## Quick Start
-
-### Diff
-
-Two simple hashes:
-
-```ruby
-a = {a:3, b:2}
-b = {}
-
-diff = Hashdiff.diff(a, b)
-diff.should == [['-', 'a', 3], ['-', 'b', 2]]
-```
-
-More complex hashes:
-
-```ruby
-a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-b = {a:{y:3}, b:{y:3, z:30}}
-
-diff = Hashdiff.diff(a, b)
-diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
-```
-
-Arrays in hashes:
-
-```ruby
-a = {a:[{x:2, y:3, z:4}, {x:11, y:22, z:33}], b:{x:3, z:45}}
-b = {a:[{y:3}, {x:11, z:33}], b:{y:22}}
-
-diff = Hashdiff.best_diff(a, b)
-diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
-```
-
-### Patch
-
-patch example:
-
-```ruby
-a = {'a' => 3}
-b = {'a' => {'a1' => 1, 'a2' => 2}}
-
-diff = Hashdiff.diff(a, b)
-Hashdiff.patch!(a, diff).should == b
-```
-
-unpatch example:
-
-```ruby
-a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, {'x' => 5, 'y' => 6, 'z' => 3}, 1]
-b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
-
-diff = Hashdiff.diff(a, b) # diff two array is OK
-Hashdiff.unpatch!(b, diff).should == a
-```
-
-### Options
-
-There are eight options available: `:delimiter`, `:similarity`,
-`:strict`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path`
-and `:use_lcs`
-
-#### `:delimiter`
-
-You can specify `:delimiter` to be something other than the default dot. For example:
-
-```ruby
-a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-b = {a:{y:3}, b:{y:3, z:30}}
-
-diff = Hashdiff.diff(a, b, :delimiter => '\t')
-diff.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
-```
-
-#### `:similarity`
-
-In cases where you have similar hash objects in arrays, you can pass a custom value for `:similarity` instead of the default `0.8`.  This is interpreted as a ratio of similarity (default is 80% similar, whereas `:similarity => 0.5` would look for at least a 50% similarity).
-
-#### `:strict`
-
-The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, an Integer will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
-
-#### `:numeric_tolerance`
-
-The :numeric_tolerance option allows for a small numeric tolerance.
-
-```ruby
-a = {x:5, y:3.75, z:7}
-b = {x:6, y:3.76, z:7}
-
-diff = Hashdiff.diff(a, b, :numeric_tolerance => 0.1)
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:strip`
-
-The :strip option strips all strings before comparing.
-
-```ruby
-a = {x:5, s:'foo '}
-b = {x:6, s:'foo'}
-
-diff = Hashdiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:case_insensitive`
-
-The :case_insensitive option makes string comparisons ignore case.
-
-```ruby
-a = {x:5, s:'FooBar'}
-b = {x:6, s:'foobar'}
-
-diff = Hashdiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:array_path`
-
-The :array_path option represents the path of the diff in an array rather than
-a string. This can be used to show differences in between hash key types and
-is useful for `patch!` when used on hashes without string keys.
-
-```ruby
-a = {x:5}
-b = {'x'=>6}
-
-diff = Hashdiff.diff(a, b, :array_path => true)
-diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
-```
-
-For cases where there are arrays in paths their index will be added to the path.
-```ruby
-a = {x:[0,1]}
-b = {x:[0,2]}
-
-diff = Hashdiff.diff(a, b, :array_path => true)
-diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
-```
-
-This shouldn't cause problems if you are comparing an array with a hash:
-
-```ruby
-a = {x:{0=>1}}
-b = {x:[1]}
-
-diff = Hashdiff.diff(a, b, :array_path => true)
-diff.should == [["~", [:x], {0=>1}, [1]]]
-```
-
-#### `:use_lcs`
-
-The :use_lcs option is used to specify whether a
-[Longest common subsequence](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
-(LCS) algorithm is used to determine differences in arrays. This defaults to
-`true` but can be changed to `false` for significantly faster array comparisons
-(O(n) complexity rather than O(n<sup>2</sup>) for LCS).
-
-When :use_lcs is false the results of array comparisons have a tendency to
-show changes at indexes rather than additions and subtractions when :use_lcs is
-true.
-
-Note, currently the :similarity option has no effect when :use_lcs is false.
-
-```ruby
-a = {x: [0, 1, 2]}
-b = {x: [0, 2, 2, 3]}
-
-diff = Hashdiff.diff(a, b, :use_lcs => false)
-diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
-```
-
-#### Specifying a custom comparison method
-
-It's possible to specify how the values of a key should be compared.
-
-```ruby
-a = {a:'car', b:'boat', c:'plane'}
-b = {a:'bus', b:'truck', c:' plan'}
-
-diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when  /a|b|c/
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [['~', 'b', 'boat', 'truck']]
-```
-
-The yielded params of the comparison block is `|path, obj1, obj2|`, in which path is the key (or delimited compound key) to the value being compared. When comparing elements in array, the path is with the format `array[*]`. For example:
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'bus', b:['truck', ' plan'] }
-
-diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when 'b[*]'
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-", "b[0]", "boat"], ["+", "b[0]", "truck"]]
-```
-
-When a comparison block is given, it'll be given priority over other specified options. If the block returns value other than `true` or `false`, then the two values will be compared with other specified options.
-
-When used in conjunction with the `array_path` option, the path passed in as an argument will be an array. When determining the ordering of an array a key of `"*"` will be used in place of the `key[*]` field. It is possible, if you have hashes with integer or `"*"` keys, to have problems distinguishing between arrays and hashes - although this shouldn't be an issue unless your data is very difficult to predict and/or your custom rules are very specific.
-
-#### Sorting arrays before comparison
-
-An order difference alone between two arrays can create too many diffs to be useful. Consider sorting them prior to diffing.
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'car', b:['plane', 'boat'] }
-
-Hashdiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
-
-b[:b].sort!
-
-Hashdiff.diff(a, b) => []
-```
-
-## Maintainers
-
-- Krzysztof Rybka ([@krzysiek1507](https://github.com/krzysiek1507))
-- Fengyun Liu ([@liufengyun](https://github.com/liufengyun))
-
-## License
-
-Hashdiff is distributed under the MIT-LICENSE.