pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/dry-core-1.2.0/lib/dry/core/memoizable.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Dry
+  module Core
+    module Memoizable
+      MEMOIZED_HASH = {}.freeze
+      PARAM_PLACEHOLDERS = %i[* ** &].freeze
+
+      module ClassInterface
+        module Base
+          def memoize(*names)
+            prepend(Memoizer.new(self, names))
+          end
+
+          def inherited(base)
+            super
+
+            memoizer = base.ancestors.find { _1.is_a?(Memoizer) }
+            base.prepend(memoizer.dup) if memoizer
+          end
+        end
+
+        module BasicObject
+          include Base
+
+          def new(*, **)
+            obj = super
+            obj.instance_eval { @__memoized__ = MEMOIZED_HASH.dup }
+            obj
+          end
+        end
+
+        module Object
+          include Base
+
+          def new(*, **)
+            obj = super
+            obj.instance_variable_set(:@__memoized__, MEMOIZED_HASH.dup)
+            obj
+          end
+        end
+      end
+
+      def self.included(klass)
+        super
+
+        if klass <= Object
+          klass.extend(ClassInterface::Object)
+        else
+          klass.extend(ClassInterface::BasicObject)
+        end
+      end
+
+      # @api private
+      class Memoizer < ::Module
+        KERNEL = {
+          singleton: ::Kernel.instance_method(:singleton_class),
+          ivar_set: ::Kernel.instance_method(:instance_variable_set),
+          frozen: ::Kernel.instance_method(:frozen?)
+        }.freeze
+
+        # @api private
+        def initialize(klass, names)
+          super()
+          names.each do |name|
+            define_memoizable(
+              method: klass.instance_method(name)
+            )
+          end
+        end
+
+        private
+
+        # @api private
+        # rubocop:disable Metrics/AbcSize
+        def define_memoizable(method:)
+          parameters = method.parameters
+          mod = self
+          kernel = KERNEL
+
+          if parameters.empty?
+            key = "#{__id__}:#{method.name}".hash.abs
+
+            define_method(method.name) do
+              value = super()
+
+              if kernel[:frozen].bind_call(self)
+                # It's not possible to modify singleton classes
+                # of frozen objects
+                mod.remove_method(method.name)
+                mod.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                  def #{method.name}                          # def slow_calc
+                    cached = @__memoized__[#{key}]            #   cached = @__memoized__[12345678]
+                                                              #
+                    if cached || @__memoized__.key?(#{key})   #   if cached || @__memoized__.key?(12345678)
+                      cached                                  #     cached
+                    else                                      #   else
+                      @__memoized__[#{key}] = super           #     @__memoized__[12345678] = super
+                    end                                       #   end
+                  end                                         # end
+                RUBY
+              else
+                # We make an attr_reader for computed value.
+                # Readers are "special-cased" in ruby so such
+                # access will be the fastest way, faster than you'd
+                # expect :)
+                attr_name = :"__memozed_#{key}__"
+                ivar_name = :"@#{attr_name}"
+                kernel[:ivar_set].bind_call(self, ivar_name, value)
+                eigenclass = kernel[:singleton].bind_call(self)
+                eigenclass.attr_reader(attr_name)
+                eigenclass.alias_method(method.name, attr_name)
+                eigenclass.remove_method(attr_name)
+              end
+
+              value
+            end
+          else
+            mapping = parameters.to_h { |k, v = nil| [k, v] }
+            params, binds = declaration(parameters, mapping)
+            last_param = parameters.last
+
+            if last_param[0].eql?(:block) && !last_param[1].eql?(:&)
+              Deprecations.warn(<<~WARN)
+                Memoization for block-accepting methods isn't safe.
+                Every call creates a new block instance bloating cached results.
+                In the future, blocks will still be allowed but won't participate in
+                cache key calculation.
+              WARN
+            end
+
+            module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+              def #{method.name}(#{params.join(", ")})                 # def slow_calc(arg1, arg2, arg3)
+                key = [:"#{method.name}", #{binds.join(", ")}].hash    #   key = [:slow_calc, arg1, arg2, arg3].hash
+                                                                       #
+                if @__memoized__.key?(key)                             #   if @__memoized__.key?(key)
+                  @__memoized__[key]                                   #     @__memoized__[key]
+                else                                                   #   else
+                  @__memoized__[key] = super                           #     @__memoized__[key] = super
+                end                                                    #   end
+              end                                                      # end
+            RUBY
+
+          end
+        end
+
+        # rubocop:enable Metrics/AbcSize
+        # @api private
+        def declaration(definition, lookup)
+          params = []
+          binds = []
+          defined = {}
+
+          definition.each do |type, name|
+            mapped_type = map_bind_type(type, name, lookup, defined) do
+              raise ::NotImplementedError, "type: #{type}, name: #{name}"
+            end
+
+            if mapped_type
+              defined[mapped_type] = true
+              bind = name_from_param(name) || make_bind_name(binds.size)
+
+              binds << bind
+              params << param(bind, mapped_type)
+            end
+          end
+
+          [params, binds]
+        end
+
+        # @api private
+        def name_from_param(name)
+          if PARAM_PLACEHOLDERS.include?(name)
+            nil
+          else
+            name
+          end
+        end
+
+        # @api private
+        def make_bind_name(idx)
+          :"__lv_#{idx}__"
+        end
+
+        # @api private
+        def map_bind_type(type, name, original_params, defined_types) # rubocop:disable Metrics/PerceivedComplexity
+          case type
+          when :req
+            :reqular
+          when :rest, :keyreq, :keyrest
+            type
+          when :block
+            if name.eql?(:&)
+              # most likely this is a case of delegation
+              # rather than actual block
+              nil
+            else
+              type
+            end
+          when :opt
+            if original_params.key?(:rest) || defined_types[:rest]
+              nil
+            else
+              :rest
+            end
+          when :key
+            if original_params.key?(:keyrest) || defined_types[:keyrest]
+              nil
+            else
+              :keyrest
+            end
+          else
+            yield
+          end
+        end
+
+        # @api private
+        def param(name, type)
+          case type
+          when :reqular
+            name
+          when :rest
+            "*#{name}"
+          when :keyreq
+            "#{name}:"
+          when :keyrest
+            "**#{name}"
+          when :block
+            "&#{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-core-1.2.0/lib/dry/core/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Core
+    VERSION = "1.2.0"
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-core-1.2.0/lib/dry/core.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+require "dry/core/constants"
+require "dry/core/errors"
+require "dry/core/version"
+
+# :nodoc:
+module Dry
+  # :nodoc:
+  module Core
+    include Constants
+
+    def self.loader
+      @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
+        root = ::File.expand_path("..", __dir__)
+        loader.tag = "dry-core"
+        loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-core.rb")
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/dry-core.rb",
+          "#{root}/dry/core/{constants,errors,version}.rb"
+        )
+        loader.inflector.inflect("namespace_dsl" => "NamespaceDSL")
+      end
+    end
+
+    loader.setup
+
+    # Build an equalizer module for the inclusion in other class
+    #
+    # ## Credits
+    #
+    # Equalizer has been originally imported from the equalizer gem created by Dan Kubb
+    #
+    # @api public
+    def self.Equalizer(*keys, **options)
+      Equalizer.new(*keys, **options)
+    end
+  end
+
+  # See dry/core/equalizer.rb
+  unless singleton_class.method_defined?(:Equalizer)
+    # Build an equalizer module for the inclusion in other class
+    #
+    # ## Credits
+    #
+    # Equalizer has been originally imported from the equalizer gem created by Dan Kubb
+    #
+    # @api public
+    def self.Equalizer(*keys, **options)
+      ::Dry::Core::Equalizer.new(*keys, **options)
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-core-1.2.0/lib/dry-core.rb

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

data/vendor/bundle/ruby/3.3.0/gems/dry-inflector-1.3.1/CHANGELOG.md

@@ -0,0 +1,153 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Break Versioning](https://www.taoensso.com/break-versioning).
+
+## [Unreleased]
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+[Unreleased]: https://github.com/dry-rb/dry-inflector/compare/v1.3.1...main
+
+## [1.3.1] - 2026-01-13
+
+### Fixed
+
+- Improve pluralization of "-um" vs "-ium" words. "Premium" is now pluralized correctly. (@hmaddocks in #60)
+
+[1.3.1]: https://github.com/dry-rb/dry-inflector/compare/v1.3.0...v1.3.1
+
+## [1.3.0] - 2026-01-09
+
+### Changed
+
+- Require Ruby 3.2 or later. (@alassek)
+- Support characters with diacritics. (@cllns in #51)
+- Improve performance of #singularize. (@sandbergja in #53)
+- Remove redundant regexps for default inflections. (@hmaddocks in #59)
+
+### Fixed
+
+- Correctly handle pluralized aconyms in `#underscore`. For example, underscoring "CustomerAPIs" now gives "customer_apis". (@hmaddocks in #54)
+- Correctly singularize "uses" and pluralize "use". (@hmaddocks in #55)
+- Fix singularization of plurals ending in a vowel and "xes", such as "taxes" -> "tax". (@hmaddocks in #56)
+- Fix pluralization of words ending in "ee", such as "fee" -> "fees". (@hmaddocks in #57)
+- Fix singularizing of words like "leaves" and "thieves". (@hmaddocks in #58)
+- Fix pluralization of words ending in "f" that should _not_ have their ending turn into "ves", e.g. "roof"->"roofs" and "chief"->"chiefs". (@hmaddocks in #59)
+- Fix pluralization of "virus" into "viruses". (@hmaddocks in #59)
+
+[1.3.0]: https://github.com/dry-rb/dry-inflector/compare/v1.2.0...v1.3.0
+
+## [1.2.0] - 2025-01-04
+
+### Changed
+
+- Bumped required Ruby version to 3.1 (@flash-gordon)
+
+[1.2.0]: https://github.com/dry-rb/dry-inflector/compare/v1.1.0...v1.2.0
+
+## [1.1.0] - 2024-07-02
+
+### Added
+
+- Added "DB" as a default acronym. (@timriley in #49)
+
+### Fixed
+
+- Fix incorrect inflections on words separated by spaces, underscores or hyphens. (@parndt in #47)
+
+[1.1.0]: https://github.com/dry-rb/dry-inflector/compare/v1.0.0...v1.1.0
+
+## [1.0.0] - 2022-11-04
+
+### Changed
+
+- Bumped version to 1.0.0. (@solnic)
+
+[1.0.0]: https://github.com/dry-rb/dry-inflector/compare/v0.3.0...v1.0.0
+
+## [0.3.0] - 2022-07-12
+
+### Added
+
+- Add CSV as default acronym. (@waiting-for-dev in #43)
+
+### Changed
+
+- Extra dashes are now omitted when converting to camelcase. (@postmodern in #40)
+
+[0.3.0]: https://github.com/dry-rb/dry-inflector/compare/v0.2.1...v0.3.0
+
+## [0.2.1] - 2021-06-30
+
+### Added
+
+- Add default acronyms: API and CSRF. (@jodosha in #35)
+
+### Fixed
+
+- Fix singularizing -us suffix. (@cllns in #38)
+
+[0.2.1]: https://github.com/dry-rb/dry-inflector/compare/v0.2.0...v0.2.1
+
+## [0.2.0] - 2019-10-13
+
+### Added
+
+- Introduced `Dry::Inflector#camelize_upper` and `Dry::Inflector#camelize_lower`. `Dry::Inflector#camelize` is now an alias for `Dry::Inflector#camelize_upper`. (Abinoam P. Marques Jr. & Andrii Savchenko)
+
+  ```ruby
+  inflector.camelize_upper("data_mapper") # => "DataMapper"
+  inflector.camelize_lower("data_mapper") # => "dataMapper"
+  ``` 
+
+### Fixed
+
+- Fixed singularization rules for words like "alias" or "status". (ecnal)
+
+[0.2.0]: https://github.com/dry-rb/dry-inflector/compare/v0.1.2...v0.2.0
+
+## [0.1.2] - 2018-04-25
+
+### Added
+
+- Added support for acronyms. (Gustavo Caso & Nikita Shilnikov)
+
+[0.1.2]: https://github.com/dry-rb/dry-inflector/compare/v0.1.1...v0.1.2
+
+## [0.1.1] - 2017-11-18
+
+### Fixed
+
+- Ensure `Dry::Inflector#ordinalize` to work for all the numbers from 0 to 100. (Luca Guidi & Abinoam P. Marques Jr.)
+
+[0.1.1]: https://github.com/dry-rb/dry-inflector/compare/v0.1.0...v0.1.1
+
+## [0.1.0] - 2017-11-17
+
+### Added
+
+- Introduced `Dry::Inflector#pluralize`. (Luca Guidi)
+- Introduced `Dry::Inflector#singularize`. (Luca Guidi)
+- Introduced `Dry::Inflector#camelize`. (Luca Guidi)
+- Introduced `Dry::Inflector#classify`. (Luca Guidi)
+- Introduced `Dry::Inflector#tableize`. (Luca Guidi)
+- Introduced `Dry::Inflector#dasherize`. (Luca Guidi)
+- Introduced `Dry::Inflector#underscore`. (Luca Guidi)
+- Introduced `Dry::Inflector#demodulize`. (Luca Guidi)
+- Introduced `Dry::Inflector#humanize`. (Luca Guidi)
+- Introduced `Dry::Inflector#ordinalize`. (Luca Guidi)
+- Introduced `Dry::Inflector#foreign_key`. (Abinoam P. Marques Jr.)
+- Introduced `Dry::Inflector#constantize`. (Abinoam P. Marques Jr.)

data/vendor/bundle/ruby/3.3.0/gems/dry-inflector-1.3.1/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2026 Hanakai team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/3.3.0/gems/dry-inflector-1.3.1/README.md

@@ -0,0 +1,17 @@
+<!--- This file is synced from hanakai-rb/repo-sync -->
+
+[rubygem]: https://rubygems.org/gems/dry-inflector
+[actions]: https://github.com/dry-rb/dry-inflector/actions
+
+# dry-inflector [![Gem Version](https://badge.fury.io/rb/dry-inflector.svg)][rubygem] [![CI Status](https://github.com/dry-rb/dry-inflector/workflows/CI/badge.svg)][actions]
+
+## Links
+
+- [User documentation](https://dry-rb.org/gems/dry-inflector)
+- [API documentation](http://rubydoc.info/gems/dry-inflector)
+- [Forum](https://discourse.dry-rb.org)
+
+## License
+
+See `LICENSE` file.
+

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# This file is synced from hanakai-rb/repo-sync. To update it, edit repo-sync.yml.
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dry/inflector/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dry-inflector"
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
+  spec.license       = "MIT"
+  spec.version       = Dry::Inflector::VERSION.dup
+
+  spec.summary       = "String inflections for dry-rb"
+  spec.description   = spec.summary
+  spec.homepage      = "https://dry-rb.org/gems/dry-inflector"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-inflector.gemspec", "lib/**/*"]
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-inflector/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-inflector"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-inflector/issues"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end
+

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Dry
+  class Inflector
+    # A set of acronyms
+    #
+    # @since 0.1.2
+    # @api private
+    class Acronyms
+      attr_reader :regex
+
+      # @since 0.1.2
+      # @api private
+      def initialize
+        @rules = {}
+        define_regex_patterns
+      end
+
+      # @since 0.1.2
+      # @api private
+      def apply_to(word, capitalize: true)
+        @rules[word.downcase] || (capitalize ? word.capitalize : word)
+      end
+
+      # @since 0.1.2
+      # @api private
+      def add(rule, replacement)
+        @rules[rule] = replacement
+        define_regex_patterns
+      end
+
+      private
+
+      # @since 0.1.2
+      # @api private
+      def define_regex_patterns
+        regex = @rules.empty? ? /(?=a)b/ : /#{@rules.values.join("|")}/
+        @regex = /(?:(?<=([A-Za-z\d]))|\b)(#{regex})(?=\b|[^a-z])/
+      end
+    end
+  end
+end