pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb/parser.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module TomlRB
+  class Parser
+    BASIC_STRING = /(?:[^"\\\x00-\x08\x0a-\x1f\x7f]|\\.)*/
+    LITERAL_STRING = /[^'\x00-\x08\x0a-\x1f\x7f]*/
+    MULTILINE_STRING = /(?:[^"\\\x00-\x08\x0b-\x1f\x7f]|\r\n|\\(?:[^\r]|\r\n)|"{1,2}(?!"))*(?:"{0,2}(?="""))?/
+    MULTILINE_LITERAL = /(?:[^'\x00-\x08\x0b-\x1f\x7f]|\r\n|'{1,2}(?!'))*(?:'{0,2}(?='''))?/
+    # A UTF-8 regexp raises Encoding::CompatibilityError on binary input with high bytes.
+    COMMENT = /[^\x00-\x08\x0a-\x1f\x7f]*/u
+    DATETIME = /(\d{4})-(\d\d)-(\d\d)(?:[Tt ]([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?([Zz]|[+-]\d\d:\d\d)?)?/
+    TIME = /([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?/
+    PREFIXED_INTEGER = /0x[0-9a-fA-F](?:_?[0-9a-fA-F])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*/
+    DECIMAL = /[+-]?(?:0|[1-9](?:_?\d)*)(\.\d(?:_?\d)*(?:[eE][+-]?\d(?:_?\d)*)?|[eE][+-]?\d(?:_?\d)*)?/
+    MAX_NESTING = 100
+
+    attr_reader :hash
+
+    def initialize(content, symbolize_keys: false)
+      @hash = {}
+      # Tables and arrays of tables that headers or dotted keys made, by identity:
+      # :implicit (super-table of a header), :explicit (header) or :dotted (dotted key).
+      # Inline tables and static arrays are absent, so no header or dotted key can enter them.
+      @tables = {}.compare_by_identity
+      @current = @hash
+      @symbolize_keys = symbolize_keys
+      @depth = 0
+
+      begin
+        @scanner = StringScanner.new(source_text(content))
+        # The visitor runs after the whole document is parsed, so a syntax
+        # error wins over a key or table that the visitor rejects.
+        document.each { |statement| statement.accept_visitor(self) }
+      rescue Encoding::CompatibilityError => e
+        raise TomlRB::ParseError.new("Encoding error: #{e.message}")
+      rescue ArgumentError => e
+        if e.message.include?("invalid byte sequence") || e.message.include?("encoding")
+          raise TomlRB::ParseError.new("Encoding error: #{e.message}")
+        else
+          raise
+        end
+      end
+    end
+
+    # Read about the Visitor pattern
+    # http://en.wikipedia.org/wiki/Visitor_pattern
+    def visit_table_array(table_array)
+      @current = table_array.navigate_keys @hash, @tables, @symbolize_keys
+    end
+
+    def visit_table(table)
+      @current = table.navigate_keys @hash, @tables, @symbolize_keys
+    end
+
+    def visit_keyvalue(keyvalue)
+      keyvalue.assign @current, @tables, @symbolize_keys
+    end
+
+    private
+
+    def source_text(source)
+      if source.respond_to?(:to_path)
+        File.read(source.to_path)
+      elsif source.respond_to?(:read)
+        source.read
+      elsif source.respond_to?(:to_str)
+        source.to_str
+      else
+        raise ArgumentError, "Unable to parse from #{source}"
+      end
+    end
+
+    def document
+      statements = []
+      loop do
+        @scanner.skip(/(?:[ \t]*\r?\n)*[ \t]*/)
+        return statements if @scanner.eos?
+
+        statements << statement unless @scanner.match?(/#/)
+        line_end
+      end
+    end
+
+    def statement
+      if @scanner.match?(/\[/)
+        @scanner.match?(/\[\[/) ? table_array : table
+      else
+        keyvalue
+      end
+    end
+
+    def table_array
+      @scanner.skip(/\[\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]\]/, "']]'")
+      TableArray.new(keys)
+    end
+
+    def table
+      @scanner.skip(/\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]/, "']'")
+      Table.new(keys)
+    end
+
+    def keyvalue
+      keys = key
+      expect(/[ \t]*=[ \t]*/, "'='")
+      Keyvalue.new(keys, value)
+    end
+
+    def key
+      keys = [simple_key]
+      keys << simple_key while @scanner.skip(/[ \t]*\.[ \t]*/)
+      keys
+    end
+
+    def simple_key
+      if (bare = @scanner.scan(/[A-Za-z0-9_-]+/))
+        bare
+      elsif @scanner.match?(/"/)
+        basic_string
+      elsif @scanner.match?(/'/)
+        literal_string
+      else
+        syntax_error("a key")
+      end
+    end
+
+    def value
+      case @scanner.peek(1)
+      when '"'
+        @scanner.match?(/"""/) ? multiline_string : basic_string
+      when "'"
+        @scanner.match?(/'''/) ? multiline_literal : literal_string
+      when "["
+        nested { array }
+      when "{"
+        nested { inline_table }
+      when "t"
+        expect(/true/, "a value")
+        true
+      when "f"
+        expect(/false/, "a value")
+        false
+      else
+        datetime || local_time || number
+      end
+    end
+
+    def basic_string
+      @scanner.skip(/"/)
+      text = @scanner.scan(BASIC_STRING)
+      expect(/"/, %('"'))
+      unescape(text)
+    end
+
+    def literal_string
+      @scanner.skip(/'/)
+      text = @scanner.scan(LITERAL_STRING)
+      expect(/'/, %("'"))
+      text
+    end
+
+    def multiline_string
+      start = @scanner.pos
+      @scanner.skip(/"""(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_STRING)
+      @scanner.skip(/"""/) || syntax_error(%('"""' to close the string at #{location(start)}))
+      unescape(text)
+    end
+
+    def multiline_literal
+      start = @scanner.pos
+      @scanner.skip(/'''(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_LITERAL)
+      @scanner.skip(/'''/) || syntax_error(%("'''" to close the string at #{location(start)}))
+      text
+    end
+
+    def unescape(text)
+      text.include?("\\") ? BasicString.transform_escaped_chars(text) : text
+    end
+
+    def datetime
+      return unless @scanner.skip(DATETIME)
+
+      year, mon, day, hour, min, sec, sec_frac, offset = @scanner.values_at(1, 2, 3, 4, 5, 6, 7, 8)
+      if hour.nil?
+        DatetimeParser.local_date(year, mon, day)
+      elsif offset
+        DatetimeParser.offset_datetime(year, mon, day, hour, min, sec, sec_frac, offset)
+      else
+        DatetimeParser.local_datetime(year, mon, day, hour, min, sec, sec_frac)
+      end
+    end
+
+    def local_time
+      DatetimeParser.local_time(*@scanner.values_at(1, 2, 3, 4)) if @scanner.skip(TIME)
+    end
+
+    def number
+      if (text = @scanner.scan(PREFIXED_INTEGER))
+        Integer(text)
+      elsif (text = @scanner.scan(DECIMAL))
+        @scanner[1] ? text.to_f : text.to_i
+      elsif (text = @scanner.scan(/[+-]?inf/))
+        text.start_with?("-") ? -Float::INFINITY : Float::INFINITY
+      elsif @scanner.skip(/[+-]?nan/)
+        Float::NAN
+      else
+        syntax_error("a value")
+      end
+    end
+
+    def array
+      @scanner.skip(/\[/)
+      values = []
+      loop do
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        values << value
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        expect(/,/, "',' or ']'")
+      end
+    end
+
+    def inline_table
+      @scanner.skip(/\{/)
+      pairs = []
+      loop do
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        pairs << keyvalue
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        expect(/,/, "',' or '}'")
+      end
+    end
+
+    # Each nested array or inline table recurses, so the limit stops a deep
+    # document before it exhausts the stack.
+    def nested
+      @depth += 1
+      syntax_error("at most #{MAX_NESTING} nested arrays and inline tables") if @depth > MAX_NESTING
+      yield
+    ensure
+      @depth -= 1
+    end
+
+    def line_end
+      return if @scanner.skip(/[ \t]*\r?\n/)
+
+      @scanner.skip(/[ \t]*/)
+      @scanner.skip(COMMENT) if @scanner.skip(/#/)
+      new_line
+    end
+
+    def skip_whitespace_and_comments
+      @scanner.skip(/[ \t\r\n]*/)
+      while @scanner.skip(/#/)
+        @scanner.skip(COMMENT)
+        new_line
+        @scanner.skip(/[ \t\r\n]*/)
+      end
+    end
+
+    def new_line
+      @scanner.skip(/\r?\n/) || @scanner.eos? || syntax_error("a new line")
+    end
+
+    def expect(pattern, expected)
+      @scanner.skip(pattern) || syntax_error(expected)
+    end
+
+    def syntax_error(expected)
+      @scanner.skip(/[ \t]*/)
+      found = @scanner.eos? ? "end of input" : @scanner.check(/./m).inspect
+      raise ParseError, "Unexpected #{found} at #{location(@scanner.pos)}: expected #{expected}"
+    end
+
+    def location(pos)
+      consumed = @scanner.string.byteslice(0, pos)
+      line = consumed.count("\n") + 1
+      column = consumed.length - (consumed.rindex("\n") || -1)
+      "line #{line}, column #{column}"
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb/string.rb

@@ -0,0 +1,41 @@
+module TomlRB
+  module BasicString
+    SPECIAL_CHARS = {
+      "\\t" => "\t",
+      "\\b" => "\b",
+      "\\e" => "\e",
+      "\\f" => "\f",
+      "\\n" => "\n",
+      "\\r" => "\r",
+      '\\"' => '"',
+      "\\\\" => "\\"
+    }.freeze
+
+    # Replace the unicode escaped characters with the corresponding character
+    # e.g. \u03B4 => ?
+    def self.decode_unicode(str)
+      code = str[2..-1].to_i(16)
+      if code.between?(0xD800, 0xDFFF) || code > 0x10FFFF
+        fail ParseError.new "Escape sequence #{str} is not a Unicode scalar value"
+      end
+
+      [code].pack("U")
+    end
+
+    def self.transform_escaped_chars(str)
+      str.gsub(/\\(x[\da-fA-F]{2}|u[\da-fA-F]{4}|U[\da-fA-F]{8}|[ \t]*\r?\n[ \t\r\n]*|.)/) do |m|
+        if m.include?("\n")
+          ""
+        elsif m.size == 2
+          SPECIAL_CHARS[m] || parse_error(m)
+        else
+          decode_unicode(m).force_encoding("UTF-8")
+        end
+      end
+    end
+
+    def self.parse_error(m)
+      fail ParseError.new "Escape sequence #{m} is reserved"
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb/table.rb

@@ -0,0 +1,34 @@
+module TomlRB
+  class Table
+    def initialize(dotted_keys)
+      @dotted_keys = dotted_keys
+    end
+
+    def navigate_keys(hash, tables, symbolize_keys = false)
+      current = hash
+      keys = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+      keys.each do |key|
+        unless current.key?(key)
+          current[key] = {}
+          tables[current[key]] = :implicit
+        end
+        element = current[key]
+        fail ValueOverwriteError.new(key) unless tables.key?(element)
+
+        current = element.is_a?(Array) ? element.last : element
+      end
+      fail ValueOverwriteError.new(full_key) unless tables[current] == :implicit
+
+      tables[current] = :explicit
+      current
+    end
+
+    def accept_visitor(parser)
+      parser.visit_table self
+    end
+
+    def full_key
+      @dotted_keys.join(".")
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb/table_array.rb

@@ -0,0 +1,43 @@
+module TomlRB
+  class TableArray
+    def initialize(dotted_keys)
+      @dotted_keys = dotted_keys
+    end
+
+    def navigate_keys(hash, tables, symbolize_keys = false)
+      current = hash
+      *keys, last_key = symbolize_keys ? @dotted_keys.map(&:to_sym) : @dotted_keys
+
+      # Go over the parent keys
+      keys.each do |key|
+        unless current.key?(key)
+          current[key] = {}
+          tables[current[key]] = :implicit
+        end
+        element = current[key]
+        fail ValueOverwriteError.new(key) unless tables.key?(element)
+
+        current = element.is_a?(Array) ? element.last : element
+      end
+
+      # Define Table Array
+      if current[last_key].is_a? Hash
+        fail TomlRB::ParseError,
+          "#{last_key} was defined as hash but is now redefined as a table!"
+      end
+      unless current.key?(last_key)
+        current[last_key] = []
+        tables[current[last_key]] = :explicit
+      end
+      fail ValueOverwriteError.new(last_key) unless tables.key?(current[last_key])
+
+      current[last_key] << {}
+      tables[current[last_key].last] = :explicit
+      current[last_key].last
+    end
+
+    def accept_visitor(parser)
+      parser.visit_table_array self
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TomlRB
+  VERSION = "6.0.0"
+end

data/vendor/bundle/ruby/3.4.0/gems/toml-rb-6.0.0/lib/toml-rb.rb

@@ -0,0 +1,90 @@
+require_relative "toml-rb/errors"
+require_relative "toml-rb/string"
+require_relative "toml-rb/datetime"
+require_relative "toml-rb/table"
+require_relative "toml-rb/table_array"
+require_relative "toml-rb/inline_table"
+require_relative "toml-rb/keyvalue"
+require_relative "toml-rb/parser"
+require_relative "toml-rb/dumper"
+
+module TomlRB
+  # Public: Returns a hash from *TomlRB* content.
+  #
+  # content         - TomlRB string to be parsed.
+  # :symbolize_keys - true | false (default: false).
+  #
+  #
+  # Examples
+  #
+  #   TomlRB.parse('[group]')
+  #   # => {"group"=>{}}
+  #
+  #   TomlRB.parse('title = "TomlRB parser"')
+  #   # => {"title"=>"TomlRB parser"}
+  #
+  #   TomlRB.parse('[group]', symbolize_keys: true)
+  #   # => {group: {}}
+  #
+  #   TomlRB.parse('title = "TomlRB parser"', symbolize_keys: true)
+  #   # => {title: "TomlRB parser"}
+  #
+  #
+  # Returns a Ruby hash representation of the content according to TomlRB spec.
+  # Raises ValueOverwriteError if a key is overwritten.
+  # Raises ParseError if the content has invalid TomlRB.
+  def self.parse(content, symbolize_keys: false)
+    Parser.new(content, symbolize_keys: symbolize_keys).hash
+  end
+
+  # Public: Returns a hash from a *TomlRB* file.
+  #
+  # path            - TomlRB File path
+  # :symbolize_keys - true|false (optional).
+  #
+  #
+  # Examples
+  #
+  #   TomlRB.load_file('/tmp/simple.toml')
+  #   # => {"group"=>{}}
+  #
+  #   TomlRB.load_file('/tmp/simple.toml', symbolize_keys: true)
+  #   # => {group: {}}
+  #
+  #
+  # Returns a Ruby hash representation of the content.
+  # Raises ValueOverwriteError if a key is overwritten.
+  # Raises ParseError if the content has invalid TomlRB.
+  # Raises Errno::ENOENT if the file cannot be found.
+  # Raises Errno::EACCES if the file cannot be accessed.
+  def self.load_file(path, symbolize_keys: false)
+    TomlRB.parse(File.read(path, encoding: "UTF-8"), symbolize_keys: symbolize_keys)
+  end
+
+  # Public: Returns a *TomlRB* string from a Ruby Hash.
+  #
+  # hash - Ruby Hash to be dumped into *TomlRB*
+  #
+  #
+  # Examples
+  #
+  #   TomlRB.dump(title: 'TomlRB dump')
+  #   # => "simple = true\n"
+  #
+  #   hash = {
+  #     "title"=>"wow!",
+  #     "awesome"=> {
+  #       "you"=>true,
+  #       "others"=>false
+  #     }
+  #   }
+  #
+  #   TomlRB.dump(hash)
+  #   # => "title = \"wow!\"\n[awesome]\nothers = false\nyou = true\n"
+  #
+  #
+  # Returns a TomlRB string representing the hash.
+  def self.dump(hash)
+    Dumper.new(hash).toml_str
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "rake"
+gem "test-unit"

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/README.md

@@ -0,0 +1,72 @@
+# TSort
+
+TSort implements topological sorting using Tarjan's algorithm for
+strongly connected components.
+
+TSort is designed to be able to be used with any object which can be
+interpreted as a directed graph.
+
+TSort requires two methods to interpret an object as a graph,
+tsort_each_node and tsort_each_child.
+
+* tsort_each_node is used to iterate for all nodes over a graph.
+* tsort_each_child is used to iterate for child nodes of a given node.
+
+The equality of nodes are defined by eql? and hash since
+TSort uses Hash internally.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tsort'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install tsort
+
+## Usage
+
+The following example demonstrates how to mix the TSort module into an
+existing class (in this case, Hash). Here, we're treating each key in
+the hash as a node in the graph, and so we simply alias the required
+#tsort_each_node method to Hash's #each_key method. For each key in the
+hash, the associated value is an array of the node's child nodes. This
+choice in turn leads to our implementation of the required #tsort_each_child
+method, which fetches the array of child nodes and then iterates over that
+array using the user-supplied block.
+
+```ruby
+require 'tsort'
+
+class Hash
+  include TSort
+  alias tsort_each_node each_key
+  def tsort_each_child(node, &block)
+    fetch(node).each(&block)
+  end
+end
+
+{1=>[2, 3], 2=>[3], 3=>[], 4=>[]}.tsort
+#=> [3, 2, 1, 4]
+
+{1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}.strongly_connected_components
+#=> [[4], [2, 3], [1]]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/tsort.
+

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tsort"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/vendor/bundle/ruby/3.4.0/gems/tsort-0.2.0/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here