phronomy 0.1.0

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/special_global_vars.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of Perl-style global variables.
+      # Correcting to global variables in the 'English' library
+      # will add a require statement to the top of the file if
+      # enabled by RequireEnglish config.
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
+      #   true, replacing perl-style variables with english variables will break.
+      #
+      # @example EnforcedStyle: use_english_names (default)
+      #   # good
+      #   require 'English' # or this could be in another file.
+      #
+      #   puts $LOAD_PATH
+      #   puts $LOADED_FEATURES
+      #   puts $PROGRAM_NAME
+      #   puts $ERROR_INFO
+      #   puts $ERROR_POSITION
+      #   puts $FIELD_SEPARATOR # or $FS
+      #   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
+      #   puts $INPUT_RECORD_SEPARATOR # or $RS
+      #   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
+      #   puts $INPUT_LINE_NUMBER # or $NR
+      #   puts $LAST_READ_LINE
+      #   puts $DEFAULT_OUTPUT
+      #   puts $DEFAULT_INPUT
+      #   puts $PROCESS_ID # or $PID
+      #   puts $CHILD_STATUS
+      #   puts $LAST_MATCH_INFO
+      #   puts $IGNORECASE
+      #   puts $ARGV # or ARGV
+      #
+      # @example EnforcedStyle: use_perl_names
+      #   # good
+      #   puts $:
+      #   puts $"
+      #   puts $0
+      #   puts $!
+      #   puts $@
+      #   puts $;
+      #   puts $,
+      #   puts $/
+      #   puts $\
+      #   puts $.
+      #   puts $_
+      #   puts $>
+      #   puts $<
+      #   puts $$
+      #   puts $?
+      #   puts $~
+      #   puts $=
+      #   puts $*
+      #
+      # @example EnforcedStyle: use_builtin_english_names
+      #
+      #   # good
+      #   # Like `use_perl_names` but allows builtin global vars.
+      #   puts $LOAD_PATH
+      #   puts $LOADED_FEATURES
+      #   puts $PROGRAM_NAME
+      #   puts ARGV
+      #   puts $:
+      #   puts $"
+      #   puts $0
+      #   puts $!
+      #   puts $@
+      #   puts $;
+      #   puts $,
+      #   puts $/
+      #   puts $\
+      #   puts $.
+      #   puts $_
+      #   puts $>
+      #   puts $<
+      #   puts $$
+      #   puts $?
+      #   puts $~
+      #   puts $=
+      #   puts $*
+      #
+      class SpecialGlobalVars < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        include RequireLibrary
+        extend AutoCorrector
+
+        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+                   'module (don\'t forget to require it) or `%<regular>s` over ' \
+                   '`%<global>s`.'
+        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+                      'module (don\'t forget to require it) over `%<global>s`.'
+        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
+
+        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
+          :$: => [:$LOAD_PATH],
+          :$" => [:$LOADED_FEATURES],
+          :$0 => [:$PROGRAM_NAME],
+          :$! => [:$ERROR_INFO],
+          :$@ => [:$ERROR_POSITION],
+          :$; => %i[$FIELD_SEPARATOR $FS],
+          :$, => %i[$OUTPUT_FIELD_SEPARATOR $OFS],
+          :$/ => %i[$INPUT_RECORD_SEPARATOR $RS],
+          :$\ => %i[$OUTPUT_RECORD_SEPARATOR $ORS],
+          :$. => %i[$INPUT_LINE_NUMBER $NR],
+          :$_ => [:$LAST_READ_LINE],
+          :$> => [:$DEFAULT_OUTPUT],
+          :$< => [:$DEFAULT_INPUT],
+          :$$ => %i[$PROCESS_ID $PID],
+          :$? => [:$CHILD_STATUS],
+          :$~ => [:$LAST_MATCH_INFO],
+          :$= => [:$IGNORECASE],
+          :$* => %i[$ARGV ARGV]
+        }
+
+        # Anything *not* in this set is provided by the English library.
+        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
+
+        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
+
+        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        BUILTIN_VARS = PERL_VARS.merge(
+          NON_ENGLISH_VARS
+            .select { |v| v.to_s.start_with?('$') }
+            .flat_map { |v| [[v, [v]], PERL_VARS[v].flat_map { |a| [a, [v]] }] }
+            .to_h
+        )
+
+        ENGLISH_VARS.each_value(&:freeze).freeze
+        PERL_VARS.each_value(&:freeze).freeze
+        BUILTIN_VARS.each_value(&:freeze).freeze
+
+        STYLE_VARS_MAP = {
+          use_english_names: ENGLISH_VARS,
+          use_perl_names: PERL_VARS,
+          use_builtin_english_names: BUILTIN_VARS
+        }.freeze
+
+        LIBRARY_NAME = 'English'
+
+        def on_new_investigation
+          super
+          @required_english = false
+        end
+
+        def on_gvar(node)
+          global_var = node.name
+
+          return unless (preferred = preferred_names(global_var))
+
+          if preferred.include?(global_var)
+            correct_style_detected
+          else
+            style_detected(matching_styles(global_var))
+
+            add_offense(node, message: message(global_var)) do |corrector|
+              autocorrect(corrector, node, global_var)
+            end
+          end
+        end
+
+        def message(global_var)
+          if style == :use_english_names
+            format_english_message(global_var)
+          else
+            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
+          end
+        end
+
+        def autocorrect(corrector, node, global_var)
+          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
+
+          if should_require_english?(global_var)
+            ensure_required(corrector, node, LIBRARY_NAME)
+
+            @required_english = true
+          end
+
+          corrector.replace(node, replacement(node, global_var))
+        end
+
+        private
+
+        def format_english_message(global_var)
+          regular, english = ENGLISH_VARS[global_var].partition do |var|
+            NON_ENGLISH_VARS.include? var
+          end
+
+          format_message(english, regular, global_var)
+        end
+
+        def format_message(english, regular, global)
+          if regular.empty?
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
+          elsif english.empty?
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
+          else
+            format(MSG_BOTH,
+                   prefer: format_list(english),
+                   regular: format_list(regular),
+                   global: global)
+          end
+        end
+
+        # For now, we assume that lists are 2 items or less. Easy grammar!
+        def format_list(items)
+          items.join('` or `')
+        end
+
+        def replacement(node, global_var)
+          parent_type = node.parent&.type
+          preferred_name = preferred_names(global_var).first
+
+          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
+
+          return english_name_replacement(preferred_name, node) if style == :use_english_names
+
+          "##{preferred_name}"
+        end
+
+        def preferred_names(global)
+          vars = STYLE_VARS_MAP.fetch(style) do
+            raise ArgumentError, "Invalid style: #{style.inspect}"
+          end
+
+          vars[global]
+        end
+
+        def matching_styles(global)
+          STYLE_VARS_MAP.filter_map do |style, vars|
+            style if vars.values.flatten(1).include? global
+          end
+        end
+
+        def english_name_replacement(preferred_name, node)
+          return "\#{#{preferred_name}}" if node.begin_type?
+
+          "{#{preferred_name}}"
+        end
+
+        def add_require_english?
+          cop_config['RequireEnglish']
+        end
+
+        def should_require_english?(global_var)
+          style == :use_english_names &&
+            add_require_english? &&
+            !@required_english &&
+            !NON_ENGLISH_VARS.include?(preferred_names(global_var).first)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/stabby_lambda_parentheses.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for parentheses around stabby lambda arguments.
+      # There are two different styles. Defaults to `require_parentheses`.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # bad
+      #   ->a,b,c { a + b + c }
+      #
+      #   # good
+      #   ->(a,b,c) { a + b + c}
+      #
+      # @example EnforcedStyle: require_no_parentheses
+      #   # bad
+      #   ->(a,b,c) { a + b + c }
+      #
+      #   # good
+      #   ->a,b,c { a + b + c}
+      class StabbyLambdaParentheses < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
+        def on_send(node)
+          return unless stabby_lambda_with_args?(node)
+          return unless redundant_parentheses?(node) || missing_parentheses?(node)
+
+          arguments = node.block_node.arguments
+
+          add_offense(arguments) do |corrector|
+            case style
+            when :require_parentheses
+              missing_parentheses_corrector(corrector, arguments)
+            when :require_no_parentheses
+              unwanted_parentheses_corrector(corrector, arguments)
+            end
+          end
+        end
+
+        private
+
+        def missing_parentheses?(node)
+          style == :require_parentheses && !parentheses?(node)
+        end
+
+        def redundant_parentheses?(node)
+          style == :require_no_parentheses && parentheses?(node)
+        end
+
+        def message(_node)
+          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
+        end
+
+        def missing_parentheses_corrector(corrector, node)
+          corrector.wrap(node, '(', ')')
+        end
+
+        def unwanted_parentheses_corrector(corrector, node)
+          args_loc = node.loc
+
+          corrector.replace(args_loc.begin, '')
+          corrector.remove(args_loc.end)
+        end
+
+        def stabby_lambda_with_args?(node)
+          node.lambda_literal? && node.block_node.arguments?
+        end
+
+        def parentheses?(node)
+          node.block_node.arguments.loc.begin
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/static_class.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where classes with only class methods can be
+      # replaced with a module. Classes should be used only when it makes sense to create
+      # instances out of them.
+      #
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def self.some_method
+      #       # body omitted
+      #     end
+      #
+      #     def self.some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     module_function
+      #
+      #     def some_method
+      #       # body omitted
+      #     end
+      #
+      #     def some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good - has instance method
+      #   class SomeClass
+      #     def instance_method; end
+      #     def self.class_method; end
+      #   end
+      #
+      class StaticClass < Base
+        include RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
+
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
+        def class_convertible_to_module?(class_node)
+          nodes = class_elements(class_node)
+          return false if nodes.empty?
+
+          nodes.all? do |node|
+            (node_visibility(node) == :public && node.defs_type?) ||
+              sclass_convertible_to_module?(node) ||
+              node.equals_asgn? ||
+              extend_call?(node)
+          end
+        end
+
+        def extend_call?(node)
+          node.send_type? && node.method?(:extend)
+        end
+
+        def sclass_convertible_to_module?(node)
+          return false unless node.sclass_type?
+
+          class_elements(node).all? do |child|
+            node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def
+            []
+          elsif class_def.begin_type?
+            class_def.children
+          else
+            [class_def]
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/stderr_puts.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `$stderr.puts` can be replaced by
+      # `warn`. The latter has the advantage of easily being disabled by,
+      # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
+      #
+      # @example
+      #   # bad
+      #   $stderr.puts('hello')
+      #
+      #   # good
+      #   warn('hello')
+      #
+      class StderrPuts < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        RESTRICT_ON_SEND = %i[puts].freeze
+
+        # @!method stderr_puts?(node)
+        def_node_matcher :stderr_puts?, <<~PATTERN
+          (send
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
+            :puts $_
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless stderr_puts?(node)
+
+          message = message(node)
+          add_offense(stderr_puts_range(node), message: message) do |corrector|
+            corrector.replace(stderr_puts_range(node), 'warn')
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, bad: "#{node.receiver.source}.#{node.method_name}")
+        end
+
+        def stderr_gvar?(sym)
+          sym == :$stderr
+        end
+
+        def stderr_puts_range(send)
+          range_between(send.source_range.begin_pos, send.loc.selector.end_pos)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/string_chars.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `String#split` with empty string or regexp literal argument.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behavior, it would be registered as a false positive.
+      #
+      # @example
+      #   # bad
+      #   string.split(//)
+      #   string.split('')
+      #
+      #   # good
+      #   string.chars
+      #
+      class StringChars < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `chars` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        BAD_ARGUMENTS = %w[// '' ""].freeze
+
+        def on_send(node)
+          return unless node.arguments.one? && BAD_ARGUMENTS.include?(node.first_argument.source)
+
+          range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+
+          add_offense(range, message: format(MSG, current: range.source)) do |corrector|
+            corrector.replace(range, 'chars')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end