spirit_hands 2.1.10-universal-java-12

data/lib/spirit_hands/options/color.rb

@@ -0,0 +1,10 @@
+class << SpiritHands
+  # Alias for Pry.color
+  def color
+    ::Pry.color
+  end
+
+  def color=(v)
+    ::Pry.color = v
+  end
+end # SpiritHands.self

data/lib/spirit_hands/options/coolline.rb

@@ -0,0 +1,60 @@
+module SpiritHands
+  class << self
+    # Is coolline enabled?
+    def coolline
+      @coolline = DEFAULT_COOLLINE if !instance_variable_defined?(:@coolline) || @coolline.nil?
+      @coolline
+    end
+
+    # Set whether hirb is enabled (default: true)
+    attr_writer :coolline
+
+  protected
+
+    def install_coolline!
+      return if coolline_installed?
+      Pry.plugins['coolline'].activate!
+      self.input_config = @coolline_input
+    end
+
+    def uninstall_coolline!
+      return unless coolline_installed?
+      Pry.plugins['coolline'].disable!
+      self.input_config = @orig_input
+    end
+
+    def coolline_installed?
+      Pry.input == @coolline_input[0]
+    end
+
+    def setup_coolline!
+      if coolline
+        install_coolline!
+      else
+        uninstall_coolline!
+      end
+    end
+
+    def input_config=(args)
+      Pry.input, Pry.config.completer = args
+    end
+
+    def input_config
+      [Pry.input, Pry.config.completer]
+    end
+
+    def setup_coolline
+      @orig_input = input_config
+      require 'pry-coolline'
+      @coolline_input = input_config
+      Pry.hooks.add_hook(:before_session, "setup_coolline_before") do |output, binding, pry|
+        setup_coolline!
+      end
+      Pry.hooks.add_hook(:after_eval, "setup_coolline_after") do |code, pry|
+        setup_coolline!
+      end
+    end
+  end
+
+  DEFAULT_COOLLINE = false # TODO: fix pry-coolline and/or integration
+end

data/lib/spirit_hands/options/hirb.rb

@@ -0,0 +1,34 @@
+require 'spirit_hands/hirb'
+
+module SpiritHands
+  class << self
+    # Is hirb enabled?
+    def hirb
+      ::Hirb.enabled?
+    end
+
+    # Set whether hirb is enabled (default: true)
+    def hirb=(h)
+      h = DEFAULT_HIRB if h.nil?
+      if hirb != h
+        if h
+          ::Hirb.enable
+        else
+          ::Hirb.disable
+        end
+      end
+      @hirb = !!h
+    end
+
+    private
+
+    def setup_hirb
+      self.hirb = nil unless @hirb
+    end
+  end
+
+  DEFAULT_HIRB = true
+
+  # Whether to use hirb/unicode when hirb is enabled (default: true)
+  mattr_accessor_with_default :hirb_unicode, true
+end

data/lib/spirit_hands/options/less.rb

@@ -0,0 +1,2 @@
+require 'spirit_hands/options/less/colorize'
+require 'spirit_hands/options/less/show_raw_unicode'

data/lib/spirit_hands/options/less/colorize.rb

@@ -0,0 +1,41 @@
+require 'shellwords'
+
+module SpiritHands
+  DEFAULT_LESS_COLORIZE = true
+  LESS_R_LONG = '--RAW-CONTROL-CHARS'.freeze
+  LESS_R = /\A(.*-[^-R]*)R(.*)\z/.freeze
+
+  class << self
+
+    # Allow less to display colorized output (default: true)
+    # (If, set updates LESS env var)
+    def less_colorize
+      ENV['LESS'].to_s.shellsplit.any? { |arg| arg == LESS_R_LONG || arg =~ LESS_R }
+    end
+
+    #  true: add -R to LESS env var (default)
+    # false: remove -R from LESS env var
+    #   nil: set to default (true)
+    def less_colorize=(n)
+      n = DEFAULT_LESS_COLORIZE if n.nil?
+
+      args = ENV['LESS'].to_s.shellsplit.map do |arg|
+        next if arg == LESS_R_LONG
+        if arg =~ LESS_R
+          arg = $1 + $2
+        end
+        arg unless arg.empty?
+      end
+      args << '-R' if n
+      new_less = args.collect.to_a.shelljoin
+      ENV['LESS'] = new_less.empty? ? nil : new_less
+      @less_colorize = !!n
+    end
+
+    private
+
+    def setup_less_colorize
+      self.less_colorize = nil unless @less_colorize
+    end
+  end
+end

data/lib/spirit_hands/options/less/show_raw_unicode.rb

@@ -0,0 +1,36 @@
+require 'shellwords'
+
+module SpiritHands
+  DEFAULT_LESS_SHOW_RAW_UNICODE = true
+  LESS_SHOW_RAW_BINFMT = '*n%c'.freeze
+
+  class << self
+    # Allow less to display colorized output (default: true)
+    # (If, set updates LESS env var)
+    def less_show_raw_unicode
+      ENV['LESSUTFBINFMT'] == LESS_SHOW_RAW_BINFMT
+    end
+
+    # true: set LESSUTFBINFMT to %*c
+    # false: unset LESSUTFBINFMT
+    # String: set custom LESSUTFBINFMT
+    # nil: set default(true)
+    def less_show_raw_unicode=(n)
+      n = DEFAULT_LESS_SHOW_RAW_UNICODE if n.nil?
+      ENV['LESSUTFBINFMT'] = if n.is_a?(String)
+        n
+      elsif n
+        LESS_SHOW_RAW_BINFMT
+      else
+        nil
+      end
+      @less_show_raw_unicode = !!n
+    end
+
+    private
+
+    def setup_less_show_raw_unicode
+      self.less_show_raw_unicode = nil unless @less_show_raw_unicode
+    end
+  end
+end

data/lib/spirit_hands/print.rb

@@ -0,0 +1,76 @@
+require 'awesome_print'
+
+module SpiritHands
+  module Print
+    class << self
+      PRINT_FUNCTION = ->(_output, value, _pry_) do
+        ::SpiritHands::Print.print(_output, value, _pry_)
+      end
+
+      def install!
+        ::Pry.config.print = PRINT_FUNCTION
+      end
+
+      def pretty(value)
+        if ::SpiritHands.awesome_print
+          opts = { :indent => ::SpiritHands.value_indent }
+          opts[:plain] = true if !SpiritHands.color
+          value.ai(opts)
+        else
+          value.inspect
+        end
+      end
+
+      def hirb_unicode_enabled?
+        ::Hirb::Formatter.dynamic_config.keys.any? do |key|
+          if opts = ::Hirb::Formatter.dynamic_config[key][:options]
+            opts && opts[:unicode]
+          end
+        end
+      end
+
+      def print(_output, value, _pry_)
+        if ::Hirb.enabled?
+          setup_hirb_unicode
+          return if ::Hirb::View.view_or_page_output(value)
+        end
+        _pry_.pager.open do |pager|
+          pager.print ::SpiritHands.value_prompt
+          pager.puts pretty(value)
+        end
+      end
+
+      private
+
+      def hirb_unicode_enable
+        return false unless ::SpiritHands::Terminal.unicode?
+        require 'hirb/unicode'
+
+        ::Hirb::Formatter.dynamic_config.keys.each do |key|
+          ::Hirb::Formatter.dynamic_config[key][:options] ||= {}
+          ::Hirb::Formatter.dynamic_config[key][:options][:unicode] = true
+        end
+        true
+      end
+
+      def hirb_unicode_disable
+        ::Hirb::Formatter.dynamic_config.keys.each do |key|
+          ::Hirb::Formatter.dynamic_config[key][:options] ||= {}
+          ::Hirb::Formatter.dynamic_config[key][:options][:unicode] = false
+        end
+        false
+      end
+
+      def setup_hirb_unicode
+        if hirb_unicode_enabled? != SpiritHands.hirb_unicode
+          if SpiritHands.hirb_unicode
+            hirb_unicode_enable
+          else
+            hirb_unicode_disable
+          end
+        end
+        nil
+      end
+    end # self
+  end # Print
+end # SpiritHands

data/lib/spirit_hands/prompt.rb

@@ -0,0 +1,12 @@
+require 'spirit_hands/prompt/main'
+require 'spirit_hands/prompt/multiline'
+
+module SpiritHands
+  module Prompt
+    class << self
+      def install!
+        ::Pry.config.prompt = [ main, multiline ].freeze
+      end
+    end # self
+  end # Prompt
+end # SpiritHands

data/lib/spirit_hands/prompt/base.rb

@@ -0,0 +1,25 @@
+require 'spirit_hands/prompt/base/render'
+
+module SpiritHands
+  module Prompt
+
+    class << self
+      private
+
+
+      def render(state, prompt, color = true)
+        r = Render.new(state, prompt, color)
+        res = r.to_s
+        STDERR.puts "\n" + (r.errors * "\n") + "\n" if r.errors?
+        res
+      end
+    end # self
+
+    # :object     Object
+    # :level      Fixnum
+    # :pry        Pry
+    # :app        String or Rails::Application
+    # :multiline  false: normal prompt,  true: multiline prompt
+    State = Struct.new(:object, :level, :pry, :app, :multiline)
+  end # Prompt
+end # SpiritHands

data/lib/spirit_hands/prompt/base/render.rb

@@ -0,0 +1,239 @@
+module SpiritHands
+  module Prompt
+    # <....>
+    # <..../>
+    # </....>
+    #
+    class Render
+      # <tag> ... </tag>, tag -> inner part of escape codes
+      MATCHED_TAG_CODES = {
+        'b'             => 1,
+        'bold'          => 1,
+        'bright'        => 1,
+        'strong'        => 1,
+
+        'dark'          => 2,
+        'faint'         => 2,
+
+        'i'             => 3,
+        'italic'        => 3,
+        'em'            => 3,
+
+        'u'             => 4,
+        'underline'     => 4,
+
+        'blink'         => 5,  # evil
+        'flash'         => 5,
+
+        'rapid-blink'   => 6, # sinister
+        'rapid-flash'   => 6,
+
+        'reverse'       => 7,
+        'negative'      => 7,
+        'inverse'       => 7,
+
+        'concealed'     => 8,
+
+        'strike'        => 9,
+        'strikethrough' => 9,
+
+        'black'         => 30,
+        'red'           => 31,
+        'green'         => 32,
+        'yellow'        => 33,
+        'blue'          => 34,
+        'magenta'       => 35,
+        'cyan'          => 36,
+        'white'         => 37,
+
+        'bgblack'       => 40,
+        'bgred'         => 41,
+        'bggreen'       => 42,
+        'bgyellow'      => 43,
+        'bgblue'        => 44,
+        'bgmagenta'     => 45,
+        'bgcyan'        => 46,
+        'bgwhite'       => 47,
+      }
+
+      # <.../>
+      SINGLE_TAGS = {
+        # <cmd/>: command number
+        'cmd' =>
+          lambda do |state|
+            pry = state.pry
+            (pry.respond_to?(:input_ring) ? pry.input_ring : pry.input_array)
+              .size
+          end,
+
+        # <tgt/>: target string
+        'tgt' => ->(state) {
+          unless (str = Pry.view_clip(state.object)) == 'main'
+            state.level = 0 if state.level < 0
+            "(#{'../' * state.level}#{str})"
+          else
+            ''
+          end
+        },
+
+        # <app/>: state.app (Object) converted to String
+        'app' => ->(state) {
+          app = state.app
+          if app.class.respond_to?(:module_parent_name) && \
+            app.class.module_parent_name.respond_to?(:underscore)
+            app.class.module_parent_name.underscore
+          elsif app.class.respond_to?(:parent_name) && \
+            app.class.parent_name.respond_to?(:underscore)
+            app.class.parent_name.underscore
+          elsif app
+            app.to_s
+          else
+            ::SpiritHands.app
+          end
+        },
+
+        # <sep/>: SpiritHands.prompt_separator
+        'sep' => ->(_state) {
+          ::SpiritHands.prompt_separator
+        }
+      }
+
+      # Array<String>
+      attr_reader :errors
+
+      def errors?
+        errors.any?
+      end
+
+      # :state   SpiritHands::Prompt::State
+      # :prompt  String
+      # :color   true or false/nil
+      def initialize(state, prompt, color)
+        @state = state
+        @prompt = prompt
+        @color = color
+      end
+
+      def to_s
+        @errors = []
+        @tag_stack = []
+        @result = ''
+        @color_applied = false
+        @in_tag = false
+
+        @prompt.each_char do |c|
+          if @in_tag
+            tag_char(c)
+          else
+            nontag_char(c)
+          end
+        end
+
+        # @tag_stack.any? --> error/s
+        @tag_stack.each { |t| errors << "<#{t}>: Missing </#{t}>" }
+
+        (errors?) ? '' : @result
+      end
+
+      private
+
+      def tag_char(c)
+        case c
+        when '/'
+          # close: </
+          # single <.+/
+          @tag_type = (@tag.nil? || @tag.empty?) ? :close : :single
+        when '>' # close tag
+          @tag.downcase!
+          send @tag_type # :start, :close or :single
+          @in_tag = false
+        else # append to existing tag
+          @tag += c
+        end
+      end
+
+      def nontag_char(c)
+        if instance_variable_defined?(:@escape) && @escape
+          nontag_escaped_char(c)
+        else
+          nontag_unescaped_char(c)
+        end
+      end
+
+      def nontag_escaped_char(c)
+        @escape = false
+        @result += (@state.multiline) ? ' ' : c
+      end
+
+      def nontag_unescaped_char(c)
+        case c
+        when '\\' # escape next char
+          @escape = true
+        when '<' # start tag
+          @in_tag = true
+          @tag_type = :start
+          @tag = ''
+        else # normal char
+          @result += (@state.multiline) ? ' ' : c
+        end
+      end
+
+      # <...>
+      def start
+        code = MATCHED_TAG_CODES[@tag]
+        if !code
+          errors << "Unknown <#{@tag}>"
+          return
+        end
+        @result += esc(code)
+        @tag_stack << @tag
+      end
+
+      # </...>
+      def close
+        code = MATCHED_TAG_CODES[@tag]
+        if !code
+          errors << "Unknown </#{@tag}>"
+          return
+        end
+        idx = @tag_stack.rindex @tag
+        if idx.nil?
+          errors << "</#{@tag}>: missing start <#{@tag}>"
+          return
+        end
+        # remove the now closed tag from the stack
+        @tag_stack.delete_at idx
+        # reset and reapply all codes on the @tag_stack
+        @result += reset
+        @tag_stack.each { |tag| @result += esc(MATCHED_TAG_CODES[tag]) }
+      end
+
+      # <.../>
+      def single
+        f = SINGLE_TAGS[@tag]
+        if !f
+          errors << "Unknown </#{@tag}>"
+          return
+        end
+        result = f.(@state).to_s
+
+        # blank out all but sep for multiline prompt, vs. main (normal)
+        if @state.multiline && @tag != 'sep'
+          result = ' ' * result.length
+        end
+        @result += result
+      end
+
+      def reset
+        esc(0)
+      end
+
+      # convert a code to an actual character
+      def esc(code)
+        return '' if !@color
+        @color_applied = true
+        "\001\e[#{code}m\002".freeze
+      end
+    end # Render
+  end # Prompt
+end # SpiritHands