ruby_jard 0.2.0 → 0.2.1

data/lib/ruby_jard/commands/next_command.rb

@@ -26,3 +26,4 @@ module RubyJard
 end
 
 Pry::Commands.add_command(RubyJard::Commands::NextCommand)
+Pry::Commands.alias_command 'n', 'next'

data/lib/ruby_jard/commands/step_command.rb

@@ -26,3 +26,4 @@ module RubyJard
 end
 
 Pry::Commands.add_command(RubyJard::Commands::StepCommand)
+Pry::Commands.alias_command 's', 'step'

data/lib/ruby_jard/commands/step_out_command.rb

@@ -26,3 +26,4 @@ module RubyJard
 end
 
 Pry::Commands.add_command(RubyJard::Commands::StepOutCommand)
+Pry::Commands.alias_command 'so', 'step-out'

data/lib/ruby_jard/console.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'tty-screen'
 require 'io/console'
 require 'English'
 
@@ -11,75 +12,158 @@ module RubyJard
         return unless output.tty?
 
         output.print tput('smcup')
+      rescue RubyJard::Error
+        # If tput not found, fallback to hard-coded sequence.
+        output.print "\e[?1049h\e[22;0;0t"
       end
 
       def stop_alternative_terminal(output)
         return unless output.tty?
 
         output.print tput('rmcup')
+      rescue RubyJard::Error
+        # If tput not found, fallback to hard-coded sequence.
+        output.print "\e[?1049l\e[23;0;0t"
       end
 
       def move_to(output, x, y)
         return unless output.tty?
 
-        output.goto(y, x)
+        output.print format("\e[%<row>d;%<col>dH", row: y + 1, col: x + 1)
       end
 
       def screen_size(output)
         return [0, 0] unless output.tty?
 
-        height, width = output.winsize
-        [width, height]
+        [TTY::Screen.width, TTY::Screen.height]
       end
 
-      def hard_clear_screen(output)
+      def clear_screen(output)
         return unless output.tty?
 
-        output.print tput('clear')
+        output.print "\e[3J"
       end
 
-      def clear_screen(output)
+      def clear_screen_to_end(output)
         return unless output.tty?
 
-        output.clear_screen
+        output.print "\e[0J"
       end
 
-      def hide_cursor(output)
+      def disable_cursor!(output = STDOUT)
         return unless output.tty?
 
         output.print tput('civis')
+      rescue RubyJard::Error
+        # If tput not found, fallback to hard-coded sequence.
+        output.print "\e[?25l"
       end
 
-      def show_cursor(output)
+      def enable_cursor!(output = STDOUT)
         return unless output.tty?
 
-        output.print tput('cvvis')
+        output.print tput('cnorm')
+      rescue RubyJard::Error
+        # If tput not found, fallback to hard-coded sequence.
+        output.print "\e[?12l\e[?25h"
+      end
+
+      def getch(input, timeout)
+        return input.getch(min: 0, time: timeout) if input.respond_to?(:getch)
+
+        raw!
+        disable_echo!
+        key =
+          begin
+            input.read_nonblock(255)
+          rescue IO::WaitReadable
+            io = IO.select([input], nil, nil, timeout)
+            if io.nil?
+              nil
+            else
+              retry
+            end
+          rescue IO::WaitWritable
+            nil
+          end
+
+        key
+      ensure
+        cooked!
+        enable_echo!
       end
 
-      def cooked!(output)
+      def raw!(output = STDOUT)
         return unless output.tty?
 
-        output.cooked!
+        begin
+          output.raw!
+        rescue StandardError
+          stty('raw')
+        end
       end
 
-      def echo!(output)
+      def cooked!(output = STDOUT)
         return unless output.tty?
 
-        output.echo = true
+        begin
+          output.cooked!
+        rescue StandardError
+          # If stty not found, or raise error, nothing I can do
+          stty('-raw')
+        end
       end
 
-      def tput(*args)
-        # TODO: Should implement multiple fallbacks here to support different platforms
+      def disable_echo!(output = STDOUT)
+        return unless output.tty?
+
+        begin
+          output.echo = false
+        rescue StandardError
+          # If stty not found, or raise error, nothing I can do
+          stty('-echo')
+        end
+      end
 
+      def enable_echo!(output = STDOUT)
+        return unless output.tty?
+
+        begin
+          output.echo = true
+        rescue StandardError
+          # If stty not found, or raise error, nothing I can do
+          stty('echo')
+        end
+      end
+
+      def cached_tput
+        @cached_tput ||= {}
+      end
+
+      def tput(*args)
         command = "tput #{args.join(' ')}"
+        return cached_tput[command] unless cached_tput[command].nil?
+
+        output = `#{command}`
+        if $CHILD_STATUS.success?
+          cached_tput[command] = output
+        else
+          raise RubyJard::Error, "Fail to call `#{command}`: #{$CHILD_STATUS}"
+        end
+      rescue StandardError => e
+        raise RubyJard::Error, "Fail to call `#{command}`. Error: #{e}"
+      end
+
+      def stty(*args)
+        command = "stty #{args.join(' ')}"
         output = `#{command}`
         if $CHILD_STATUS.success?
           output
         else
-          raise Ruby::Error, "Fail to call `#{command}`: #{$CHILD_STATUS}"
+          raise RubyJard::Error, "Fail to call `#{command}`: #{$CHILD_STATUS}"
         end
       rescue StandardError => e
-        raise Ruby::Error, "Fail to call `#{command}`. Error: #{e}"
+        raise RubyJard::Error, "Fail to call `#{command}`. Error: #{e}"
       end
     end
   end

data/lib/ruby_jard/control_flow.rb

@@ -7,14 +7,15 @@ module RubyJard
   class ControlFlow
     THROW_KEYWORD = :jard_control_flow
     ALLOW_LIST = {
-      continue: [:times],    # lib/ruby_jard/commands/continue_command.rb
-      frame: [:frame],       # lib/ruby_jard/commands/frame_command.rb
-      up: [:times],          # lib/ruby_jard/commands/up_command.rb
-      down: [:times],        # lib/ruby_jard/commands/down_command.rb
-      next: [:times],        # lib/ruby_jard/commands/next_command.rb
-      step: [:times],        # lib/ruby_jard/commands/step_command.rb
-      step_out: [:times],    # lib/ruby_jard/commands/step_out_command.rb
-      key_binding: [:action] # lib/ruby_jard/commands/step_command.rb
+      continue: [:times],     # lib/ruby_jard/commands/continue_command.rb
+      frame: [:frame],        # lib/ruby_jard/commands/frame_command.rb
+      up: [:times],           # lib/ruby_jard/commands/up_command.rb
+      down: [:times],         # lib/ruby_jard/commands/down_command.rb
+      next: [:times],         # lib/ruby_jard/commands/next_command.rb
+      step: [:times],         # lib/ruby_jard/commands/step_command.rb
+      step_out: [:times],     # lib/ruby_jard/commands/step_out_command.rb
+      key_binding: [:action], # lib/ruby_jard/commands/step_command.rb
+      list: []                # lib/ruby_jard/commands/step_command.rb
     }.freeze
 
     attr_reader :command, :arguments

data/lib/ruby_jard/decorators/color_decorator.rb

@@ -1,77 +1,66 @@
 # frozen_string_literal: true
 
-require 'pastel'
-
 module RubyJard
   module Decorators
     ##
-    # Manipulate and decorate color for texts. The core is Pastel, which is a library to
-    # inject escape sequences to let the terminal emulator aware of target color. This
-    # class wraps around the core, validates, and standardizes the styles before feeding
-    # styling information to Pastel.
+    # Manipulate and decorate color for texts.
     class ColorDecorator
-      COLORS = [
-        :black,
-        :red,
-        :green,
-        :yellow,
-        :blue,
-        :magenta,
-        :cyan,
-        :white
-      ].freeze
+      HEX_PATTERN_6 = /^#([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})$/i.freeze
+      HEX_PATTERN_3 = /^#([A-Fa-f0-9]{1})([A-Fa-f0-9]{1})([A-Fa-f0-9]{1})$/i.freeze
+      XTERM_NUMBER_PATTERN = /^([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])$/i.freeze
 
-      def initialize
-        @pastel = Pastel.new
-      end
+      CSI_RESET = "\e[0m"
+      CSI_FOREGROUND_24BIT = "\e[38;2;%d;%d;%dm"
+      CSI_BACKGROUND_24BIT = "\e[48;2;%d;%d;%dm"
+      CSI_FOREGROUND_256 = "\e[38;5;%dm"
+      CSI_BACKGROUND_256 = "\e[48;5;%dm"
 
-      def decorate(text, *styles)
-        styles = standardize_styles(styles)
-        @pastel.decorate(text, *styles)
-      end
-
-      private
+      CSI_ITALIC = "\e[3m"
+      CSI_UNDERLINE = "\e[4m"
 
-      def standardize_styles(styles)
-        return [] if styles.include?(:clear)
+      STYLES_CSI_MAP = {
+        underline: CSI_UNDERLINE,
+        italic: CSI_ITALIC
+      }.freeze
 
-        if styles.include?(:darker)
-          # Convert all bright_color -> color
-          styles = darker(styles)
-        elsif styles.include?(:brighter)
-          # Convert all color -> bright_color
-          styles = brighter(styles)
-        end
+      def initialize(color_scheme)
+        @color_scheme = color_scheme
+      end
 
-        styles.uniq.compact
+      # TODO: rename and replace #decorate by this method
+      def decorate(element, content)
+        styles = @color_scheme.styles_for(element) || []
+        foreground = translate_color(styles.shift, true)
+        background = translate_color(styles.shift, false)
+        "#{foreground}#{background}#{translate_styles(styles)}#{content}#{CSI_RESET}"
       end
 
-      def darker(styles)
-        styles.map do |color|
-          next if [:darker, :brighter].include?(color)
+      private
 
-          color_str = color.to_s
-          if color_str.start_with?('bright_')
-            color_str.gsub(/^bright_/i, '').to_sym
-          else
-            color
-          end
+      def translate_color(color, foreground)
+        if matches = HEX_PATTERN_6.match(color.to_s)
+          red = matches[1].to_i(16)
+          green = matches[2].to_i(16)
+          blue = matches[3].to_i(16)
+          sequence = foreground ? CSI_FOREGROUND_24BIT : CSI_BACKGROUND_24BIT
+          format sequence, red, green, blue
+        elsif matches = HEX_PATTERN_3.match(color.to_s)
+          red = (matches[1] * 2).to_i(16)
+          green = (matches[2] * 2).to_i(16)
+          blue = (matches[3] * 2).to_i(16)
+          sequence = foreground ? CSI_FOREGROUND_24BIT : CSI_BACKGROUND_24BIT
+          format sequence, red, green, blue
+        elsif matches = XTERM_NUMBER_PATTERN.match(color.to_s)
+          color = matches[1]
+          sequence = foreground ? CSI_FOREGROUND_256 : CSI_BACKGROUND_256
+          format sequence, color
+        else
+          ''
         end
       end
 
-      def brighter(styles)
-        styles.map do |color|
-          next if [:darker, :brighter].include?(color)
-
-          color_str = color.to_s
-          if color_str.start_with?('bright_')
-            color
-          elsif COLORS.include?(color)
-            "bright_#{color}".to_sym
-          else
-            color
-          end
-        end
+      def translate_styles(styles = [])
+        styles.map { |key| STYLES_CSI_MAP[key] }.compact.join
       end
     end
   end

data/lib/ruby_jard/decorators/inspection_decorator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubyJard
+  # PP subclass for streaming inspect output in color.
+  class InspectionDecorator < ::PP::SingleLine
+    def self.inspect(obj, output = [], max_width = 79)
+      queue = new(output, max_width)
+      queue.guard_inspect_key { queue.pp obj }
+      queue.flush
+
+      queue.output.flatten
+    end
+
+    attr_reader :output
+
+    def initialize(output, max_width = nil, new_line = nil)
+      @output = output
+      @first = [true]
+      @max_width = max_width
+      @width = 0
+      @new_line = new_line
+      @loc_decorator = RubyJard::Decorators::LocDecorator.new
+    end
+
+    def pp(object)
+      return if @width > @max_width
+      return super unless object.is_a?(String)
+
+      puts @output.length
+      text(object.inspect)
+    end
+
+    def text(str, _max_width = str.length)
+      if str.start_with?('#<') || ['>'].include?(str)
+        append_output(str, :object)
+      elsif [' ', '=', '=>'].include?(str)
+        append_output(str, :trivial_inspection)
+      elsif str.start_with?("\e")
+        append_output(str.gsub(/\e/i, '\e'), :trivial_inspection)
+      else
+        spans, _tokens = @loc_decorator.decorate(str)
+        spans.each do |span|
+          break if @width > @max_width
+
+          @output << span
+          @width += span.content_length
+        end
+      end
+    end
+
+    def breakable(sep = ' ', _width = nil)
+      append_output(sep, :trivial_inspection)
+    end
+
+    def group(_indent = nil, open_obj = nil, close_obj = nil, _open_width = nil, _close_width = nil)
+      @first.push true
+      append_output(open_obj, :normal_token) unless open_obj.nil?
+      yield
+      append_output(close_obj, :normal_token) unless close_obj.nil?
+      @first.pop
+    end
+
+    def append_output(str, style)
+      return if str.empty?
+      return if @width > @max_width
+
+      @output << Span.new(
+        span_template: nil,
+        content: str,
+        content_length: str.length,
+        styles: style
+      )
+      @width += str.length
+    end
+  end
+end

data/lib/ruby_jard/decorators/loc_decorator.rb

@@ -9,28 +9,23 @@ module RubyJard
     # The line is tokenized, and feed into JardEncoder to append color (with
     # Span).
     class LocDecorator
-      attr_reader :spans, :tokens
-
-      def initialize(file, loc)
-        @file = file
-        @loc = loc
+      def initialize
         @encoder = JardLocEncoder.new
-
-        decorate
       end
 
-      def decorate
-        @tokens = CodeRay.scan(@loc, extension)
-        @spans = @encoder.encode_tokens(tokens)
+      def decorate(loc, file = nil)
+        tokens = CodeRay.scan(loc, extension(file))
+        spans = @encoder.encode_tokens(tokens)
+        [spans, tokens]
       end
 
       private
 
-      def extension
+      def extension(file)
         # TODO: A map constant is better
-        if @file =~ /.*\.erb$/
+        if file =~ /.*\.erb$/
           :erb
-        elsif @file =~ /.*\.haml$/
+        elsif file =~ /.*\.haml$/
           :haml
         else
           :ruby
@@ -39,111 +34,93 @@ module RubyJard
 
       # A shameless copy from https://github.com/rubychan/coderay/blob/master/lib/coderay/encoders/terminal.rb
       class JardLocEncoder < CodeRay::Encoders::Encoder
-        DEFAULT_COLOR = [:white].freeze
-        TOKEN_COLORS = {
-          debug: [:white, :on_blue],
-          annotation: [:blue],
-          attribute_name: [:blue],
-          attribute_value: [:blue],
+        DEFAULT_STYLE = :normal_token
+        TOKEN_STYLES = {
+          annotation: :keyword,
+          attribute_name: :keyword,
+          attribute_value: :keyword,
           binary: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue]
+            self: :keyword,
+            char: :keyword,
+            delimiter: :keyword
           },
           char: {
-            self: [:blue],
-            delimiter: [:blue]
+            self: :keyword,
+            delimiter: :keyword
           },
-          class: [:underline, :green],
-          class_variable: [:green],
-          color: [:green],
+          class: :constant,
+          class_variable: :constant,
+          color: :constant,
           comment: {
-            self: [:white],
-            char: [:white],
-            delimiter: [:white]
+            self: :comment,
+            char: :comment,
+            delimiter: :comment
           },
-          constant: [:green],
-          decorator: [:blue],
-          definition: [:blue],
-          directive: [:blue],
-          docstring: [:blue],
-          doctype: [:blue],
-          done: [:blue],
-          entity: [:blue],
-          error: [:white, :on_red],
-          exception: [:blue],
-          float: [:blue],
-          function: [:green],
-          method: [:green],
-          global_variable: [:green],
-          hex: [:blue],
-          id: [:blue],
-          include: [:blue],
-          integer: [:blue],
-          imaginary: [:blue],
-          important: [:blue],
+          constant: :constant,
+          decorator: :keyword,
+          definition: :keyword,
+          directive: :keyword,
+          docstring: :keyword,
+          doctype: :keyword,
+          done: :keyword,
+          entity: :keyword,
+          error: :constant,
+          exception: :keyword,
+          float: :literal,
+          function: :constant,
+          method: :method,
+          global_variable: :constant,
+          hex: :keyword,
+          id: :keyword,
+          include: :keyword,
+          integer: :literal,
+          imaginary: :keyword,
+          important: :keyword,
           key: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue]
+            self: :literal,
+            char: :literal,
+            delimiter: :literal
           },
-          label: [:blue],
-          local_variable: [:blue],
-          namespace: [:blue],
-          octal: [:blue],
-          predefined: [:blue],
-          predefined_constant: [:blue],
-          predefined_type: [:green],
-          preprocessor: [:blue],
-          pseudo_class: [:blue],
+          label: :literal,
+          local_variable: :keyword,
+          namespace: :keyword,
+          octal: :keyword,
+          predefined: :keyword,
+          predefined_constant: :keyword,
+          predefined_type: :constant,
+          preprocessor: :keyword,
+          pseudo_class: :keyword,
           regexp: {
-            self: [:blue],
-            delimiter: [:blue],
-            modifier: [:blue],
-            char: [:blue]
+            self: :keyword,
+            delimiter: :keyword,
+            modifier: :keyword,
+            char: :keyword
           },
-          reserved: [:blue],
-          keyword: [:blue],
+          reserved: :keyword,
+          keyword: :keyword,
           shell: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue],
-            escape: [:blue]
+            self: :keyword,
+            char: :keyword,
+            delimiter: :keyword,
+            escape: :keyword
           },
           string: {
-            self: [:blue],
-            modifier: [:blue],
-            char: [:blue],
-            delimiter: [:blue],
-            escape: [:blue]
+            self: :string,
+            modifier: :string,
+            char: :string,
+            delimiter: :string,
+            escape: :string,
+            content: :string
           },
           symbol: {
-            self: [:blue],
-            delimiter: [:blue]
-          },
-          tag: [:green],
-          type: [:blue],
-          value: [:blue],
-          variable: [:blue],
-          insert: {
-            self: [:on_green],
-            insert: [:green, :on_green],
-            eyecatcher: [:italic]
-          },
-          delete: {
-            self: [:on_red],
-            delete: [:blue, :on_red],
-            eyecatcher: [:italic]
-          },
-          change: {
-            self: [:on_blue],
-            change: [:white, :on_blue]
-          },
-          head: {
-            self: [:on_red],
-            filename: [:white, :on_red]
+            self: :literal,
+            delimiter: :literal
           },
-          instance_variable: [:blue]
+          tag: :constant,
+          type: :keyword,
+          value: :keyword,
+          variable: :keyword,
+          instance_variable: :instance_variable
         }.freeze
 
         protected
@@ -151,7 +128,7 @@ module RubyJard
         def setup(options)
           super
           @opened = []
-          @color_scopes = [TOKEN_COLORS]
+          @color_scopes = [TOKEN_STYLES]
           @out = []
         end
 
@@ -160,19 +137,18 @@ module RubyJard
         def text_token(text, kind)
           color = @color_scopes.last[kind]
           text.gsub!("\n", '')
-          styles =
+          style =
             if !color
-              DEFAULT_COLOR
+              DEFAULT_STYLE
             elsif color.is_a? Hash
               color[:self]
             else
               color
             end
           @out << Span.new(
-            span_template: nil,
             content: text,
             content_length: text.length,
-            styles: styles
+            styles: style.to_sym
           )
         end