pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 8
+total_score: 52

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/flog.yml

@@ -0,0 +1,2 @@
+---
+threshold: 5.5

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/mutant.yml

@@ -0,0 +1,4 @@
+---
+name: ice_nine
+namespace: IceNine
+since: HEAD~1

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/reek.yml

@@ -0,0 +1,105 @@
+---
+Attribute:
+  enabled: true
+  exclude: []
+BooleanParameter:
+  enabled: true
+  exclude: []
+ClassVariable:
+  enabled: true
+  exclude: []
+ControlParameter:
+  enabled: true
+  exclude: []
+DataClump:
+  enabled: true
+  exclude: []
+  max_copies: 2
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: true
+  exclude: []
+  max_calls: 1
+  allow_calls: []
+FeatureEnvy:
+  enabled: true
+  exclude:
+  - IceNine::RecursionGuard::Frozen#guard
+IrresponsibleModule:
+  enabled: true
+  exclude: []
+LongParameterList:
+  enabled: true
+  exclude: []
+  max_params: 2
+  overrides:
+    initialize:
+      max_params: 3
+LongYieldList:
+  enabled: true
+  exclude: []
+  max_params: 2
+NestedIterators:
+  enabled: true
+  exclude: []
+  max_allowed_nesting: 1
+  ignore_iterators: []
+NilCheck:
+  enabled: true
+  exclude: []
+RepeatedConditional:
+  enabled: true
+  exclude: []
+  max_ifs: 1
+TooManyInstanceVariables:
+  enabled: true
+  exclude: []
+  max_instance_variables: 3
+TooManyMethods:
+  enabled: true
+  exclude: []
+  max_methods: 10
+TooManyStatements:
+  enabled: true
+  exclude:
+  - each
+  max_statements: 5
+UncommunicativeMethodName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeModuleName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  accept: []
+UncommunicativeParameterName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeVariableName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UnusedParameters:
+  enabled: true
+  exclude: []
+UtilityFunction:
+  enabled: true
+  exclude:
+  - IceNine::RecursionGuard::Frozen#guard
+  max_helper_calls: 0

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/roodi.yml

@@ -0,0 +1,16 @@
+---
+AbcMetricMethodCheck:            { score: 1 }
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 88 }
+ClassNameCheck:                  { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
+ClassVariableCheck:              { }
+CyclomaticComplexityBlockCheck:  { complexity: 3 }
+CyclomaticComplexityMethodCheck: { complexity: 1 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+MethodLineCountCheck:            { line_count: 1 }
+MethodNameCheck:                 { pattern: !ruby/regexp '/\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|<<|[+*&|-])\z/' }
+ModuleLineCountCheck:            { line_count: 92 }
+ModuleNameCheck:                 { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
+ParameterNumberCheck:            { parameter_count: 0 }

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/rubocop.yml

@@ -0,0 +1,114 @@
+inherit_from: ../.rubocop.yml
+
+# Avoid parameter lists longer than five parameters.
+ParameterLists:
+  Max: 3
+  CountKeywordArgs: true
+
+# Avoid more than `Max` levels of nesting.
+BlockNesting:
+  Max: 3
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    inject:   'reduce'
+    find:     'detect'
+    find_all: 'select'
+
+# Do not force public/protected/private keyword to be indented at the same
+# level as the def keyword. My personal preference is to outdent these keywords
+# because I think when scanning code it makes it easier to identify the
+# sections of code and visually separate them. When the keyword is at the same
+# level I think it sort of blends in with the def keywords and makes it harder
+# to scan the code and see where the sections are.
+AccessModifierIndentation:
+  Enabled: false
+
+# Limit line length
+LineLength:
+  Max: 79
+
+# Disable documentation checking until a class needs to be documented once
+Documentation:
+  Enabled: false
+
+# Do not always use &&/|| instead of and/or.
+AndOr:
+  Enabled: false
+
+# Do not favor modifier if/unless usage when you have a single-line body
+IfUnlessModifier:
+  Enabled: false
+
+# Allow case equality operator (in limited use within the specs)
+CaseEquality:
+  Enabled: false
+
+# Constants do not always have to use SCREAMING_SNAKE_CASE
+ConstantName:
+  Enabled: false
+
+# Not all trivial readers/writers can be defined with attr_* methods
+TrivialAccessors:
+  Enabled: false
+
+# Allow empty lines around class body
+EmptyLinesAroundClassBody:
+  Enabled: false
+
+# Allow empty lines around module body
+EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# Allow multiple line operations to not require indentation
+MultilineOperationIndentation:
+  Enabled: false
+
+# Prefer String#% over Kernel#sprintf
+FormatString:
+  Enabled: false
+
+# Use square brackets for literal Array objects
+PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  ()
+    '%i': '[]'
+    '%q': ()
+    '%Q': ()
+    '%r': '{}'
+    '%s': ()
+    '%w': '[]'
+    '%W': '[]'
+    '%x': ()
+
+# Align if/else blocks with the variable assignment
+EndAlignment:
+  AlignWith: variable
+
+# Do not always align parameters when it is easier to read
+AlignParameters:
+  Exclude:
+    - spec/**/*_spec.rb
+
+# Prefer #kind_of? over #is_a?
+ClassCheck:
+  EnforcedStyle: kind_of?
+
+# Do not prefer double quotes to be used when %q or %Q is more appropriate
+UnneededPercentQ:
+  Enabled: false
+
+# Allow a maximum ABC score
+Metrics/AbcSize:
+  Max: 6.08
+
+# Allow modules to be qualified with a "::" prefix
+ClassAndModuleChildren:
+  Exclude:
+    - spec/**/*_spec.rb
+
+# Allow additional spaces
+ExtraSpacing:
+  Enabled: false

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/ice_nine.gemspec

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/ice_nine/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'ice_nine'
+  gem.version     = IceNine::VERSION.dup
+  gem.authors     = ['Dan Kubb']
+  gem.email       = %w[dan.kubb@gmail.com]
+  gem.description = 'Deep Freeze Ruby Objects'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/dkubb/ice_nine'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec/{unit,integration}`.split($/)
+  gem.extra_rdoc_files = %w[LICENSE README.md TODO]
+
+  gem.add_development_dependency('bundler', '~> 1.6', '>= 1.6.1')
+end

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/core_ext/object.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module IceNine
+
+  # Core Ruby extensions
+  module CoreExt
+
+    # Extend Object with deep freezing
+    module Object
+
+      # Deep freeze an object
+      #
+      # @example
+      #   object = object.deep_freeze
+      #
+      # @return [self]
+      #
+      # @api public
+      def deep_freeze
+        IceNine.deep_freeze(self)
+      end
+
+      # Deep freeze an object
+      #
+      # @see IceNine.deep_freeze!
+      #
+      # @example
+      #   object = object.deep_freeze!
+      #
+      # @return [self]
+      #
+      # @api public
+      def deep_freeze!
+        IceNine.deep_freeze!(self)
+      end
+
+    end # Object
+  end # CoreExt
+end # IceNine
+
+# Add Object#deep_freeze
+Object.instance_eval { include IceNine::CoreExt::Object }

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/array.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Array objects
+    class Array < Object
+
+      # Deep Freeze an Array
+      #
+      # @example
+      #   array = IceNine:Freezer::Array.deep_freeze(%w[a b c])
+      #   array.select(&:frozen?)  # => ['a', 'b', 'c']
+      #
+      # @param [Array] array
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [Array]
+      def self.guarded_deep_freeze(array, recursion_guard)
+        super
+        array.each do |entry|
+          Freezer.guarded_deep_freeze(entry, recursion_guard)
+        end
+      end
+
+    end # Array
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/false_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing false objects
+    class FalseClass < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/hash/state.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+    class Hash
+
+      # Skip freezing Hash::State objects on Rubinius
+      class State < NoFreeze; end
+
+    end # Hash
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/hash.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Hash objects
+    class Hash < Object
+
+      # Deep Freeze a Hash
+      #
+      # @example
+      #   hash = IceNine::Freezer::Hash.deep_freeze('a' => '1', 'b' => '2')
+      #   hash.keys.select(&:frozen?)    # => ['a', 'b']
+      #   hash.values.select(&:frozen?)  # => ['1', '2']
+      #
+      # @param [Hash] hash
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [Hash]
+      def self.guarded_deep_freeze(hash, recursion_guard)
+        super
+        default = hash.default_proc || hash.default
+        Freezer.guarded_deep_freeze(default, recursion_guard)
+        freeze_key_value_pairs(hash, recursion_guard)
+      end
+
+      # Handle freezing the key/value pairs
+      #
+      # @param [Hash] hash
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.freeze_key_value_pairs(hash, recursion_guard)
+        hash.each do |key, value|
+          Freezer.guarded_deep_freeze(key, recursion_guard)
+          Freezer.guarded_deep_freeze(value, recursion_guard)
+        end
+      end
+
+      private_class_method :freeze_key_value_pairs
+
+    end # Hash
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/module.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing Module objects
+    class Module < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/nil_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing nil objects
+    class NilClass < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/no_freeze.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class that does not freeze anything
+    class NoFreeze < self
+
+      # Pass through the object without freezing it
+      #
+      # @example
+      #   object = IceNine::Freezer::NoFreeze.deep_freeze(object)
+      #   object.frozen?  # => false
+      #
+      # @param [Object] object
+      # @param [RecursionGuard] _recursion_guard
+      #
+      # @return [Object]
+      def self.guarded_deep_freeze(object, _recursion_guard)
+        object
+      end
+
+    end # NoFreeze
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/numeric.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing Numeric objects
+    class Numeric < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/object.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Object instances
+    class Object < self
+
+      # Deep Freeze an object
+      #
+      # @example
+      #   object = IceNine.deep_freeze(Object.new)
+      #
+      # @param [Object] object
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [Object]
+      def self.guarded_deep_freeze(object, recursion_guard)
+        return object unless object.respond_to?(:freeze)
+
+        object.freeze
+        freeze_instance_variables(object, recursion_guard)
+        object
+      end
+
+      # Handle freezing the object's instance variables
+      #
+      # @param [Object] object
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.freeze_instance_variables(object, recursion_guard)
+        object.instance_variables.each do |ivar_name|
+          Freezer.guarded_deep_freeze(
+            object.instance_variable_get(ivar_name),
+            recursion_guard
+          )
+        end
+      end
+
+      private_class_method :freeze_instance_variables
+
+    end # Object
+
+    BasicObject = Object
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/range.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Range objects
+    class Range < Object
+
+      # Deep Freeze a Range
+      #
+      # @example
+      #   range = IceNine:Freezer::Range.deep_freeze('a'..'z')
+      #   range.begin.frozen?  # => true
+      #   range.end.frozen?    # => true
+      #
+      # @param [Range] range
+      # @param [RecursionGuard] recursion_guard
+      #
+      # @return [Range]
+      def self.guarded_deep_freeze(range, recursion_guard)
+        super
+        Freezer.guarded_deep_freeze(range.begin, recursion_guard)
+        Freezer.guarded_deep_freeze(range.end, recursion_guard)
+        range
+      end
+
+    end # Range
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/rubinius.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing Rubinius objects
+    class Rubinius < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/struct.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Struct objects
+    class Struct < Array; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/symbol.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing Symbol objects
+    class Symbol < NoFreeze; end
+
+  end # Freezer
+end # IceNine

data/vendor/bundle/ruby/3.3.0/gems/ice_nine-0.11.2/lib/ice_nine/freezer/true_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing true objects
+    class TrueClass < NoFreeze; end
+
+  end # Freezer
+end # IceNine