es_cli 0.1.0

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/lib/power_assert/enable_tracepoint_events.rb

@@ -0,0 +1,62 @@
+require 'power_assert/configuration'
+
+if defined?(RubyVM)
+  if PowerAssert.configuration._redefinition
+    module PowerAssert
+      # set redefined flag
+      basic_classes = [
+        Integer, Float, String, Array, Hash, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
+      ]
+
+      verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        [:Fixnum, :Bignum].each do |c|
+          if Object.const_defined?(c) and (c = Object.const_get(c)) != Integer
+            basic_classes << c
+          end
+        end
+      ensure
+        $VERBOSE = verbose
+      end
+
+      basic_operators = [
+        :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=, :length, :size,
+        :empty?, :nil?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min,
+        # :call (it is just used for block call optimization)
+        :&, :|,
+        # :default (no specialized instruction for this)
+        :pack, :include?,
+      ]
+
+      basic_classes.each do |klass|
+        basic_operators.each do |bop|
+          if klass.public_method_defined?(bop)
+            refine(klass) do
+              define_method(bop) {}
+            end
+          end
+        end
+      end
+
+      # bypass check_cfunc
+      refine BasicObject do
+        def !
+        end
+
+        def ==
+        end
+      end
+
+      refine Module do
+        def ==
+        end
+      end
+    end
+  end
+
+  # disable optimization
+  RubyVM::InstructionSequence.compile_option = {
+    specialized_instruction: false
+  }
+end

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/lib/power_assert/inspector.rb

@@ -0,0 +1,66 @@
+require 'power_assert/configuration'
+begin
+  require 'io/console/size'
+rescue LoadError
+end
+
+module PowerAssert
+  class InspectedValue
+    def initialize(value)
+      @value = value
+    end
+
+    def inspect
+      @value
+    end
+  end
+  private_constant :InspectedValue
+
+  class SafeInspectable
+    def initialize(value)
+      @value = value
+    end
+
+    def inspect
+      inspected = @value.inspect
+      if Encoding.compatible?(Encoding.default_external, inspected)
+        inspected
+      else
+        begin
+          "#{inspected.encode(Encoding.default_external)}(#{inspected.encoding})"
+        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+          inspected.force_encoding(Encoding.default_external)
+        end
+      end
+    rescue => e
+      "InspectionFailure: #{e.class}: #{e.message.each_line.first}"
+    end
+  end
+  private_constant :SafeInspectable
+
+  class Inspector
+    def initialize(value, indent)
+      @value = value
+      @indent = indent
+    end
+
+    def inspect
+      if PowerAssert.configuration.colorize_message
+        if PowerAssert.configuration.inspector == :pp
+          console_width = IO.respond_to?(:console_size) ? IO.console_size[1] : 80
+          width = [console_width - 1 - @indent, 10].max
+          IRB::ColorPrinter.pp(@value, +'', width)
+        else
+          IRB::Color.colorize_code(@value.to_s, ignore_error: true)
+        end
+      else
+        if PowerAssert.configuration.inspector == :pp
+          PP.pp(@value, +'')
+        else
+          @value.inspect
+        end
+      end
+    end
+  end
+  private_constant :Inspector
+end

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/lib/power_assert/parser.rb

@@ -0,0 +1,251 @@
+require 'ripper'
+
+module PowerAssert
+  class Parser
+    Ident = Struct.new(:type, :name, :column)
+
+    attr_reader :line, :path, :lineno, :binding
+
+    def initialize(line, path, lineno, binding, assertion_method_name = nil, assertion_proc = nil)
+      @line = line
+      @line_for_parsing = (valid_syntax?(line) ? line : slice_expression(line)).b
+      @path = path
+      @lineno = lineno
+      @binding = binding
+      @proc_local_variables = binding.eval('local_variables').map(&:to_s)
+      @assertion_method_name = assertion_method_name
+      @assertion_proc = assertion_proc
+    end
+
+    def idents
+      @idents ||= extract_idents(Ripper.sexp(@line_for_parsing))
+    end
+
+    def call_paths
+      collect_paths(idents).uniq
+    end
+
+    def method_id_set
+      methods = idents.flatten.find_all {|i| i.type == :method }
+      @method_id_set ||= methods.map(&:name).map(&:to_sym).each_with_object({}) {|i, h| h[i] = true }
+    end
+
+    private
+
+    def valid_syntax?(str)
+      return true unless defined?(RubyVM)
+      begin
+        verbose, $VERBOSE = $VERBOSE, nil
+        RubyVM::InstructionSequence.compile(str)
+        true
+      rescue SyntaxError
+        false
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+
+    def slice_expression(str)
+      str = str.chomp
+      str.sub!(/\A\s*(?:if|unless|elsif|case|while|until) /) {|i| ' ' * i.length }
+      str.sub!(/\A\s*(?:\}|\]|end)?\./) {|i| ' ' * i.length }
+      str.sub!(/[\{\.\\]\z/, '')
+      str.sub!(/(?:&&|\|\|)\z/, '')
+      str.sub!(/ (?:do|and|or)\z/, '')
+      str
+    end
+
+    class Branch < Array
+    end
+
+    AND_OR_OPS = %i(and or && ||)
+
+    #
+    # Returns idents as graph structure.
+    #
+    #                                                  +--c--b--+
+    #  extract_idents(Ripper.sexp('a&.b(c).d')) #=> a--+        +--d
+    #                                                  +--------+
+    #
+    def extract_idents(sexp)
+      tag, * = sexp
+      case tag
+      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal, :return
+        extract_idents(sexp[1])
+      when :assign, :massign
+        extract_idents(sexp[2])
+      when :opassign
+        _, _, (_, op_name, (_, op_column)), s0 = sexp
+        extract_idents(s0) + [Ident[:method, op_name.sub(/=\z/, ''), op_column]]
+      when :dyna_symbol
+        if sexp[1][0].kind_of?(Symbol)
+          # sexp[1] can be [:string_content, [..]] while parsing { "a": 1 }
+          extract_idents(sexp[1])
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
+        end
+      when :assoclist_from_args, :bare_assoc_hash, :paren, :string_embexpr,
+        :regexp_literal, :xstring_literal
+        sexp[1].flat_map {|s| extract_idents(s) }
+      when :command
+        [sexp[2], sexp[1]].flat_map {|s| extract_idents(s) }
+      when :assoc_new, :dot2, :dot3, :string_content
+        sexp[1..-1].flat_map {|s| extract_idents(s) }
+      when :unary
+        handle_columnless_ident([], sexp[1], extract_idents(sexp[2]))
+      when :binary
+        op = sexp[2]
+        if AND_OR_OPS.include?(op)
+          extract_idents(sexp[1]) + [Branch[extract_idents(sexp[3]), []]]
+        else
+          handle_columnless_ident(extract_idents(sexp[1]), op, extract_idents(sexp[3]))
+        end
+      when :call
+        _, recv, (op_sym, op_name, _), method = sexp
+        with_safe_op = ((op_sym == :@op and op_name == '&.') or op_sym == :"&.")
+        if method == :call
+          handle_columnless_ident(extract_idents(recv), :call, [], with_safe_op)
+        else
+          extract_idents(recv) + (with_safe_op ? [Branch[extract_idents(method), []]] : extract_idents(method))
+        end
+      when :array
+        sexp[1] ? sexp[1].flat_map {|s| extract_idents(s) } : []
+      when :command_call
+        [sexp[1], sexp[4], sexp[3]].flat_map {|s| extract_idents(s) }
+      when :aref
+        handle_columnless_ident(extract_idents(sexp[1]), :[], extract_idents(sexp[2]))
+      when :method_add_arg
+        idents = extract_idents(sexp[1])
+        if idents.empty?
+          # idents may be empty(e.g. ->{}.())
+          extract_idents(sexp[2])
+        else
+          if idents[-1].kind_of?(Branch) and idents[-1][1].empty?
+            # Safe navigation operator is used. See :call clause also.
+            idents[0..-2] + [Branch[extract_idents(sexp[2]) + idents[-1][0], []]]
+          else
+            idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
+          end
+        end
+      when :args_add_block
+        _, (tag, ss0, *ss1), _ = sexp
+        if tag == :args_add_star
+          (ss0 + ss1).flat_map {|s| extract_idents(s) }
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
+        end
+      when :vcall
+        _, (tag, name, (_, column)) = sexp
+        if tag == :@ident
+          [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
+        else
+          []
+        end
+      when :program
+        _, ((tag0, (tag1, (tag2, (tag3, mname, _)), _), (tag4, _, ss))) = sexp
+        if tag0 == :method_add_block and tag1 == :method_add_arg and tag2 == :fcall and
+            (tag3 == :@ident or tag3 == :@const) and mname == @assertion_method_name and (tag4 == :brace_block or tag4 == :do_block)
+          ss.flat_map {|s| extract_idents(s) }
+        else
+          _, (s0, *) = sexp
+          extract_idents(s0)
+        end
+      when :ifop
+        _, s0, s1, s2 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), extract_idents(s2)]]
+      when :if, :unless
+        _, s0, ss0, (_, ss1) = sexp
+        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, ss1 ? ss1.flat_map {|s| extract_idents(s) } : []]]
+      when :if_mod, :unless_mod
+        _, s0, s1 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), []]]
+      when :var_ref, :var_field
+        _, (tag, ref_name, (_, column)) = sexp
+        case tag
+        when :@kw
+          if ref_name == 'self'
+            [Ident[:ref, 'self', column]]
+          else
+            []
+          end
+        when :@ident, :@const, :@cvar, :@ivar, :@gvar
+          [Ident[:ref, ref_name, column]]
+        else
+          []
+        end
+      when :@ident, :@const, :@op
+        _, method_name, (_, column) = sexp
+        [Ident[:method, method_name, column]]
+      else
+        []
+      end
+    end
+
+    def str_indices(str, re, offset, limit)
+      idx = str.index(re, offset)
+      if idx and idx <= limit
+        [idx, *str_indices(str, re, idx + 1, limit)]
+      else
+        []
+      end
+    end
+
+    MID2SRCTXT = {
+      :[] => '[',
+      :+@ => '+',
+      :-@ => '-',
+      :call => '('
+    }
+
+    def handle_columnless_ident(left_idents, mid, right_idents, with_safe_op = false)
+      left_max = left_idents.flatten.max_by(&:column)
+      right_min = right_idents.flatten.min_by(&:column)
+      bg = left_max ? left_max.column + left_max.name.length : 0
+      ed = right_min ? right_min.column - 1 : @line_for_parsing.length - 1
+      mname = mid.to_s
+      srctxt = MID2SRCTXT[mid] || mname
+      re = /
+        #{'\b' if /\A\w/ =~ srctxt}
+        #{Regexp.escape(srctxt)}
+        #{'\b' if /\w\z/ =~ srctxt}
+      /x
+      indices = str_indices(@line_for_parsing, re, bg, ed)
+      if indices.length == 1 or !(right_idents.empty? and left_idents.empty?)
+        ident = Ident[:method, mname, right_idents.empty? ? indices.first : indices.last]
+        left_idents + right_idents + (with_safe_op ? [Branch[[ident], []]] : [ident])
+      else
+        left_idents + right_idents
+      end
+    end
+
+    def collect_paths(idents, prefixes = [[]], index = 0)
+      if index < idents.length
+        node = idents[index]
+        if node.kind_of?(Branch)
+          prefixes = node.flat_map {|n| collect_paths(n, prefixes, 0) }
+        else
+          prefixes = prefixes.map {|prefix| prefix + [node] }
+        end
+        collect_paths(idents, prefixes, index + 1)
+      else
+        prefixes
+      end
+    end
+
+    class DummyParser < Parser
+      def initialize
+        super('', nil, nil, TOPLEVEL_BINDING)
+      end
+
+      def idents
+        []
+      end
+
+      def call_paths
+        []
+      end
+    end
+    DUMMY = DummyParser.new
+  end
+  private_constant :Parser
+end

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/lib/power_assert/version.rb

@@ -0,0 +1,3 @@
+module PowerAssert
+  VERSION = "2.0.5"
+end

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/lib/power_assert.rb

@@ -0,0 +1,93 @@
+# power_assert.rb
+#
+# Copyright (C) 2014 Kazuki Tsujimoto
+
+begin
+  unless defined?(Byebug)
+    captured = false
+    target_thread = Thread.current
+    TracePoint.new(:return, :c_return) do |tp|
+      next unless Thread.current == target_thread
+      captured = true
+      unless tp.return_value and tp.callee_id
+        raise ''
+      end
+    end.enable { __id__ }
+    raise '' unless captured
+  end
+rescue
+  raise LoadError, 'Fully compatible TracePoint API required'
+end
+
+require 'power_assert/context'
+require 'power_assert/configuration'
+require 'power_assert/version'
+
+module PowerAssert
+  POWER_ASSERT_LIB_DIR = File.dirname(caller_locations(1, 1).first.path)
+  INTERNAL_LIB_DIRS = {PowerAssert => POWER_ASSERT_LIB_DIR}
+  private_constant :POWER_ASSERT_LIB_DIR, :INTERNAL_LIB_DIRS
+
+  class << self
+    def start(assertion_proc_or_source, assertion_method: nil, source_binding: TOPLEVEL_BINDING)
+      if respond_to?(:clear_global_method_cache, true)
+        clear_global_method_cache
+      end
+      yield BlockContext.new(assertion_proc_or_source, assertion_method, source_binding)
+    end
+
+    def trace(frame)
+      begin
+        raise 'Byebug is not started yet' unless Byebug.started?
+      rescue NameError
+        raise "PowerAssert.#{__method__} requires Byebug"
+      end
+      ctx = TraceContext.new(frame._binding)
+      ctx.enable
+      ctx
+    end
+
+    def app_caller_locations
+      caller_locations.drop_while {|i| internal_file?(i.path) }.take_while {|i| ! internal_file?(i.path) }
+    end
+
+    def app_context?
+      top_frame = caller_locations.drop_while {|i| i.path.start_with?(POWER_ASSERT_LIB_DIR) }.first
+      top_frame and ! internal_file?(top_frame.path)
+    end
+
+    private
+
+    def internal_file?(file)
+      setup_internal_lib_dir(Byebug, :attach, 2) if defined?(Byebug)
+      setup_internal_lib_dir(PryByebug, :start_with_pry_byebug, 2, Pry) if defined?(PryByebug)
+      INTERNAL_LIB_DIRS.find do |_, dir|
+        file.start_with?(dir)
+      end
+    end
+
+    def setup_internal_lib_dir(lib, mid, depth, lib_obj = lib)
+      unless INTERNAL_LIB_DIRS.key?(lib)
+        INTERNAL_LIB_DIRS[lib] = lib_dir(lib_obj, mid, depth)
+      end
+    rescue NameError
+    end
+
+    def lib_dir(obj, mid, depth)
+      File.expand_path('../' * depth, obj.method(mid).source_location[0])
+    end
+
+    if defined?(RubyVM)
+      CLEAR_CACHE_ISEQ = RubyVM::InstructionSequence.compile('using PowerAssert.const_get(:Empty)')
+      private_constant :CLEAR_CACHE_ISEQ
+
+      def clear_global_method_cache
+        CLEAR_CACHE_ISEQ.eval
+      end
+    end
+  end
+
+  module Empty
+  end
+  private_constant :Empty
+end

data/vendor/bundle/ruby/3.1.0/gems/power_assert-2.0.5/power_assert.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'power_assert/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'power_assert'
+  s.version     = PowerAssert::VERSION
+  s.authors     = ['Kazuki Tsujimoto']
+  s.email       = ['kazuki@callcc.net']
+  s.homepage    = 'https://github.com/ruby/power_assert'
+  s.summary     = "Power Assert for Ruby"
+  s.description = "Power Assert shows each value of variables and method calls in the expression. It is useful for testing, providing which value wasn't correct when the condition is not satisfied."
+
+  s.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{\A(?:test|spec|features|benchmark|bin)/})
+  end
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.extra_rdoc_files = ['README.md']
+  s.rdoc_options     = ['--main', 'README.md']
+  s.licenses         = ['BSD-2-Clause', "Ruby"]
+end