pangea-core 0.1.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/dry-inflector-1.3.1/lib/dry/inflector.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+module Dry
+  # dry-inflector
+  #
+  # @since 0.1.0
+  class Inflector
+    require "dry/inflector/version"
+    require "dry/inflector/inflections"
+
+    # Instantiate the inflector
+    #
+    # @param blk [Proc] an optional block to specify custom inflection rules
+    # @yieldparam [Dry::Inflector::Inflections] the inflection rules
+    #
+    # @return [Dry::Inflector] the inflector
+    #
+    # @since 0.1.0
+    #
+    # @example Basic usage
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #
+    # @example Custom inflection rules
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new do |inflections|
+    #     inflections.plural      "virus",   "viruses" # specify a rule for #pluralize
+    #     inflections.singular    "thieves", "thief"   # specify a rule for #singularize
+    #     inflections.uncountable "dry-inflector"      # add an exception for an uncountable word
+    #   end
+    def initialize(&)
+      @inflections = Inflections.build(&)
+    end
+
+    # Lower camelize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the lower camelized string
+    #
+    # @since 0.1.3
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.camelize_lower("data_mapper") # => "dataMapper"
+    def camelize_lower(input)
+      internal_camelize(input, false)
+    end
+
+    # Upper camelize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the upper camelized string
+    #
+    # @since 0.1.3
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.camelize_upper("data_mapper") # => "DataMapper"
+    #   inflector.camelize_upper("dry/inflector") # => "Dry::Inflector"
+    def camelize_upper(input)
+      internal_camelize(input, true)
+    end
+
+    alias_method :camelize, :camelize_upper
+
+    # Find a constant with the name specified in the argument string
+    #
+    # The name is assumed to be the one of a top-level constant,
+    # constant scope of caller is ignored
+    #
+    # @param input [String,Symbol] the input
+    # @return [Class, Module] the class or module
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.constantize("Module")         # => Module
+    #   inflector.constantize("Dry::Inflector") # => Dry::Inflector
+    def constantize(input)
+      Object.const_get(input, false)
+    end
+
+    # Classify a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the classified string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.classify("books") # => "Book"
+    def classify(input)
+      camelize(singularize(input.to_s.split(".").last))
+    end
+
+    # Dasherize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the dasherized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.dasherize("dry_inflector") # => "dry-inflector"
+    def dasherize(input)
+      input.to_s.tr("_", "-")
+    end
+
+    # Demodulize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the demodulized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.demodulize("Dry::Inflector") # => "Inflector"
+    def demodulize(input)
+      input.to_s.split("::").last
+    end
+
+    # Humanize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the humanized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.humanize("dry_inflector") # => "Dry inflector"
+    #   inflector.humanize("author_id")     # => "Author"
+    def humanize(input)
+      input = input.to_s
+      result = inflections.humans.apply_to(input)
+      result.delete_suffix!("_id")
+      result.tr!("_", " ")
+      match = /([^[:alnum:]])/.match(result)
+      separator = match ? match[0] : DEFAULT_SEPARATOR
+      result.split(separator).map.with_index { |word, index|
+        inflections.acronyms.apply_to(word, capitalize: index.zero?)
+      }.join(separator)
+    end
+
+    # Creates a foreign key name
+    #
+    # @param input [String, Symbol] the input
+    # @return [String] foreign key
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.foreign_key("Message") => "message_id"
+    def foreign_key(input)
+      "#{underscore(demodulize(input))}_id"
+    end
+
+    # Ordinalize a number
+    #
+    # @param number [Integer] the input
+    # @return [String] the ordinalized number
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.ordinalize(1)  # => "1st"
+    #   inflector.ordinalize(2)  # => "2nd"
+    #   inflector.ordinalize(3)  # => "3rd"
+    #   inflector.ordinalize(10) # => "10th"
+    #   inflector.ordinalize(23) # => "23rd"
+    def ordinalize(number)
+      abs_value = number.abs
+
+      if ORDINALIZE_TH[abs_value % 100]
+        "#{number}th"
+      else
+        case abs_value % 10
+        when 1 then "#{number}st"
+        when 2 then "#{number}nd"
+        when 3 then "#{number}rd"
+        else        "#{number}th"
+        end
+      end
+    end
+
+    # Pluralize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the pluralized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.pluralize("book")  # => "books"
+    #   inflector.pluralize("money") # => "money"
+    def pluralize(input)
+      input = input.to_s
+      return input if uncountable?(input)
+
+      inflections.plurals.apply_to(input)
+    end
+
+    # Singularize a string
+    #
+    # @param input [String] the input
+    # @return [String] the singularized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.singularize("books") # => "book"
+    #   inflector.singularize("money") # => "money"
+    def singularize(input)
+      input = input.to_s
+      return input if uncountable?(input)
+
+      inflections.singulars.apply_to(input)
+    end
+
+    # Tableize a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the tableized string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.tableize("Book") # => "books"
+    def tableize(input)
+      input = input.to_s.gsub("::", "_")
+      pluralize(underscore(input))
+    end
+
+    # Underscore a string
+    #
+    # @param input [String,Symbol] the input
+    # @return [String] the underscored string
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "dry/inflector"
+    #
+    #   inflector = Dry::Inflector.new
+    #   inflector.underscore("dry-inflector") # => "dry_inflector"
+    def underscore(input)
+      input = input.to_s.gsub("::", "/")
+      input.gsub!(inflections.acronyms.regex) do
+        m1 = Regexp.last_match(1)
+        m2 = Regexp.last_match(2)
+        "#{m1 ? "_" : ""}#{m2.downcase}"
+      end
+      input.gsub!(/([[:upper:][:digit:]]+)([[:upper:]][[:lower:]])(?=[[:lower:]])/, '\1_\2')
+      input.gsub!(/([[:lower:][:digit:]])([[:upper:]])/, '\1_\2')
+      input.tr!("-", "_")
+      input.downcase!
+      input
+    end
+
+    # Check if the input is an uncountable word
+    #
+    # @param input [String] the input
+    # @return [TrueClass,FalseClass] the result of the check
+    #
+    # @since 0.1.0
+    # @api private
+    def uncountable?(input)
+      input.match?(/\A[[:space:]]*\z/) ||
+        inflections.uncountables.include?(input.downcase) ||
+        inflections.uncountables.include?(input.rpartition(/_|\b(?!\z)/).last.downcase)
+    end
+
+    # @return [String]
+    #
+    # @since 0.2.0
+    # @api public
+    def to_s
+      "#<Dry::Inflector>"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    # @since 0.1.0
+    # @api private
+    ORDINALIZE_TH = {11 => true, 12 => true, 13 => true}.freeze
+
+    # @since 0.1.2
+    # @api private
+    DEFAULT_SEPARATOR = " "
+
+    attr_reader :inflections
+
+    # @since 0.1.3
+    # @api private
+    def internal_camelize(input, upper)
+      input = input.to_s.dup
+      input.sub!(/^[[:lower:][:digit:]]*/) do |match|
+        inflections.acronyms.apply_to(match, capitalize: upper)
+      end
+      input.gsub!(%r{(?:[_-]|(/))([[:lower:][:digit:]]*)}i) do
+        m1 = Regexp.last_match(1)
+        m2 = Regexp.last_match(2)
+        "#{m1}#{inflections.acronyms.apply_to(m2)}"
+      end
+      input.gsub!("/", "::")
+      input
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-inflector-1.3.1/lib/dry-inflector.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "dry/inflector"

data/vendor/bundle/ruby/3.3.0/gems/dry-logic-1.6.0/CHANGELOG.md

@@ -0,0 +1,375 @@
+<!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
+
+## 1.6.0 2025-01-04
+
+
+### Fixed
+
+- Fix NoMethodError when trying to get AST of a Builder's result. (via #107) (@estum)
+
+### Changed
+
+- Set 3.1 as minimum ruby version (@flash-gordon)
+
+[Compare v1.5.0...v1.6.0](https://github.com/dry-rb/dry-logic/compare/v1.5.0...v1.6.0)
+
+## 1.5.0 2022-11-24
+
+
+### Added
+
+- `uri_rfc3986?` predicate that uses a better regexp than `uri?` (see #94 for more details) (@hieuk09)
+
+### Changed
+
+- Made `Predicates.respond_to?` compatible with `Object#respond_to?` (via #105) (@solnic)
+- Made `Predicates.eql?` compatible with `Object#eql?` (via #106) (@solnic)
+
+[Compare v1.4.0...v1.5.0](https://github.com/dry-rb/dry-logic/compare/v1.4.0...v1.5.0)
+
+## 1.4.0 2022-11-04
+
+
+### Changed
+
+- Updated to dry-core 1.0 (@flash-gordon + @solnic)
+
+[Compare v1.3.0...v1.4.0](https://github.com/dry-rb/dry-logic/compare/v1.3.0...v1.4.0)
+
+## 1.3.0 2022-10-15
+
+
+### Changed
+
+- Use zeitwerk for auto-loading (@solnic + @flash-gordon)
+
+[Compare v1.2.0...v1.3.0](https://github.com/dry-rb/dry-logic/compare/v1.2.0...v1.3.0)
+
+## 1.2.0 2021-04-26
+
+
+### Added
+
+- Add predicate and operation builder DSL (@oleander)
+
+
+[Compare v1.1.1...v1.2.0](https://github.com/dry-rb/dry-logic/compare/v1.1.1...v1.2.0)
+
+## 1.1.1 2021-04-14
+
+
+### Fixed
+
+- Fixed a crash under jruby caused by arg splatting in Binary operations (@flash-gordon)
+
+
+[Compare v1.1.0...v1.1.1](https://github.com/dry-rb/dry-logic/compare/v1.1.0...v1.1.1)
+
+## 1.1.0 2020-12-26
+
+
+### Fixed
+
+- Nested `Check` operations no longer crash under MRI 3.0 (@oleander)
+
+### Changed
+
+- Switched to equalizer from dry-core (@solnic)
+
+[Compare v1.0.8...v1.1.0](https://github.com/dry-rb/dry-logic/compare/v1.0.8...v1.1.0)
+
+## 1.0.8 2020-09-28
+
+
+### Fixed
+
+- Better Ruby 3 support with fixed specialization for rules of negative arity (@flash-gordon)
+
+
+[Compare v1.0.7...v1.0.8](https://github.com/dry-rb/dry-logic/compare/v1.0.7...v1.0.8)
+
+## 1.0.7 2020-08-13
+
+
+### Added
+
+- A new `uri?` predicate that you can use to verify `URI` strings, ie `uri?("https", "https://dry-rb.org")` (@nerburish)
+- New predicates: `uuid_v1?`, `uuid_v2?`, `uuid_v3?` and `uuid_v5?` (via #75) (@jamesbrauman)
+
+
+[Compare v1.0.6...v1.0.7](https://github.com/dry-rb/dry-logic/compare/v1.0.6...v1.0.7)
+
+## 1.0.6 2020-02-10
+
+
+### Fixed
+
+- Made the regexp used by `uuid_v4?` more secure (@kml)
+
+
+[Compare v1.0.5...v1.0.6](https://github.com/dry-rb/dry-logic/compare/v1.0.5...v1.0.6)
+
+## 1.0.5 2019-11-07
+
+
+### Fixed
+
+- Make `format?` tolerant to `nil` values. It already worked like that before, but starting Ruby 2.7 it would produce warnings. Now it won't. Don't rely on this behavior, it's only added to make tests pass in dry-schema. Use explicit type checks instead (@flash-gordon)
+
+
+[Compare v1.0.4...v1.0.5](https://github.com/dry-rb/dry-logic/compare/v1.0.4...v1.0.5)
+
+## 1.0.4 2019-11-06
+
+
+### Fixed
+
+- Fix keyword warnings (@flash-gordon)
+
+
+[Compare v1.0.3...v1.0.4](https://github.com/dry-rb/dry-logic/compare/v1.0.3...v1.0.4)
+
+## 1.0.3 2019-08-01
+
+
+### Added
+
+- `bytesize?` predicate (@bmalinconico)
+- `min_bytesize?` predicate (@bmalinconico)
+- `max_bytesize? predicate (@bmalinconico)
+
+### Changed
+
+- Min ruby version was set to `>= 2.4.0` (@flash-gordon)
+
+[Compare v1.0.2...v1.0.3](https://github.com/dry-rb/dry-logic/compare/v1.0.2...v1.0.3)
+
+## 1.0.2 2019-06-14
+
+Re-pushed 1.0.1 after dry-schema 1.2.0 release.
+
+
+[Compare v1.0.1...v1.0.2](https://github.com/dry-rb/dry-logic/compare/v1.0.1...v1.0.2)
+
+## 1.0.1 2019-06-04
+
+This release was removed from rubygems because it broke dry-schema.
+
+### Added
+
+- `uuid_v4?` predicate (radar)
+- `respond_to?` predicate (waiting-for-dev)
+
+
+[Compare v1.0.0...v1.0.1](https://github.com/dry-rb/dry-logic/compare/v1.0.0...v1.0.1)
+
+## 1.0.0 2019-04-23
+
+
+### Changed
+
+- Version bump to `1.0.0` (flash-gordon)
+
+[Compare v0.6.1...v1.0.0](https://github.com/dry-rb/dry-logic/compare/v0.6.1...v1.0.0)
+
+## 0.6.1 2019-04-18
+
+
+### Fixed
+
+- Fix a regression in dry-validation 0.x for argument-less predicates (flash-gordon)
+
+
+[Compare v0.6.0...v0.6.1](https://github.com/dry-rb/dry-logic/compare/v0.6.0...v0.6.1)
+
+## 0.6.0 2019-04-04
+
+
+### Added
+
+- Generating hints can be disabled by building `Operations::And` with `hints: false` option set (solnic)
+
+### Changed
+
+- `Rule` construction has been optimized so that currying and application is multiple-times faster (flash-gordon)
+
+[Compare v0.5.0...v0.6.0](https://github.com/dry-rb/dry-logic/compare/v0.5.0...v0.6.0)
+
+## 0.5.0 2019-01-29
+
+
+### Added
+
+- `:nil?` predicate (`none?` is now an alias) (solnic)
+
+### Fixed
+
+- `Operation::Key#ast` will now return a correct AST with non-Undefined inputs (solnic)
+
+
+[Compare v0.4.2...v0.5.0](https://github.com/dry-rb/dry-logic/compare/v0.4.2...v0.5.0)
+
+## 0.4.2 2017-09-15
+
+
+### Added
+
+- New `:case?` predicate matches a value against the given object with `#===` (flash-gordon)
+- New `:is?` predicate checks objects identity (using `#equal?`) (flash-gordon)
+
+### Fixed
+
+- A bug with using custom predicates within a standalone module in `dry-validation` (flash-gordon)
+
+
+[Compare v0.4.1...v0.4.2](https://github.com/dry-rb/dry-logic/compare/v0.4.1...v0.4.2)
+
+## 0.4.1 2017-01-23
+
+
+### Fixed
+
+- Warnings on MRI 2.4.0 are gone (jtippett)
+
+### Changed
+
+- Predicates simply reuse other predicate methods instead of referring to them via `#[]` (georgemillo)
+
+[Compare v0.4.0...v0.4.1](https://github.com/dry-rb/dry-logic/compare/v0.4.0...v0.4.1)
+
+## 0.4.0 2016-09-21
+
+This is a partial rewrite focused on internal clean up and major performance improvements. This is also the beginning of the work to make this library first-class rather than "just" a rule backend for dry-validation and dry-types.
+
+### Added
+
+- `Rule#[]` which applies a rule and always returns `true` or `false` (solnic)
+- `Rule#bind` which returns a rule with its predicate bound to a given object (solnic)
+- `Rule#eval_args` which evaluates unbound-methods-args in the context of a given object (solnic)
+- `Logic.Rule` builder function (solnic)
+- Nice `#inspect` on rules and operation objects (solnic)
+
+### Changed
+
+- [BRAEKING] New result API (solnic)
+- [BREAKING] `Predicate` is now `Rule::Predicate` (solnic)
+- [BREAKING] `Rule::Conjunction` is now `Operation::And` (solnic)
+- [BREAKING] `Rule::Disjunction` is now `Operation::Or` (solnic)
+- [BREAKING] `Rule::ExlusiveDisjunction` is now `Operation::Xor` (solnic)
+- [BREAKING] `Rule::Implication` is now `Operation::Implication` (solnic)
+- [BREAKING] `Rule::Set` is now `Operation::Set` (solnic)
+- [BREAKING] `Rule::Each` is now `Operation::Each` (solnic)
+- [BREAKING] `Rule.new` accepts a predicate function as its first arg now (solnic)
+- [BREAKING] `Rule#name` is now `Rule#id` (solnic)
+- `Rule#parameters` is public now (solnic)
+
+[Compare v0.3.0...v0.4.0](https://github.com/dry-rb/dry-logic/compare/v0.3.0...v0.4.0)
+
+## 0.3.0 2016-07-01
+
+
+### Added
+
+- `:type?` predicate imported from dry-types (solnic)
+- `Rule#curry` interface (solnic)
+
+### Changed
+
+- Predicates AST now includes information about args (names & possible values) (fran-worley + solnic)
+- Predicates raise errors when they are called with invalid arity (fran-worley + solnic)
+- Rules no longer evaluate input twice when building result objects (solnic)
+
+[Compare v0.2.3...v0.3.0](https://github.com/dry-rb/dry-logic/compare/v0.2.3...v0.3.0)
+
+## 0.2.3 2016-05-11
+
+
+### Added
+
+- `not_eql?`, `includes?`, `excludes?` predicates (fran-worley)
+
+### Changed
+
+- Renamed `inclusion?` to `included_in?` and deprecated `inclusion?` (fran-worley)
+- Renamed `exclusion?` to `excluded_from?` and deprecated `exclusion?` (fran-worley)
+
+[Compare v0.2.2...v0.2.3](https://github.com/dry-rb/dry-logic/compare/v0.2.2...v0.2.3)
+
+## 0.2.2 2016-03-30
+
+
+### Added
+
+- `number?`, `odd?`, `even?` predicates (fran-worley)
+
+
+[Compare v0.2.1...v0.2.2](https://github.com/dry-rb/dry-logic/compare/v0.2.1...v0.2.2)
+
+## 0.2.1 2016-03-20
+
+
+### Fixed
+
+- Result AST for `Rule::Each` correctly maps elements with eql inputs (solnic)
+
+
+[Compare v0.2.0...v0.2.1](https://github.com/dry-rb/dry-logic/compare/v0.2.0...v0.2.1)
+
+## 0.2.0 2016-03-11
+
+
+### Changed
+
+- Entire AST has been redefined (solnic)
+
+[Compare v0.1.4...v0.2.0](https://github.com/dry-rb/dry-logic/compare/v0.1.4...v0.2.0)
+
+## 0.1.4 2016-01-27
+
+
+### Added
+
+- Support for hash-names in `Check` and `Result` which can properly resolve input
+  from nested results (solnic)
+
+
+[Compare v0.1.3...v0.1.4](https://github.com/dry-rb/dry-logic/compare/v0.1.3...v0.1.4)
+
+## 0.1.3 2016-01-27
+
+
+### Added
+
+- Support for resolving input from `Rule::Result` (solnic)
+
+### Changed
+
+- `Check` and `Result` carry original input(s) (solnic)
+
+[Compare v0.1.2...v0.1.3](https://github.com/dry-rb/dry-logic/compare/v0.1.2...v0.1.3)
+
+## 0.1.2 2016-01-19
+
+
+### Fixed
+
+- `xor` returns wrapped results when used against another result-rule (solnic)
+
+
+[Compare v0.1.1...v0.1.2](https://github.com/dry-rb/dry-logic/compare/v0.1.1...v0.1.2)
+
+## 0.1.1 2016-01-18
+
+
+### Added
+
+- `Rule::Attr` which can be applied to a data object with attr readers (SunnyMagadan)
+- `Rule::Result` which can be applied to a result object (solnic)
+- `true?` and `false?` predicates (solnic)
+
+
+[Compare v0.1.0...v0.1.1](https://github.com/dry-rb/dry-logic/compare/v0.1.0...v0.1.1)
+
+## 0.1.0 2016-01-11
+
+Code extracted from dry-validation 0.4.1