ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/commands/next_command.rb

@@ -3,9 +3,6 @@
 module RubyJard
   module Commands
     # Command used to continue program execution to the next line.
-    # Data attached in the throw:
-    # * command: constant symbol (:next)
-    # * pry: current context pry instance
     class NextCommand < Pry::ClassCommand
       group 'RubyJard'
       description 'Next into the execution of the current line'
@@ -22,7 +19,7 @@ module RubyJard
       BANNER
 
       def process
-        throw :control_flow, command: :next, pry: pry_instance
+        RubyJard::ControlFlow.dispatch(:next)
       end
     end
   end

data/lib/ruby_jard/commands/step_command.rb

@@ -3,9 +3,6 @@
 module RubyJard
   module Commands
     # Command used to Step into the execution of the current line.
-    # Data attached in the throw:
-    # * command: constant symbol (:step)
-    # * pry: current context pry instance
     class StepCommand < Pry::ClassCommand
       group 'RubyJard'
       description 'Step into the execution of the current line'
@@ -22,7 +19,7 @@ module RubyJard
       BANNER
 
       def process
-        throw :control_flow, command: :step, pry: pry_instance
+        RubyJard::ControlFlow.dispatch(:step)
       end
     end
   end

data/lib/ruby_jard/commands/step_out_command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Commands
+    # Command used to Step into the execution of the current line.
+    class StepOutCommand < Pry::ClassCommand
+      group 'RubyJard'
+      description 'Step out of current frame and move to the execution of the upper frame'
+
+      match 'step-out'
+
+      banner <<-BANNER
+        Usage: step-out
+
+        Step out of current frame and move to the execution of the upper frame
+
+        Examples:
+          step-out
+      BANNER
+
+      def process
+        RubyJard::ControlFlow.dispatch(:step_out)
+      end
+    end
+  end
+end
+
+Pry::Commands.add_command(RubyJard::Commands::StepOutCommand)

data/lib/ruby_jard/commands/up_command.rb

@@ -3,9 +3,6 @@
 module RubyJard
   module Commands
     # Command used to explore stacktrace.
-    # Data attached in the throw:
-    # * command: constant symbol (:up)
-    # * pry: current context pry instance
     class UpCommand < Pry::ClassCommand
       group 'RubyJard'
       description 'Explore the frames above the current stopped line in the backtrace'
@@ -22,7 +19,7 @@ module RubyJard
       BANNER
 
       def process
-        throw :control_flow, command: :up, pry: pry_instance
+        RubyJard::ControlFlow.dispatch(:up)
       end
     end
   end

data/lib/ruby_jard/console.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'English'
+
+module RubyJard
+  # Wrapper for utilities to control screen
+  class Console
+    class << self
+      def start_alternative_terminal(output)
+        return unless output.tty?
+
+        output.print tput('smcup')
+      end
+
+      def stop_alternative_terminal(output)
+        return unless output.tty?
+
+        output.print tput('rmcup')
+      end
+
+      def move_to(output, x, y)
+        return unless output.tty?
+
+        output.goto(y, x)
+      end
+
+      def screen_size(output)
+        return [0, 0] unless output.tty?
+
+        height, width = output.winsize
+        [width, height]
+      end
+
+      def hard_clear_screen(output)
+        return unless output.tty?
+
+        output.print tput('clear')
+      end
+
+      def clear_screen(output)
+        return unless output.tty?
+
+        output.clear_screen
+      end
+
+      def hide_cursor(output)
+        return unless output.tty?
+
+        output.print tput('civis')
+      end
+
+      def show_cursor(output)
+        return unless output.tty?
+
+        output.print tput('cvvis')
+      end
+
+      def cooked!(output)
+        return unless output.tty?
+
+        output.cooked!
+      end
+
+      def echo!(output)
+        return unless output.tty?
+
+        output.echo = true
+      end
+
+      def tput(*args)
+        # TODO: Should implement multiple fallbacks here to support different platforms
+
+        command = "tput #{args.join(' ')}"
+        output = `#{command}`
+        if $CHILD_STATUS.success?
+          output
+        else
+          raise Ruby::Error, "Fail to call `#{command}`: #{$CHILD_STATUS}"
+        end
+      rescue StandardError => e
+        raise Ruby::Error, "Fail to call `#{command}`. Error: #{e}"
+      end
+    end
+  end
+end

data/lib/ruby_jard/control_flow.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # A helper to standardize control instruction passed around via
+  # throw and catch mechanism.
+  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
+    }.freeze
+
+    attr_reader :command, :arguments
+
+    def initialize(command, arguments)
+      @command = command
+      @arguments = arguments
+
+      validate!
+    end
+
+    def validate!
+      if command.to_s.empty?
+        raise RubyJard::Error, 'Control command is empty'
+      end
+
+      unless ALLOW_LIST.key?(command)
+        raise RubyJard::Error,
+              "Control command `#{command}` is not registered in the allow list."
+      end
+
+      invalid_keys = arguments.keys - ALLOW_LIST[command]
+      unless invalid_keys.empty?
+        raise RubyJard::Error,
+              "Control command `#{command}` is attached with unregister arguments: #{invalid_keys}"
+      end
+    end
+
+    class << self
+      def dispatch(command, arguments = {})
+        if command.is_a?(RubyJard::ControlFlow)
+          throw THROW_KEYWORD, command
+        else
+          throw THROW_KEYWORD, new(command, arguments)
+        end
+      end
+
+      def listen
+        raise RubyJard::Error, 'This method requires a block' unless block_given?
+
+        flow = catch(THROW_KEYWORD) do
+          yield
+          nil
+        end
+
+        if flow.nil? || flow.is_a?(RubyJard::ControlFlow)
+          flow
+        else
+          raise RubyJard::Error, 'Control flow misused!'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/color_decorator.rb

@@ -0,0 +1,78 @@
+# 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.
+    class ColorDecorator
+      COLORS = [
+        :black,
+        :red,
+        :green,
+        :yellow,
+        :blue,
+        :magenta,
+        :cyan,
+        :white
+      ].freeze
+
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      def decorate(text, *styles)
+        styles = standardize_styles(styles)
+        @pastel.decorate(text, *styles)
+      end
+
+      private
+
+      def standardize_styles(styles)
+        return [] if styles.include?(:clear)
+
+        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
+
+        styles.uniq.compact
+      end
+
+      def darker(styles)
+        styles.map do |color|
+          next if [:darker, :brighter].include?(color)
+
+          color_str = color.to_s
+          if color_str.start_with?('bright_')
+            color_str.gsub(/^bright_/i, '').to_sym
+          else
+            color
+          end
+        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
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/loc_decorator.rb

@@ -1,32 +1,45 @@
 # frozen_string_literal: true
 
+require 'coderay'
+
 module RubyJard
   module Decorators
     ##
     # Decorate a line of code fetched from the source file.
     # The line is tokenized, and feed into JardEncoder to append color (with
-    # Pastel).
+    # Span).
     class LocDecorator
-      attr_reader :loc, :tokens
+      attr_reader :spans, :tokens
 
-      def initialize(color_decorator, loc, highlighted)
+      def initialize(file, loc)
+        @file = file
         @loc = loc
-        @highlighted = highlighted
-        @encoder = JardLocEncoder.new(
-          color_decorator: color_decorator,
-          highlighted: highlighted
-        )
+        @encoder = JardLocEncoder.new
 
         decorate
       end
 
       def decorate
-        @tokens = CodeRay.scan(@loc, :ruby)
-        @loc = @encoder.encode_tokens(tokens)
+        @tokens = CodeRay.scan(@loc, extension)
+        @spans = @encoder.encode_tokens(tokens)
+      end
+
+      private
+
+      def extension
+        # TODO: A map constant is better
+        if @file =~ /.*\.erb$/
+          :erb
+        elsif @file =~ /.*\.haml$/
+          :haml
+        else
+          :ruby
+        end
       end
 
       # 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],
@@ -49,7 +62,7 @@ module RubyJard
             char: [:white],
             delimiter: [:white]
           },
-          constant: [:underline, :green],
+          constant: [:green],
           decorator: [:blue],
           definition: [:blue],
           directive: [:blue],
@@ -129,7 +142,8 @@ module RubyJard
           head: {
             self: [:on_red],
             filename: [:white, :on_red]
-          }
+          },
+          instance_variable: [:blue]
         }.freeze
 
         protected
@@ -138,8 +152,7 @@ module RubyJard
           super
           @opened = []
           @color_scopes = [TOKEN_COLORS]
-          @color_decorator = options[:color_decorator]
-          @highlighted = options[:highlighted]
+          @out = []
         end
 
         public
@@ -147,12 +160,20 @@ module RubyJard
         def text_token(text, kind)
           color = @color_scopes.last[kind]
           text.gsub!("\n", '')
-          if color
-            color = color[:self] if color.is_a? Hash
-            @out << @color_decorator.decorate(text, *compose_color(color))
-          else
-            @out << @color_decorator.decorate(text, *compose_color([]))
-          end
+          styles =
+            if !color
+              DEFAULT_COLOR
+            elsif color.is_a? Hash
+              color[:self]
+            else
+              color
+            end
+          @out << Span.new(
+            span_template: nil,
+            content: text,
+            content_length: text.length,
+            styles: styles
+          )
         end
 
         def begin_group(kind)
@@ -186,14 +207,6 @@ module RubyJard
               @color_scopes.last
             end
         end
-
-        def compose_color(color)
-          if @highlighted
-            [:clear] + color
-          else
-            [:dim] + color
-          end
-        end
       end
     end
   end