ruby_jard 0.1.0

data/lib/ruby_jard/commands/step_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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'
+
+      match 'step'
+
+      banner <<-BANNER
+        Usage: step
+
+        Step into the execution of the current line
+
+        Examples:
+          step
+      BANNER
+
+      def process
+        throw :control_flow, command: :step, pry: pry_instance
+      end
+    end
+  end
+end
+
+Pry::Commands.add_command(RubyJard::Commands::StepCommand)

data/lib/ruby_jard/commands/up_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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'
+
+      match 'up'
+
+      banner <<-BANNER
+      Usage: up
+
+      Explore the frames above the current stopped line in the backtrace.
+
+      Examples:
+        up
+      BANNER
+
+      def process
+        throw :control_flow, command: :up, pry: pry_instance
+      end
+    end
+  end
+end
+
+Pry::Commands.add_command(RubyJard::Commands::UpCommand)

data/lib/ruby_jard/decorators/loc_decorator.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+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).
+    class LocDecorator
+      attr_reader :loc, :tokens
+
+      def initialize(color_decorator, loc, highlighted)
+        @loc = loc
+        @highlighted = highlighted
+        @encoder = JardLocEncoder.new(
+          color_decorator: color_decorator,
+          highlighted: highlighted
+        )
+
+        decorate
+      end
+
+      def decorate
+        @tokens = CodeRay.scan(@loc, :ruby)
+        @loc = @encoder.encode_tokens(tokens)
+      end
+
+      # A shameless copy from https://github.com/rubychan/coderay/blob/master/lib/coderay/encoders/terminal.rb
+      class JardLocEncoder < CodeRay::Encoders::Encoder
+        TOKEN_COLORS = {
+          debug: [:white, :on_blue],
+          annotation: [:blue],
+          attribute_name: [:blue],
+          attribute_value: [:blue],
+          binary: {
+            self: [:blue],
+            char: [:blue],
+            delimiter: [:blue]
+          },
+          char: {
+            self: [:blue],
+            delimiter: [:blue]
+          },
+          class: [:underline, :green],
+          class_variable: [:green],
+          color: [:green],
+          comment: {
+            self: [:white],
+            char: [:white],
+            delimiter: [:white]
+          },
+          constant: [:underline, :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],
+          key: {
+            self: [:blue],
+            char: [:blue],
+            delimiter: [:blue]
+          },
+          label: [:blue],
+          local_variable: [:blue],
+          namespace: [:blue],
+          octal: [:blue],
+          predefined: [:blue],
+          predefined_constant: [:blue],
+          predefined_type: [:green],
+          preprocessor: [:blue],
+          pseudo_class: [:blue],
+          regexp: {
+            self: [:blue],
+            delimiter: [:blue],
+            modifier: [:blue],
+            char: [:blue]
+          },
+          reserved: [:blue],
+          keyword: [:blue],
+          shell: {
+            self: [:blue],
+            char: [:blue],
+            delimiter: [:blue],
+            escape: [:blue]
+          },
+          string: {
+            self: [:blue],
+            modifier: [:blue],
+            char: [:blue],
+            delimiter: [:blue],
+            escape: [:blue]
+          },
+          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]
+          }
+        }.freeze
+
+        protected
+
+        def setup(options)
+          super
+          @opened = []
+          @color_scopes = [TOKEN_COLORS]
+          @color_decorator = options[:color_decorator]
+          @highlighted = options[:highlighted]
+        end
+
+        public
+
+        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
+        end
+
+        def begin_group(kind)
+          @opened << kind
+          open_token(kind)
+        end
+        alias begin_line begin_group
+
+        def end_group(_kind)
+          return unless @opened.pop
+
+          @color_scopes.pop
+        end
+
+        def end_line(kind)
+          end_group(kind)
+        end
+
+        private
+
+        def open_token(kind)
+          color = @color_scopes.last[kind]
+          @color_scopes <<
+            if color
+              if color.is_a?(Hash)
+                color
+              else
+                @color_scopes.last
+              end
+            else
+              @color_scopes.last
+            end
+        end
+
+        def compose_color(color)
+          if @highlighted
+            [:clear] + color
+          else
+            [:dim] + color
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/path_decorator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Simplify and generate labels to indicate the location of a path.
+    # If it's from gem, strip Gem paths, or Bundler paths to expose relative
+    # location of the file.
+    # If it's from the current working dir, strip the working dir.
+    class PathDecorator
+      GEM_PATTERN = /(.*)\-(\d+\.\d+[\.\d]*[\.\d]*[\-\.\w]*)/i.freeze
+      PATH_TYPES = [
+        TYPE_UNKNOWN = :unknown,
+        TYPE_PWD = :pwd,
+        TYPE_GEM = :gem
+      ].freeze
+
+      attr_reader :path, :lineno, :gem, :gem_version
+
+      def initialize(path, lineno)
+        @gem = nil
+        @gem_version = nil
+        @path = path
+        @lineno = lineno
+        @type = TYPE_UNKNOWN
+
+        decorate
+      end
+
+      def decorate
+        if path.start_with?(Dir.pwd)
+          @type = TYPE_PWD
+          @path = @path[Dir.pwd.length..-1]
+        else
+          decorate_gem_path
+        end
+
+        @path = @path[1..-1] if @path.start_with?('/')
+      end
+
+      def gem?
+        @type == TYPE_GEM
+      end
+
+      private
+
+      def decorate_gem_path
+        gem_paths.each do |gem_path|
+          next unless path.start_with?(gem_path)
+
+          @type = TYPE_GEM
+          splitted_path =
+            @path[gem_path.length..-1]
+            .split('/')
+            .reject(&:empty?)
+          @path = splitted_path[1..-1].join('/')
+          @gem = splitted_path.first
+          match = GEM_PATTERN.match(@gem)
+          if match
+            @gem = match[1]
+            @gem_version = match[2]
+          end
+
+          break
+        end
+      end
+
+      def gem_paths
+        paths = []
+
+        if defined?(Gem)
+          Gem.path.each do |gem_path|
+            paths << File.join(gem_path, 'gems')
+            paths << gem_path
+          end
+        end
+
+        if defined?(Bundler)
+          bundle_path = Bundler.bundle_path.to_s
+          paths << File.join(bundle_path, 'gems')
+          paths << bundle_path
+        end
+
+        paths
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/source_decorator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Decorator to decorate a file of source code
+    # It loads a window of source code that centers the current line position.
+    class SourceDecorator
+      attr_reader :codes, :window_start, :window_end
+
+      def initialize(file, lineno, window)
+        @file = file
+        @lineno = lineno
+        @window = window
+        @codes = []
+
+        decorate
+      end
+
+      def decorate
+        begin
+          file = File.open(@file)
+        rescue Errno::ENOENT
+          return
+        end
+
+        @window_start = @lineno - @window / 2
+        @window_start = 0 if @window_start.negative?
+        @window_end = @window_start + @window
+
+        until file.eof?
+          loc = file.gets
+          next if file.lineno < @window_start
+          break if @window_end < file.lineno
+
+          @codes << loc
+        end
+
+        file.close
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/text_decorator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Decorate text colos and styles. It acts as a wrapper for Pastel gem
+    # TODO: the current color handling sucks. This should be migrated to a
+    # color scheme system instead.
+    class TextDecorator
+      attr_reader :length, :content
+
+      def initialize(color, highlighted = false)
+        @length = 0
+        @content = ''
+        @color = color
+        @highlighted = highlighted
+      end
+
+      def text(sentence, *styles)
+        return self + sentence if sentence.is_a?(TextDecorator)
+
+        sentence = sentence.to_s
+        @length += sentence.length
+
+        @content +=
+          if styles.empty?
+            sentence
+          else
+            @color.decorate(sentence, *compose_styles(styles))
+          end
+
+        self
+      end
+
+      def with_highlight(highlighted)
+        @highlighted = highlighted
+
+        self
+      end
+
+      def +(other)
+        if other.is_a?(RubyJard::Decorators::TextDecorator)
+          @length = other.length
+          @content += other.content
+        else
+          text(other.to_s)
+        end
+
+        self
+      end
+
+      private
+
+      def compose_styles(styles)
+        styles.delete(:clear)
+        styles.delete(:dim)
+        styles.prepend(@highlighted ? :clear : :dim)
+      end
+    end
+  end
+end