yap-shell 0.6.0 → 0.7.0

data/lib/yap/gem_tasks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "rake/clean"
+CLOBBER.include "pkg"
+
+require "yap/gem_helper"
+Yap::GemHelper.install_tasks

data/lib/yap/shell.rb

@@ -105,7 +105,7 @@ module Yap
             if $stdout.isatty
               binding.pry
             else
-              $stdout.puts ex.message
+              $stdout.puts ex.class.name
               raise ex
             end
           end

data/lib/yap/shell/repl.rb

@@ -195,7 +195,7 @@ module Yap::Shell
     end
 
     def install_default_tab_completion_proc
-      editor.completion_proc = lambda do |word|
+      editor.completion_proc = lambda do |word, line, word_index|
         Dir["#{word}*"].map{ |str| str.gsub(/ /, '\ ')}
       end
     end

data/lib/yap/shell/version.rb

@@ -1,5 +1,5 @@
 module Yap
   module Shell
-    VERSION = "0.6.0"
+    VERSION = "0.7.0"
   end
 end

data/lib/yap/world.rb

@@ -5,9 +5,9 @@ require 'rawline'
 require 'termios'
 
 module Yap
+  require 'yap/addon'
   require 'yap/shell/execution'
   require 'yap/shell/prompt'
-  require 'yap/world/addons'
 
   class World
     include Term::ANSIColor
@@ -64,13 +64,51 @@ module Yap
 
       @repl = Yap::Shell::Repl.new(world:self)
 
-      @addons = addons.reduce(Hash.new) do |hsh, addon|
-        hsh[addon.addon_name] = addon
-        hsh
+      @addons_initialized = []
+      @addons = AddonHash.new(
+        self
+      )
+
+      addons.each do |addon|
+        if addon.yap_enabled?
+          @addons[addon.export_as] = addon
+        end
+      end
+
+      @addons.values.select(&:yap_enabled?).each do |addon|
+        initialize_addon(addon) unless addon_initialized?(addon)
+        addon
       end
+    end
+
+    def addon_initialized?(addon)
+      (@addons_initialized ||= []).include?(addon)
+    end
 
-      # initialize after they are all loaded in case they reference each other.
-      addons.each { |addon| addon.initialize_world(self) }
+    def initialize_addon(addon)
+      return unless addon
+      begin
+        addon.initialize_world(self)
+        (@addons_initialized ||= []) << addon
+      rescue Exception => ex
+        puts Term::ANSIColor.red(("The #{addon.addon_name} addon failed to initialize due to error:"))
+        puts ex.message
+        puts ex.backtrace[0..5]
+      end
+    end
+
+    class AddonHash < Hash
+      def initialize(world)
+        @world = world
+      end
+
+      def [](key)
+        addon = super
+        unless @world.addon_initialized?(addon)
+          @world.initialize_addon(addon)
+        end
+        addon
+      end
     end
 
     def configuration
@@ -108,7 +146,7 @@ module Yap
     end
 
     def reload!
-      exec File.expand_path($0)
+      exec configuration.yap_binpath
     end
 
     def func(name, &blk)

data/rcfiles/yaprc

@@ -1,5 +1,81 @@
 #!/usr/bin/ruby
 
+old_world_envs = []
+parse_env_vars_from_string = -> (str) {
+  keys_and_values = str.split("\n").map(&:chomp).map do |line|
+    next if line =~ /^\s*#/
+    line.split('=', 2)
+  end.compact
+
+  keys_and_values.map! do |(key, value)|
+    if value =~ /^['"]/
+      [key, value.scan(/^['"](.*)['"]\s*$/).flatten.first]
+    else
+      [key, value]
+    end
+  end
+}
+
+load_dotenv_file = -> (file) {
+  dotenv_file = Dir[file].first
+  if dotenv_file
+    old_world_envs.push world.env.dup
+    Treefell['shell'].puts "loading dotenv file #{dotenv_file}"
+    keys_and_values = parse_env_vars_from_string.call(IO.read(dotenv_file))
+
+    keys_and_values.each do |(key, value)|
+      next unless key
+      next if key == 'RAILS_ENV'
+      world.env[key] = value
+    end
+    Treefell['shell'].puts "done loading dotenv"
+  end
+}
+
+
+Yap::Shell::Execution::Context.on(:after_execute) do |world, command:, **kwargs|
+  if command.str == "nvm"
+    old_nvm_bin = world.env["NVM_BIN"]
+    Dir[ world.configuration.path_for("env/nvm.env") ].each do |file|
+      if old_nvm_bin
+        world.env["PATH"].sub!(/#{Regexp.escape(old_nvm_bin)}:/, '')
+      end
+
+      key_and_values = parse_env_vars_from_string.call(IO.read(file))
+      key_and_values.each do |(key, value)|
+        world.env[key] = value
+      end
+
+      nvm_bin = world.env["NVM_BIN"]
+      if nvm_bin
+        world.env["PATH"] = nvm_bin + ":" + world.env["PATH"]
+      end
+    end
+  end
+end
+
+Yap::Shell::Execution::Context.on(:before_execute) do |world, command:|
+  if command.str == "cd"
+    if old_world_envs.any?
+      world.env.replace(old_world_envs.first)
+      old_world_envs.clear
+    end
+  end
+end
+
+Yap::Shell::Execution::Context.on(:after_execute) do |world, command:, result:|
+  if command.str == "cd"
+    load_dotenv_file.call('.env')
+    load_dotenv_file.call('.env.local')
+    rails_env = world.env['RAILS_ENV']
+    if rails_env
+      load_dotenv_file.call(".env.#{rails_env}")
+    else
+      load_dotenv_file.call(".env.development")
+    end
+  end
+end
+
 ###############################################################################
 #                         ENVIRONMENT VARIABLES
 #------------------------------------------------------------------------------
@@ -87,6 +163,7 @@ world.prompt = -> do
   # Example: ~/source/playground/yap master ➜
   "#{yellow(pwd)} #{git_branch}#{red('➜')} "
 end
+# world.prompt = world.addons[:zztop].prompt
 
 ###############################################################################
 #                            SECONDARY PROMPT
@@ -120,7 +197,7 @@ self.secondary_prompt = '> '
 #
 # == Example
 #
-#    world.addons[:keyboard_macros].configure(trigger_key: :ctrl_g) do |macros|
+#    world.addons[:'keyboard-macros'].configure(trigger_key: :ctrl_g) do |macros|
 #      macros.define :z, 'git open-pull'
 #      macros.define 'l', "git log -n1\n"
 #    end
@@ -133,20 +210,20 @@ self.secondary_prompt = '> '
 ###############################################################################
 
 # Sets the default trigger key for all keyboard macros
-world.addons[:keyboard_macros].trigger_key = ?\C-g
+world.addons[:'keyboard-macros'].trigger_key = ?\C-g
 
 # Sets the default cancel key (space) for all keyboard macros
-world.addons[:keyboard_macros].cancel_key = " "
+world.addons[:'keyboard-macros'].cancel_key = " "
 
 # Sets the default timeout for macros. When set to nil you will have to
 # use the cancel key to exit out of macros.
-world.addons[:keyboard_macros].timeout_in_ms = nil
+world.addons[:'keyboard-macros'].timeout_in_ms = nil
 
 # Forgiveness-mode: Automatically cancel if the sequence is unknown. When
 # set to false you can keep attempting to type in your macro.
-world.addons[:keyboard_macros].cancel_on_unknown_sequences = true
+world.addons[:'keyboard-macros'].cancel_on_unknown_sequences = true
 
-keyboard_macros = world.addons[:keyboard_macros]
+keyboard_macros = world.addons[:'keyboard-macros']
 keyboard_macros.cycle(:recent_git_branches) { `git recent`.lines.map(&:chomp) }
 world.editor.bind(:alt_up_arrow) do
   keyboard_macros.cycle(:recent_git_branches).next
@@ -156,12 +233,15 @@ world.editor.bind(:alt_down_arrow) do
 end
 
 world.editor.bind(:ctrl_r) do
-  world.addons[:history_search].prompt_user_to_search
+  world.addons[:'history-search'].prompt_user_to_search
 end
 
+world.editor.bind(:up_arrow) { world.addons[:history].back }
+world.editor.bind(:down_arrow) { world.addons[:history].forward }
+
 # Or, you can set the trigger key for a particular set of macros
 # by specifying it when you call .configure(...).
-world.addons[:keyboard_macros].configure(trigger_key: ?\C-g) do |macro|
+world.addons[:'keyboard-macros'].configure(trigger_key: ?\C-g) do |macro|
   macro.start do
     # TODO: FUTURE
     # world.editor.content_box.children = [
@@ -205,7 +285,7 @@ end
 
 # The below macro shows that you can have macros start with a different
 # trigger keys.
-# world.addons[:keyboard_macros].configure(trigger_key: :ctrl_h) do |macros|
+# world.addons[:'keyboard-macros'].configure(trigger_key: :ctrl_h) do |macros|
 #   macros.define 'h123', -> {
 #     box = TerminalLayout::Box.new(content: "Right?", style: { display: :block, float: :right, height: 1, width: 50 })
 #     world.editor.content_box.children = [box]
@@ -267,7 +347,7 @@ func :'run-modified-specs' do |stdin:, stdout:|
     specs.concat Dir["spec/**/*#{filename_without_extension}_spec.rb"]
   end
 
-  cmd = "bundle exec rspec #{specs.join(' ')}"
+  cmd = "bundle exec rspec #{specs.sort.uniq.join(' ')}"
   stdout.puts cmd
   shell cmd
 end

data/spec/features/addons/generating_an_addon_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'Generating an addon', type: :feature, repl: false do
+  let(:addons_path) { tmp_dir.join('addons/') }
+  let(:yaprc_path) { tmp_dir.join('yaprc') }
+  let(:yaprc_contents) { '' }
+
+  let(:yap_cli_args) do
+    [
+      'generate', 'addon', 'foo-bar'
+    ]
+  end
+
+  before do
+    set_yap_command_line_arguments yap_cli_args
+
+    turn_on_debug_log(debug: 'editor')
+
+    reinitialize_shell
+  end
+
+  it 'generates an addon in the current working directory' do
+    # foo-addon is a shell function added by the foo-addon defined above;
+    expect { output }.to have_printed_lines <<-TEXT.gsub(/^\s*\|/, '')
+      |Creating addon foo-bar in yap-shell-addon-foo-bar/
+      |
+      |Create directory: yap-shell-addon-foo-bar done
+      |Create directory: lib done
+      |Creating file: Gemfile done
+      |Creating file: yap-shell-addon-foo-bar.gemspec done
+      |Creating file: LICENSE.txt done
+      |Creating file: Rakefile done
+      |Creating file: README.md done
+      |Creating file: lib/yap-shell-addon-foo-bar.rb done
+      |Create directory: lib/yap-shell-addon-foo-bar done
+      |Creating file: lib/yap-shell-addon-foo-bar/version.rb done
+      |
+      |Creating file: .gitignore done
+      |git init . && git add . && git commit -m 'initial commit of foo-bar' done
+      |
+      |Yap addon generated! A few helpful things to note:
+      |
+      |  * The foo-bar addon has been generated in yap-shell-addon-foo-bar/
+      |  * It is a standard rubygem, has its own gemspec, and is named yap-shell-addon-foo-bar
+      |  * Yap loads the YapShellAddonFooBar, found in lib/yap-shell-addon-foo-bar.rb (start there)
+      |  * Share your addon with others by building a gem and pushing it to rubygems
+
+      |For more information see https://github.com/zdennis/yap-shell/wiki/Addons
+      |
+      |Now, to get started:
+      |
+      |   cd yap-shell-addon-foo-bar
+      TEXT
+  end
+end

data/spec/features/addons/using_an_addon_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe 'Using an addon', type: :feature do
+  let(:addons_path) { tmp_dir.join('addons/') }
+  let(:yaprc_path) { tmp_dir.join('yaprc') }
+  let(:yaprc_contents) { '' }
+
+  let(:foo_addon_path) { addons_path.join('yap-shell-addon-foo-0.1.0') }
+  let(:foo_lib_addon_path) { foo_addon_path.join('lib') }
+  let(:foo_addon_rb_path) { foo_lib_addon_path.join('yap-shell-addon-foo.rb') }
+  let(:create_foo_addon) do
+    mkdir_p foo_lib_addon_path.to_s
+    write_file foo_addon_rb_path.to_s, <<-RUBY.strip_heredoc
+      |module YapShellAddonFoo
+      |  class Addon < ::Yap::Addon::Base
+      |    self.export_as :foo
+      |
+      |    def initialize_world(world)
+      |      world.func('foo-addon') do |args:, stdout:|
+      |        stdout.puts \"You passed \#\{args.inspect\} to foo-addon\"
+      |      end
+      |    end
+      |  end
+      |end
+    RUBY
+  end
+
+  let(:bar_addon_path) { addons_path.join('yap-shell-addon-bar-0.1.0') }
+  let(:bar_lib_addon_path) { bar_addon_path.join('lib') }
+  let(:bar_addon_rb_path) { bar_lib_addon_path.join('yap-shell-addon-bar.rb') }
+  let(:create_bar_addon) do
+    mkdir_p bar_lib_addon_path.to_s
+    write_file bar_addon_rb_path.to_s, <<-RUBY.strip_heredoc
+      |module YapShellAddonBar
+      |  class Addon < ::Yap::Addon::Base
+      |    self.export_as :bar
+      |
+      |    def initialize_world(world)
+      |      world.func('bar-addon') do |args:, stdout:|
+      |        stdout.puts \"You passed \#\{args.inspect\} to bar-addon\"
+      |      end
+      |    end
+      |  end
+      |end
+    RUBY
+  end
+
+  let(:create_yaprc_file) do
+    write_file yaprc_path.to_s, <<-RUBY.strip_heredoc
+      |#{yaprc_contents}
+    RUBY
+  end
+
+  let(:yap_cli_args) do
+    [
+      '--addon-paths', addons_path.to_s,
+      '--rcfiles', yaprc_path.to_s,
+      '--no-history',
+      '--no-rcfiles',
+      '--skip-first-time'
+    ]
+  end
+
+  before do
+    set_yap_command_line_arguments yap_cli_args
+
+    create_foo_addon
+    create_bar_addon
+    create_yaprc_file
+
+    turn_on_debug_log(debug: 'editor')
+    reinitialize_shell
+  end
+
+  it 'loads addons it finds in addon paths' do
+    # foo-addon is a shell function added by the foo-addon defined above
+    type 'foo-addon hello world'
+    enter
+
+    expect { output }.to have_printed("You passed [\"hello\", \"world\"] to foo-addon")
+  end
+
+  it 'makes addons available thru its export_as name' do
+    type '!addons.keys.include?(:foo)'
+    enter
+    expect { output }.to have_printed('true')
+    clear_all_output
+
+    type '!addons.keys.include?(:non_existent_addon)'
+    enter
+    expect { output }.to have_printed('false')
+  end
+
+  describe 'disabling an addon', repl: false do
+    let(:yap_cli_args) do
+      [
+        '--addon-paths', addons_path.to_s,
+        'addon', 'disable', 'foo'
+      ]
+    end
+
+    it 'writes to disk that the addon has been disabled' do
+      expect { output }.to have_printed("Addon foo has been disabled")
+
+      expect(File.exists?(tmp_dir.join('.yap/addons.yml'))).to be(true)
+
+      addons_config_hsh = YAML.load_file(tmp_dir.join('.yap/addons.yml'))
+      expect(addons_config_hsh[:foo]).to include(disabled: true)
+    end
+  end
+
+  describe 'enabling an addon', repl: false do
+    let(:yap_cli_args) do
+      [
+        '--addon-paths', addons_path.to_s,
+        'addon', 'enable', 'foo'
+      ]
+    end
+
+    it 'writes to disk that the addon has been enabled' do
+      expect { output }.to have_printed("Addon foo has been enabled")
+
+      expect(File.exists?(tmp_dir.join('.yap/addons.yml'))).to be(true)
+
+      addons_config_hsh = YAML.load_file(tmp_dir.join('.yap/addons.yml'))
+      expect(addons_config_hsh[:foo]).to include(disabled: false)
+    end
+  end
+
+  describe 'listing addons', repl: false do
+    let(:yap_cli_args) do
+      [
+        '--addon-paths', addons_path.to_s,
+        'addon', 'list'
+      ]
+    end
+
+    before do
+      mkdir tmp_dir.join('.yap')
+      write_file(
+        tmp_dir.join('.yap/addons.yml'),
+        {
+          bar: { disabled: true },
+          foo: { disabled: false }
+        }.to_yaml
+      )
+      reinitialize_shell
+    end
+
+    it 'lists all addons found in the addon-paths' do
+      expect { output }.to have_printed(/bar.*foo/m)
+    end
+
+    describe 'enabled' do
+      let(:yap_cli_args) do
+        [
+          '--addon-paths', addons_path.to_s,
+          'addon', 'list', '--enabled'
+        ]
+      end
+
+      it 'lists enabled addons' do
+        expect { output }.to have_printed(/foo/m)
+        expect { output }.to have_not_printed(/bar/m)
+      end
+    end
+
+    describe 'disabled' do
+      let(:yap_cli_args) do
+        [
+          '--addon-paths', addons_path.to_s,
+          'addon', 'list', '--disabled'
+        ]
+      end
+
+      it 'lists disabled addons' do
+        expect { output }.to have_printed(/bar/m)
+        expect { output }.to have_not_printed(/foo/m)
+      end
+    end
+  end
+end