fir-repl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ce006c0c7b8576257f7ffa4304a09050a7a4e9b
+  data.tar.gz: c374f93b993ec41048fb8d2b7c8f5ae63b52bfbd
+SHA512:
+  metadata.gz: 1da41645a9ebefa7b56e853f4d9c70757c55d9993834da384e824b2486e6882aedbbd371a2cba4dd29cbe2e5285b3a47c9537abd5eb526b39d3b7fe896fe21dd
+  data.tar.gz: b3374e86acb504681571d88f4926049ad9498447b925645da888dcd77465bf99f891eaae0638e32d2de2d822443d8f7dacc4b08ee030599a5d4bb609fcfd3946

data/LICENSE

@@ -0,0 +1,25 @@
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2017 Nassredean Nasseri (dnasseri)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+[![CircleCI](https://circleci.com/gh/dnasseri/fir.svg?style=svg&circle-token=547487bfcc46230ec60829366533cbbad14524ee)](https://circleci.com/gh/dnasseri/fir)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Description
+
+Fir is a ruby repl that is an alternative to IRB. Fir aims to bring some of the friendly features that the [fish](https://github.com/fish-shell/fish-shell) project brought to shells to a ruby repl. Though I originally intended Fir to be a full blown replacement for pry, it is unlikely that you can use it in that capacity, since pry offers so many damn good features that this project does not replicate.
+
+Fir does bring some features to the table that pry and other REPL's do not have. The key difference between pry, IRB, Ripl, etc, and Fir is that fir puts stdin into raw mode which allows us to provide features like autosuggestion a la fish, and automatically indenting/dedenting code as you type. Below is a gif of fir in action:
+
+![Fir in Action](fir-example.gif?raw=true "Fir in action")
+
+As the video demonstrates, fir is able to indent your code as soon as it is typed, not just when you hit enter. It also can suggest lines from your history file as you type as well!
+
+## Install
+
+## Usage
+```
+$ fir
+(fir)> ...
+```
+
+### Key Commands
+Fir aims to bring familiar bash keyboard shortcuts that we all know and love, however many editing commands remain unimplemented. Below is a list of keycommands, what they do, and whether they are implemented.
+
+| Command | Alt | Description | Status |
+| --- | --- | --- | --- |
+| Ctrl + a | N/A | Move cursor to the beginning of the line | Implemented |
+| Ctrl + e | N/A | Move cursor to the end of the line | Implemented |
+| Ctrl + c | N/A | Clear current state, and step out of the block. | Implemented |
+| Ctrl + d | N/A | Exit program. | Implemented |
+| Ctrl + v | N/A | Paste from system clipboard. | Implemented |
+| Ctrl + z | N/A | Put the running fir process in the background. | Implemented |
+| Ctrl + p | Up Arrow | Previous command in history (i.e. walk back through the command history). | Implemented |
+| Ctrl + n | Down Arrow | Next command in history (i.e. walk forward through the command history). | Implemented |
+| Ctrl + b | Left Arrow | Backward one character. | Implemented |
+| Ctrl + f | Right Arrow | Forward one character. | Implemented |
+| Ctrl + u | N/A | Cut the line before the cursor position               | Not implemented |
+| Ctrl + d | N/A | Delete character under the cursor                     | Not implemented |
+| Ctrl + h | N/A | Delete character before the cursor (backspace)        | Not implemented |
+| Ctrl + w | N/A | Cut the Word before the cursor to the clipboard       | Not implemented |
+| Ctrl + k | N/A | Cut the Line after the cursor to the clipboard        | Not implemented |
+| Ctrl + t | N/A | Swap the last two characters before the cursor (typo) | Not implemented |
+| Ctrl + y | N/A | Paste the last thing to be cut (yank)                 | Not implemented |
+| Сtrl + _ | N/A | Undo                                                  | Not implemented |
+
+
+
+
+
+
+
+
+## Future Ideas
+Below is a list of ideas/features that I would like to eventually add.
+
+* Break points a la `binding.pry`
+* Configurability via `.firrc` file
+* Command line options
+	* -r: load module (same as ruby -r)
+	* -e, --exec: A line of code to execute in context before the session starts
+	* --no-history: Disable history loading
+	* --no-prompt: Disable prompt
+* Suggesting methods, local variables, instance variables, and global variables that are in scope as you type
+* Colorization

data/bin/fir

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require 'fir'
+Fir.start($stdin, $stdout, $stderr)

data/lib/fir.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require 'io/console'
+require 'optparse'
+require_relative 'fir/key'
+require_relative 'fir/key_command/key_command'
+require_relative 'fir/repl_state'
+require_relative 'fir/screen'
+require_relative 'fir/version'
+
+class Fir
+  attr_reader :key
+  attr_reader :screen
+
+  def self.start(input, output, error)
+    parse_opts(output)
+    new(
+      Key.new(input),
+      Screen.new(output, error)
+    ).perform(ReplState.blank)
+  end
+
+  def self.parse_opts(output)
+    OptionParser.new do |cl_opts|
+      cl_opts.banner = 'Usage: fir [options]'
+      cl_opts.on('-v', '--version', 'Show version') do |v|
+        config[:version] = v
+      end
+    end.parse!
+    process_immediate_opts(config, output)
+  end
+
+  def self.config
+    @config ||= {
+      history: '~/.irb_history'
+    }
+  end
+
+  def self.process_immediate_opts(opts, output)
+    return unless opts[:version]
+    output.syswrite(Fir::VERSION)
+    exit(0)
+  end
+
+  def initialize(key, screen)
+    @key = key
+    @screen = screen
+  end
+
+  def perform(state)
+    state = yield(state) if block_given?
+    perform(state) do
+      state.transition(KeyCommand.for(key.get, state)) do |new_state|
+        screen.update(state, new_state)
+      end
+    end
+  end
+end

data/lib/fir/cursor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+class Fir
+  class Cursor
+    attr_reader :x
+    attr_reader :y
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    def self.blank
+      new(0, 0)
+    end
+
+    def clone
+      self.class.new(x, y)
+    end
+
+    def up
+      self.class.new(x, y - 1)
+    end
+
+    def down
+      self.class.new(x, y + 1)
+    end
+
+    def left(n)
+      self.class.new(x - n, y)
+    end
+
+    def right(n)
+      self.class.new(x + n, y)
+    end
+
+    def ==(other)
+      other.x == x && other.y == y
+    end
+
+    def blank?
+      x.zero? && y.zero?
+    end
+  end
+end

data/lib/fir/eraser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require_relative 'screen_helper'
+
+class Fir
+  class Eraser
+    include ScreenHelper
+
+    attr_reader :output
+
+    def initialize(output)
+      @output = output
+    end
+
+    def perform(state)
+      state.lines.length.times do |i|
+        output.syswrite("#{horizontal_absolute(1)}#{clear(0)}")
+        output.syswrite("#{previous_line(1)}#{clear(0)}") unless i.zero?
+      end
+    end
+  end
+end

data/lib/fir/evaluater.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require_relative 'screen_helper'
+
+class Fir
+  class Evaluater
+    include ScreenHelper
+
+    attr_reader :output
+    attr_reader :error
+
+    def initialize(output, error)
+      @output = output
+      @error = error
+    end
+
+    def perform(state)
+      return unless state.executable?
+      begin
+        write_result(eval(state.lines.join("\n"), state.repl_binding, 'fir'))
+      rescue Exception => e
+        write_error(e)
+      ensure
+        output.syswrite(line_prompt)
+      end
+    end
+
+    private
+
+    def write_result(result)
+      output.syswrite(result.inspect)
+      output.syswrite(next_line(1))
+    end
+
+    def write_error(result)
+      error.syswrite(exception_output(result))
+      output.syswrite(next_line(1))
+    end
+
+    def exception_output(exception)
+      "#{exception.class}: #{exception.message}\n    #{backtrace(exception)}"
+    end
+
+    def backtrace(exception)
+      exception
+        .backtrace
+        .take_while { |line| line !~ %r{/fir/\S+\.rb} }
+        .join("\n    ")
+    end
+  end
+end

data/lib/fir/history.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require_relative '../fir'
+
+class Fir
+  class History
+    attr_reader :active_selection
+
+    def initialize
+      @active_selection = 0
+    end
+
+    def reset
+      @active_selection = 0
+    end
+
+    def up
+      @active_selection += 1
+    end
+
+    def down
+      @active_selection -= 1 if active_selection.positive?
+    end
+
+    def suggestion(line)
+      Fir::Suggestion.new(
+        line,
+        Fir::History.history
+      ).generate(active_selection)
+    end
+
+    class << self
+      def history_file
+        @history_file ||= Fir.config[:history] &&
+                          File.expand_path(Fir.config[:history])
+      end
+
+      def history
+        if history_file && File.exist?(history_file)
+          IO.readlines(history_file).map(&:chomp)
+        else
+          []
+        end
+      end
+
+      def add_line_to_history_file(line)
+        return unless history_file
+        File.open(history_file, 'a') { |f| f.puts(line) }
+      end
+    end
+  end
+end

data/lib/fir/indent.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require 'ripper'
+
+class Fir
+  class Indent
+    attr_reader :lines
+    attr_reader :stack
+    attr_reader :delimiter_stack
+    attr_reader :array_stack
+    attr_reader :paren_stack
+    attr_reader :heredoc_stack
+
+    def initialize(lines)
+      @lines = lines
+      @stack = []
+      @delimiter_stack = []
+      @array_stack = []
+      @paren_stack = []
+      @heredoc_stack = []
+    end
+
+    OPEN_TOKENS = %w[if while for until unless def class module begin].freeze
+    OPTIONAL_DO_TOKENS = %w[for while until].freeze
+    WHEN_MIDWAY_TOKEN = %w[else when].freeze
+    IF_MIDWAY_TOKEN = %w[else elsif].freeze
+    BEGIN_MIDWAY_TOKEN = %w[rescue ensure else].freeze
+    BEGIN_IMPLICIT_TOKEN = %w[rescue ensure].freeze
+    OPEN_HEREDOC_TOKEN = %w[<<- <<~].freeze
+
+    def generate
+      indents = lines.each.with_index.with_object([]) do |(line, line_index), deltas|
+        delta = stack.length
+        delta += array_stack.length if in_array?
+        delta += paren_stack.length if in_paren?
+        delta += heredoc_stack.length if in_heredoc?
+        line.split(' ').each_with_index do |word, word_index|
+          token = construct_token(word, word_index, line_index)
+          if any_open?(token)
+            stack.push(token)
+          elsif any_midway?(token)
+            delta -= 1
+          elsif any_close?(token)
+            delta -= 1
+            stack.pop
+          elsif string_open_token?(token)
+            delimiter_stack.push(token)
+          elsif string_close_token?(token)
+            delimiter_stack.pop
+          elsif open_array_token?(token)
+            array_stack.push(token)
+          elsif close_array_token?(token)
+            delta -= 1 if array_stack.last.position.y != token.position.y
+            array_stack.pop
+          elsif open_paren_token?(token)
+            paren_stack.push(token)
+          elsif close_paren_token?(token)
+            delta -= 1 if paren_stack.last.position.y != token.position.y
+            paren_stack.pop
+          elsif open_heredoc_token?(token)
+            heredoc_stack.push(token)
+          elsif close_heredoc_token?(token)
+            delta -= 1 if heredoc_stack.last.position.y != token.position.y
+            heredoc_stack.pop
+          end
+        end
+        deltas << delta
+      end
+      IndentBlock.new(indents, executable?(indents, lines))
+    end
+
+    private
+
+    def construct_token(word, word_index, line_index)
+      position = Position.new(word_index, line_index)
+      Token.new(word, position)
+    end
+
+    def executable?(indents, lines)
+      indents[-1].zero? &&
+        lines[-1] == '' &&
+        !in_block? &&
+        !in_string? &&
+        !in_heredoc? &&
+        !in_paren? &&
+        !in_array? &&
+        !lines.all? { |line| line == '' }
+    end
+
+    def any_open?(token)
+      !in_string? &&
+        !in_heredoc? &&
+        open_token?(token) ||
+        when_open_token?(token) ||
+        unmatched_do_token?(token)
+    end
+
+    def any_midway?(token)
+      !in_string? &&
+        !in_heredoc? &&
+        if_midway_token?(token) ||
+        begin_midway_token?(token) ||
+        when_midway_token?(token)
+    end
+
+    def any_close?(token)
+      !in_string? &&
+        !in_heredoc? &&
+        closing_token?(token) ||
+        when_close_token?(token)
+    end
+
+    def string_open_token?(token)
+      (token.word[0] == '\'' || token.word[0] == '"') &&
+        !((token.word.length > 1) && token.word[-1] == token.word[0]) &&
+        !in_string?
+    end
+
+    def string_close_token?(token)
+      in_string? &&
+        ((token.word[-1] == delimiter_stack.last.word[0]) && (token.word[-2] != "\\"))
+    end
+
+    def open_heredoc_token?(token)
+      !in_string? &&
+        !in_heredoc? &&
+        token.word.length > 3 &&
+        OPEN_HEREDOC_TOKEN.include?(token.word[0..2]) &&
+        (token.word[3..-1] == token.word[3..-1].upcase)
+    end
+
+    def close_heredoc_token?(token)
+      !in_string? &&
+        in_heredoc? &&
+        heredoc_stack.last.word[3..-1] == token.word
+    end
+
+    def open_array_token?(token)
+      !in_string? &&
+        token.word[0] == '['
+    end
+
+    def close_array_token?(token)
+      !in_string? &&
+        in_array? &&
+        token.word[-1] == ']'
+    end
+
+    def open_paren_token?(token)
+      !in_string? &&
+        token.word[0] == '{'
+    end
+
+    def close_paren_token?(token)
+      !in_string? &&
+        in_paren? &&
+        token.word[-1] == '}'
+    end
+
+    def in_array?
+      array_stack.length.positive?
+    end
+
+    def in_string?
+      delimiter_stack.length.positive?
+    end
+
+    def in_paren?
+      paren_stack.length.positive?
+    end
+
+    def in_block?
+      stack.length.positive?
+    end
+
+    def in_heredoc?
+      heredoc_stack.length.positive?
+    end
+
+    def open_token?(token)
+      OPEN_TOKENS.include?(token.word) && token.position.x.zero?
+    end
+
+    def closing_token?(token)
+      token.word == 'end' && in_block? && token.position.x.zero?
+    end
+
+    def unmatched_do_token?(token)
+      return false unless token.word == 'do'
+      !(OPTIONAL_DO_TOKENS.include?(stack.last&.word) &&
+        (token.position.y == stack.last&.position&.y))
+    end
+
+    def when_open_token?(token)
+      return false unless token.word == 'when' && token.position.x.zero?
+      stack.last&.word != 'when'
+    end
+
+    def when_midway_token?(token)
+      return false unless WHEN_MIDWAY_TOKEN.include?(token.word) && token.position.x.zero?
+      return false unless stack.last&.word == 'when'
+      true
+    end
+
+    def when_close_token?(token)
+      return false unless token.word == 'end' && token.position.x.zero?
+      return false unless stack.last&.word == 'when'
+      true
+    end
+
+    def if_midway_token?(token)
+      return false unless IF_MIDWAY_TOKEN.include?(token.word) && token.position.x.zero?
+      return false unless stack.last&.word == 'if'
+      true
+    end
+
+    def begin_midway_token?(token)
+      return false unless token.position.x.zero? && stack.last
+      (BEGIN_MIDWAY_TOKEN.include?(token.word) && stack.last.word == 'begin') ||
+        BEGIN_IMPLICIT_TOKEN.include?(token.word)
+    end
+
+    Token = Struct.new(:word, :position)
+    Position = Struct.new(:x, :y)
+    IndentBlock = Struct.new(:indents, :executable?)
+  end
+end