yap-shell 0.7.1 → 0.7.2

data/lib/yap/configuration.rb

@@ -1,74 +0,0 @@
-require 'pathname'
-
-module Yap
-  require 'yap/world'
-
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
-
-  class Configuration
-    attr_accessor :addon_paths
-    attr_accessor :rcfiles
-    attr_accessor :yap_addons_configuration_path
-    attr_accessor :yap_binpath
-
-    def self.option(name, type=nil, default: nil)
-      reader_method = name.to_s
-      define_method(reader_method) do
-        return default unless instance_variable_defined?("@#{name}")
-        value = instance_variable_get("@#{name}")
-        return !!value if type == :boolean
-        value
-      end
-
-      writer_method = "#{reader_method}="
-      define_method(writer_method) do |value|
-        instance_variable_set("@#{name}", value)
-      end
-
-      if type == :boolean
-        query_method = "#{reader_method}?"
-        alias_method query_method, reader_method
-      end
-    end
-
-    option :run_shell, :boolean, default: true
-    option :skip_first_time, :boolean, default: false
-    option :use_addons, :boolean, default: true
-    option :use_history, :boolean, default: true
-    option :use_rcfiles, :boolean, default: true
-
-    def initialize
-      @yap_addons_configuration_path = yap_path.join('addons.yml')
-
-      @addon_paths = [
-        # "#{File.dirname(__FILE__)}/../../addons",
-        # "#{ENV['HOME']}/.yap/addons"
-      ].concat(Gem.path.map { |gems_path| "#{gems_path}/gems" }).map do |path|
-        File.expand_path(path)
-      end
-
-      @rcfiles = [
-        "#{ENV['HOME']}/.yaprc",
-        preferred_yaprc_path
-      ]
-    end
-
-    def path_for(part)
-      yap_path.join(part)
-    end
-
-    def preferred_yaprc_path
-      yap_path.join("yaprc")
-    end
-
-    def yaprc_template_path
-      Pathname.new(File.dirname(__FILE__)).join('../../rcfiles/yaprc')
-    end
-
-    def yap_path
-      Pathname.new "#{ENV['HOME']}/.yap"
-    end
-  end
-end

data/lib/yap/gem_helper.rb

@@ -1,195 +0,0 @@
-require 'bundler'
-require 'term/ansicolor'
-require 'yap/addon'
-
-module Yap
-  class GemHelper
-    Color = Term::ANSIColor
-
-    include Rake::DSL if defined? Rake::DSL
-
-    class << self
-      # set when install'd.
-      attr_accessor :instance
-
-      def install_tasks(opts = {})
-        new(opts[:dir], opts[:name]).install
-      end
-    end
-
-    attr_reader :spec_path, :base, :gemspec
-
-    def initialize(base = nil, name = nil)
-      @base ||= Dir.pwd
-      gemspecs = name ? [File.join(@base, "#{name}.gemspec")] : Dir[File.join(@base, "{,*}.gemspec")]
-      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
-      @spec_path = gemspecs.first
-      @gemspec = Bundler.load_gemspec(@spec_path)
-      @export_as = Yap::Addon.export_as_for_gemspec(@gemspec)
-    end
-
-    def install
-      built_gem_path = nil
-
-      desc "Build #{Color.yellow(@export_as)} yap addon as gem #{name}-#{version}.gem"
-      task "build" do
-        built_gem_path = build_gem
-        puts "Don't forget to run #{Term::ANSIColor.yellow('rake install && reload!')} to see your changes reflected in yap."
-        puts Term::ANSIColor.bright_black("P.S. You can skip this step if you always run 'rake install'")
-      end
-
-      desc "Build and install #{Color.yellow(@export_as)} yap addon as gem #{name}-#{version}.gem into system gems."
-      task "install" do
-        built_gem_path = build_gem
-        install_gem(built_gem_path)
-        puts "Don't forget to run #{Term::ANSIColor.yellow('reload!')} to see your changes reflected in yap."
-      end
-
-      desc "Build and install #{Color.yellow(@export_as)} yap addon as #{name}-#{version}.gem into system gems without network access."
-      task "install:local" => "build" do
-        install_gem(built_gem_path, :local)
-      end
-
-      desc "Create tag #{version_tag} and build and push #{Color.yellow(@export_as)} addon #{name}-#{version}.gem to Rubygems\n" \
-           "To prevent publishing in Rubygems use `gem_push=no rake release`"
-      task "release", [:remote] => ["build", "release:guard_clean",
-                                    "release:source_control_push", "release:rubygem_push"] do
-      end
-
-      task "release:guard_clean" do
-        guard_clean
-      end
-
-      task "release:source_control_push", [:remote] do |_, args|
-        tag_version { git_push(args[:remote]) } unless already_tagged?
-      end
-
-      task "release:rubygem_push" do
-        rubygem_push(built_gem_path) if gem_push?
-      end
-
-      GemHelper.instance = self
-    end
-
-    def build_gem
-      file_name = nil
-      sh("gem build -V '#{spec_path}'") do
-        file_name = File.basename(built_gem_path)
-        FileUtils.mkdir_p(File.join(base, 'pkg'))
-        FileUtils.mv(built_gem_path, 'pkg')
-        tell_user_success("#{name} #{version} built to pkg/#{file_name}.")
-      end
-      File.join(base, "pkg", file_name)
-    end
-
-    def install_gem(built_gem_path = nil, local = false)
-      built_gem_path ||= build_gem
-      out, _ = sh_with_code("gem install '#{built_gem_path}'#{" --local" if local}")
-      raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
-      tell_user_success("#{name} (#{version}) installed.")
-    end
-
-  protected
-
-    def tell_user_success(msg)
-      puts Color.green(msg)
-    end
-
-    def tell_user_error(msg)
-      puts Color.red(msg)
-    end
-
-    def rubygem_push(path)
-      allowed_push_host = nil
-      gem_command = "gem push '#{path}'"
-      if @gemspec.respond_to?(:metadata)
-        allowed_push_host = @gemspec.metadata["allowed_push_host"]
-        gem_command += " --host #{allowed_push_host}" if allowed_push_host
-      end
-      unless allowed_push_host || Pathname.new("~/.gem/credentials").expand_path.file?
-        raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
-      end
-      sh(gem_command)
-      tell_user_success "Pushed #{name} #{version} to #{allowed_push_host ? allowed_push_host : "rubygems.org."}"
-    end
-
-    def built_gem_path
-      Dir[File.join(base, "#{name}-*.gem")].sort_by {|f| File.mtime(f) }.last
-    end
-
-    def git_push(remote = "")
-      perform_git_push remote
-      perform_git_push "#{remote} --tags"
-      tell_user_success "Pushed git commits and tags."
-    end
-
-    def perform_git_push(options = "")
-      cmd = "git push #{options}"
-      out, code = sh_with_code(cmd)
-      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
-    end
-
-    def already_tagged?
-      return false unless sh("git tag").split(/\n/).include?(version_tag)
-      tell_user_success "Tag #{version_tag} has already been created."
-      true
-    end
-
-    def guard_clean
-      clean? && committed? || raise("There are files that need to be committed first.")
-    end
-
-    def clean?
-      sh_with_code("git diff --exit-code")[1] == 0
-    end
-
-    def committed?
-      sh_with_code("git diff-index --quiet --cached HEAD")[1] == 0
-    end
-
-    def tag_version
-      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
-      tell_user_success "Tagged #{version_tag}."
-      yield if block_given?
-    rescue
-      tell_user_error "Untagging #{version_tag} due to error."
-      sh_with_code "git tag -d #{version_tag}"
-      raise
-    end
-
-    def version
-      gemspec.version
-    end
-
-    def version_tag
-      "v#{version}"
-    end
-
-    def name
-      gemspec.name
-    end
-
-    def sh(cmd, &block)
-      out, code = sh_with_code(cmd, &block)
-      unless code.zero?
-        raise(out.empty? ? "Running `#{cmd}` failed. Run this command directly for more detailed output." : out)
-      end
-      out
-    end
-
-    def sh_with_code(cmd, &block)
-      cmd += " 2>&1"
-      outbuf = String.new
-      Dir.chdir(base) do
-        outbuf = `#{cmd}`
-        status = $?.exitstatus
-        block.call(outbuf) if status.zero? && block
-        [outbuf, status]
-      end
-    end
-
-    def gem_push?
-      ! %w(n no nil false off 0).include?(ENV["gem_push"].to_s.downcase)
-    end
-  end
-end

data/lib/yap/gem_tasks.rb

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

data/lib/yap/shell.rb

@@ -1,116 +0,0 @@
-require 'readline'
-require 'yaml'
-require 'fcntl'
-
-module Yap
-  module Shell
-    require 'yap/shell/version'
-    require 'yap/shell/builtins'
-
-    autoload :Aliases, "yap/shell/aliases"
-
-    autoload :CommandFactory, "yap/shell/commands"
-    autoload :CommandError,  "yap/shell/commands"
-    autoload :BuiltinCommand,  "yap/shell/commands"
-    autoload :FileSystemCommand,  "yap/shell/commands"
-    autoload :RubyCommand,  "yap/shell/commands"
-    autoload :ShellCommand,  "yap/shell/commands"
-
-    autoload :Execution,  "yap/shell/execution"
-
-    autoload :Evaluation, "yap/shell/evaluation"
-    autoload :Repl, "yap/shell/repl"
-
-    class Impl
-      def initialize(addons:)
-        @original_file_descriptor_flags = {
-          stdin: $stdin.fcntl(Fcntl::F_GETFL, 0),
-          stdout: $stdout.fcntl(Fcntl::F_GETFL, 0),
-          stderr: $stderr.fcntl(Fcntl::F_GETFL, 0)
-        }
-
-        @stdin = $stdin
-        @stdout = $stdout
-        @stderr = $stderr
-
-        @stdout.sync = true
-        @stderr.sync = true
-
-        addons_str = "\n  - " + addons.map(&:class).map(&:name).join("\n  - ")
-        Treefell['shell'].puts "Constructing world instance with addons: #{addons_str}"
-        @world = Yap::World.instance(addons:addons)
-      end
-
-      # Yields to the passed in block after restoring the file descriptor
-      # flags that Yap started in. This ensures that any changes Yap has
-      # made to run the shell don't interfere with child processes.
-      def with_original_file_descriptor_flags(&block)
-        current_file_descriptor_flags = {
-          stdin: $stdin.fcntl(Fcntl::F_GETFL, 0),
-          stdout: $stdout.fcntl(Fcntl::F_GETFL, 0),
-          stderr: $stderr.fcntl(Fcntl::F_GETFL, 0)
-        }
-
-        $stdin.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stdin])
-        $stdout.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stdout])
-        $stderr.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stderr])
-
-        yield
-      ensure
-        $stdin.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stdin])
-        $stdout.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stdout])
-        $stderr.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stderr])
-      end
-
-      def repl
-        context = Yap::Shell::Execution::Context.new(
-          stdin:  @stdin,
-          stdout: @stdout,
-          stderr: @stderr
-        )
-
-        @world.repl.on_input do |input|
-          Treefell['shell'].puts "repl received input: #{input.inspect}"
-          evaluation = Yap::Shell::Evaluation.new(stdin:@stdin, stdout:@stdout, stderr:@stderr, world:@world)
-          evaluation.evaluate(input) do |command, stdin, stdout, stderr, wait|
-            Treefell['shell'].puts <<-DEBUG.gsub(/^\s*\|/, '')
-              |adding #{command} to run in context of:
-              |  stdin: #{stdin.inspect}
-              |  stdout: #{stdout.inspect}
-              |  stderr: #{stderr.inspect}
-              |  wait for child process to complete? #{wait.inspect}
-            DEBUG
-            context.clear_commands
-            context.add_command_to_run command, stdin:stdin, stdout:stdout, stderr:stderr, wait:wait
-
-            with_original_file_descriptor_flags do
-              context.execute(world:@world)
-            end
-          end
-        end
-
-        begin
-          Treefell['shell'].puts "enter interactive mode"
-          @world.interactive!
-        # rescue Errno::EIO => ex
-        #   # This happens when yap is no longer the foreground process
-        #   # but it tries to receive input/output from the tty. I believe it
-        #   # is a race condition when launching a child process.
-        rescue Interrupt
-          Treefell['shell'].puts "^C"
-          @world.editor.puts "^C"
-          retry
-        rescue Exception => ex
-          if !ex.is_a?(SystemExit)
-            if $stdout.isatty
-              binding.pry
-            else
-              $stdout.puts ex.class.name
-              raise ex
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yap/shell/aliases.rb

@@ -1,58 +0,0 @@
-require 'singleton'
-
-module Yap::Shell
-  class Aliases
-    include Singleton
-
-    def initialize
-      @file = ENV["HOME"] + "/.yapaliases.yml"
-      @aliases = begin
-        Treefell['shell'].puts "reading aliases from disk: #{@file}"
-        YAML.load_file(@file)
-      rescue
-        {}
-      end
-    end
-
-    def names
-      @aliases.keys
-    end
-
-    def fetch_alias(name)
-      @aliases[name].tap do |contents|
-        Treefell['shell'].puts "alias fetched name=#{name} contents=#{contents.inspect}"
-      end
-    end
-
-    def set_alias(name, contents)
-      @aliases[name] = contents
-      Treefell['shell'].puts "alias set name=#{name} to #{contents.inspect}"
-      write_to_disk
-    end
-
-    def unset_alias(name)
-      @aliases.delete(name)
-      Treefell['shell'].puts "alias unset name=#{name}"
-      write_to_disk
-    end
-
-    def has_key?(key)
-      @aliases.has_key?(key)
-    end
-
-    def to_h
-      @aliases.keys.compact.sort.inject(Hash.new) do |h,k|
-        h[k] = @aliases[k]
-        h
-      end
-    end
-
-    private
-
-    def write_to_disk
-      File.write(@file, @aliases.to_yaml).tap do
-        Treefell['shell'].puts "aliases written to disk: #{@file}"
-      end
-    end
-  end
-end