super-smart-mod 0.0.1

data/pry-0.16.0/lib/pry/helpers/text.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+class Pry
+  module Helpers
+    # The methods defined on {Text} are available to custom commands via
+    # {Pry::Command#text}.
+    module Text
+      extend self
+
+      COLORS = {
+        "black" => 0,
+        "red" => 1,
+        "green" => 2,
+        "yellow" => 3,
+        "blue" => 4,
+        "purple" => 5,
+        "magenta" => 5,
+        "cyan" => 6,
+        "white" => 7
+      }.freeze
+
+      COLORS.each_pair do |color, value|
+        define_method color do |text|
+          "\033[0;#{30 + value}m#{text}\033[0m"
+        end
+
+        define_method "bright_#{color}" do |text|
+          "\033[1;#{30 + value}m#{text}\033[0m"
+        end
+
+        COLORS.each_pair do |bg_color, bg_value|
+          define_method "#{color}_on_#{bg_color}" do |text|
+            "\033[0;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
+          end
+
+          define_method "bright_#{color}_on_#{bg_color}" do |text|
+            "\033[1;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
+          end
+        end
+      end
+
+      # Remove any color codes from _text_.
+      #
+      # @param  [String, #to_s] text
+      # @return [String] _text_ stripped of any color codes.
+      def strip_color(text)
+        text.to_s.gsub(/(\001)?(\e\[(\d[;\d]?)*m)(\002)?/, '')
+      end
+
+      # Returns _text_ as bold text for use on a terminal.
+      #
+      # @param [String, #to_s] text
+      # @return [String] _text_
+      def bold(text)
+        "\e[1m#{text}\e[0m"
+      end
+
+      # Returns `text` in the default foreground colour.
+      # Use this instead of "black" or "white" when you mean absence of colour.
+      #
+      # @param [String, #to_s] text
+      # @return [String]
+      def default(text)
+        text.to_s
+      end
+
+      #
+      # @yield
+      #   Yields a block with color turned off.
+      #
+      # @return [void]
+      #
+      def no_color
+        boolean = Pry.config.color
+        Pry.config.color = false
+        yield
+      ensure
+        Pry.config.color = boolean
+      end
+
+      #
+      # @yield
+      #   Yields a block with paging turned off.
+      #
+      # @return [void]
+      #
+      def no_pager
+        boolean = Pry.config.pager
+        Pry.config.pager = false
+        yield
+      ensure
+        Pry.config.pager = boolean
+      end
+
+      # Returns _text_ in a numbered list, beginning at _offset_.
+      #
+      # @param  [#each_line] text
+      # @param  [Fixnum] offset
+      # @return [String]
+      def with_line_numbers(text, offset, color = :blue)
+        lines = text.each_line.to_a
+        max_width = (offset + lines.count).to_s.length
+        lines.each_with_index.map do |line, index|
+          adjusted_index = (index + offset).to_s.rjust(max_width)
+          "#{send(color, adjusted_index)}: #{line}"
+        end.join
+      end
+
+      # Returns _text_ indented by _chars_ spaces.
+      #
+      # @param [String] text
+      # @param [Fixnum] chars
+      def indent(text, chars)
+        text.lines.map { |l| "#{' ' * chars}#{l}" }.join
+      end
+    end
+  end
+end

data/pry-0.16.0/lib/pry/helpers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "pry/helpers/base_helpers"
+require "pry/helpers/options_helpers"
+require "pry/helpers/command_helpers"
+require "pry/helpers/text"
+require "pry/helpers/table"
+require "pry/helpers/platform"

data/pry-0.16.0/lib/pry/history.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+class Pry
+  # The History class is responsible for maintaining the user's input history,
+  # both internally and within Readline.
+  class History
+    def self.default_file
+      history_file =
+        if (xdg_home = Pry::Env['XDG_DATA_HOME'])
+          # See XDG Base Directory Specification at
+          # https://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
+          xdg_home + '/pry/pry_history'
+        elsif File.exist?(File.expand_path('~/.pry_history'))
+          '~/.pry_history'
+        else
+          '~/.local/share/pry/pry_history'
+        end
+      File.expand_path(history_file)
+    end
+
+    attr_accessor :loader, :saver
+
+    # @return [Fixnum] Number of lines in history when Pry first loaded.
+    attr_reader :original_lines
+
+    # @return [Integer] total number of lines, including original lines
+    attr_reader :history_line_count
+
+    def initialize(options = {})
+      @history = options[:history] || []
+      @history_line_count = @history.count
+      @file_path = options[:file_path]
+      @original_lines = 0
+      @loader = method(:read_from_file)
+      @saver = method(:save_to_file)
+    end
+
+    # Load the input history using `History.loader`.
+    # @return [Integer] The number of lines loaded
+    def load
+      @loader.call do |line|
+        next if invalid_readline_line?(line)
+
+        @history << line.chomp
+        @original_lines += 1
+        @history_line_count += 1
+      end
+    end
+
+    # Add a line to the input history, ignoring blank and duplicate lines.
+    # @param [String] line
+    # @return [String] The same line that was passed in
+    def push(line)
+      return line if line.empty? || invalid_readline_line?(line)
+
+      begin
+        last_line = @history[-1]
+      rescue IndexError
+        last_line = nil
+      end
+
+      return line if line == last_line
+
+      @history << line
+      @history_line_count += 1
+      @saver.call(line) if !should_ignore?(line) && Pry.config.history_save
+
+      line
+    end
+    alias << push
+
+    # Clear this session's history. This won't affect the contents of the
+    # history file.
+    def clear
+      @history.clear
+      @history_line_count = 0
+      @original_lines = 0
+    end
+
+    # @return [Fixnum] The number of lines in history from just this session.
+    def session_line_count
+      @history_line_count - @original_lines
+    end
+
+    # Return an Array containing all stored history.
+    # @return [Array<String>] An Array containing all lines of history loaded
+    #   or entered by the user in the current session.
+    def to_a
+      @history.to_a
+    end
+
+    # Filter the history with the histignore options
+    # @return [Array<String>] An array containing all the lines that are not
+    #   included in the histignore.
+    def filter(history)
+      history.select { |l| l unless should_ignore?(l) }
+    end
+
+    private
+
+    # Check if the line match any option in the histignore
+    # [Pry.config.history_ignorelist]
+    # @return [Boolean] a boolean that notifies if the line was found in the
+    #   histignore array.
+    def should_ignore?(line)
+      hist_ignore = Pry.config.history_ignorelist
+      return false if hist_ignore.nil? || hist_ignore.empty?
+
+      hist_ignore.any? { |p| line.to_s.match(p) }
+    end
+
+    # The default loader. Yields lines from `Pry.config.history_file`.
+    def read_from_file
+      path = history_file_path
+
+      File.foreach(path) { |line| yield(line) } if File.exist?(path)
+    rescue SystemCallError => error
+      warn "Unable to read history file: #{error.message}"
+    end
+
+    # The default saver. Appends the given line to `Pry.config.history_file`.
+    def save_to_file(line)
+      history_file.puts line if history_file
+    end
+
+    # The history file, opened for appending.
+    def history_file
+      if defined?(@history_file)
+        @history_file
+      else
+        unless File.exist?(history_file_path)
+          FileUtils.mkdir_p(File.dirname(history_file_path))
+        end
+        @history_file = File.open(history_file_path, 'a', 0o600).tap do |file|
+          file.sync = true
+        end
+      end
+    rescue SystemCallError => error
+      warn "Unable to write history file: #{error.message}"
+      @history_file = false
+    end
+
+    def history_file_path
+      File.expand_path(@file_path || Pry.config.history_file)
+    end
+
+    def invalid_readline_line?(line)
+      # `Readline::HISTORY << line` raises an `ArgumentError` if `line`
+      # includes a null byte
+      line.include?("\0")
+    end
+  end
+end

data/pry-0.16.0/lib/pry/hooks.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+class Pry
+  # Implements a hooks system for Pry. A hook is a callable that is associated
+  # with an event. A number of events are currently provided by Pry, these
+  # include: `:when_started`, `:before_session`, `:after_session`.  A hook must
+  # have a name, and is connected with an event by the `Pry::Hooks#add_hook`
+  # method.
+  #
+  # @example Adding a hook for the `:before_session` event.
+  #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
+  #     puts "hello"
+  #   end
+  class Hooks
+    def self.default
+      hooks = new
+      hooks.add_hook(:before_session, :default) do |_out, _target, pry_instance|
+        next if pry_instance.quiet?
+
+        pry_instance.run_command('whereami --quiet')
+      end
+      hooks
+    end
+
+    def initialize
+      @hooks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Ensure that duplicates have their @hooks object.
+    def initialize_copy(_orig)
+      hooks_dup = @hooks.dup
+      @hooks.each do |k, v|
+        hooks_dup[k] = v.dup
+      end
+
+      @hooks = hooks_dup
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    # Destructively merge the contents of two `Pry:Hooks` instances.
+    #
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry:Hooks] The receiver.
+    # @see #merge
+    def merge!(other)
+      @hooks.merge!(other.dup.hooks) do |_key, array, other_array|
+        temp_hash = {}
+        output = []
+
+        (array + other_array).reverse_each do |pair|
+          temp_hash[pair.first] ||= output.unshift(pair)
+        end
+
+        output
+      end
+
+      self
+    end
+
+    # @example
+    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   Pry::Hooks.new.merge(hooks)
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the
+    #   contents of two `Pry:Hooks` instances.
+    def merge(other)
+      dup.tap do |v|
+        v.merge!(other)
+      end
+    end
+
+    # Add a new hook to be executed for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    # @param [#call] callable The callable.
+    # @yield The block to use as the callable (if no `callable` provided).
+    # @return [Pry:Hooks] The receiver.
+    def add_hook(event_name, hook_name, callable = nil, &block)
+      event_name = event_name.to_s
+
+      # do not allow duplicates, but allow multiple `nil` hooks
+      # (anonymous hooks)
+      if hook_exists?(event_name, hook_name) && !hook_name.nil?
+        raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
+      end
+
+      raise ArgumentError, "Must provide a block or callable." if !block && !callable
+
+      # ensure we only have one anonymous hook
+      @hooks[event_name].delete_if { |h, _k| h.nil? } if hook_name.nil?
+
+      if block
+        @hooks[event_name] << [hook_name, block]
+      elsif callable
+        @hooks[event_name] << [hook_name, callable]
+      end
+
+      self
+    end
+
+    # Execute the list of hooks for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Array] args The arguments to pass to each hook function.
+    # @return [Object] The return value of the last executed hook.
+    def exec_hook(event_name, *args, &block)
+      @hooks[event_name.to_s].map do |_hook_name, callable|
+        begin
+          callable.call(*args, &block)
+        rescue RescuableException => e
+          errors << e
+          e
+        end
+      end.last
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @return [Fixnum] The number of hook functions for `event_name`.
+    def hook_count(event_name)
+      @hooks[event_name.to_s].size
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook
+    # @return [#call] a specific hook for a given event.
+    def get_hook(event_name, hook_name)
+      hook = @hooks[event_name.to_s].find do |current_hook_name, _callable|
+        current_hook_name == hook_name
+      end
+      hook.last if hook
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @return [Hash] The hash of hook names / hook functions.
+    # @note Modifying the returned hash does not alter the hooks, use
+    # `add_hook`/`delete_hook` for that.
+    def get_hooks(event_name)
+      Hash[@hooks[event_name.to_s]]
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    #   to delete.
+    # @return [#call] The deleted hook.
+    def delete_hook(event_name, hook_name)
+      deleted_callable = nil
+
+      @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
+        if current_hook_name == hook_name
+          deleted_callable = callable
+          true
+        else
+          false
+        end
+      end
+      deleted_callable
+    end
+
+    # Clear all hooks functions for a given event.
+    #
+    # @param [String] event_name The name of the event.
+    # @return [void]
+    def clear_event_hooks(event_name)
+      @hooks[event_name.to_s] = []
+    end
+
+    # @param [Symbol] event_name Name of the event.
+    # @param [Symbol] hook_name Name of the hook.
+    # @return [Boolean] Whether the hook by the name `hook_name`.
+    def hook_exists?(event_name, hook_name)
+      @hooks[event_name.to_s].map(&:first).include?(hook_name)
+    end
+
+    protected
+
+    attr_reader :hooks
+  end
+end