yap-shell 0.6.0 → 0.7.0

data/lib/yap/cli/options/addon/list.rb

@@ -0,0 +1,65 @@
+module Yap
+  module Cli
+    class Options::Addon::List
+      include OptionsLoader
+
+      attr_reader :command, :options
+
+      def initialize(options:)
+        @options = options
+      end
+
+      def parse(args)
+        option_parser.order!(args)
+      end
+
+      def command
+        @command ||= load_command('addon/list').new
+      end
+
+      def help_message
+        option_parser.to_s
+      end
+
+      private
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = <<-TEXT.gsub(/^\s*\|/, '')
+            |Usage: #{opts.program_name} addon list [options]
+            |
+            |#{Term::ANSIColor.cyan('yap addon list')} can be used to list yap addons.
+            |
+            |Addon list options:
+          TEXT
+
+          opts.on('-h', '--help', 'Prints this help') do
+            puts opts
+            puts
+            puts  <<-TEXT.gsub(/^\s*\|/, '')
+              |Example: Listing all addons
+              |
+              |   #{opts.program_name} addon list
+              |
+              |Example: Listing disabled addons only
+              |
+              |   #{opts.program_name} addon list --disabled
+              |
+              |Example: Listing enabled addons only
+              |
+              |   #{opts.program_name} addon list --enabled
+              |
+            TEXT
+            exit 0
+          end
+          opts.on('--enabled', 'Lists yap addons that are enabled') do
+            command.filter = :enabled
+          end
+          opts.on('--disabled', 'Lists yap addons that are disabled') do
+            command.filter = :disabled
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yap/cli/options/addon/search.rb

@@ -0,0 +1,76 @@
+module Yap
+  module Cli
+    class Options::Addon::Search
+      include OptionsLoader
+
+      attr_reader :command, :options
+
+      def initialize(options:)
+        @options = options
+      end
+
+      def parse(args)
+        search_terms = []
+        while args.any?
+          option_parser.order!(args)
+          search_terms << args.shift
+        end
+        command.search_term = search_terms.shift
+      end
+
+      def command
+        @command ||= load_command('addon/search').new
+      end
+
+      def help_message
+        option_parser.to_s
+      end
+
+      private
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = <<-TEXT.gsub(/^\s*\|/, '')
+            |Usage: #{opts.program_name} addon search [options] [addon-name]
+            |
+            |#{Term::ANSIColor.cyan('yap addon search')} can be used to search for yap addons.
+            |
+            |Addon search options:
+          TEXT
+
+          opts.on('-h', '--help', 'Prints this help') do
+            puts opts
+            puts
+            puts  <<-TEXT.gsub(/^\s*\|/, '')
+              |Example: Search for an addon
+              |
+              |   #{opts.program_name} addon search --local foo
+              |
+              |Example: Search for an addon locally (no network access)
+              |
+              |   #{opts.program_name} addon search foo
+              |
+            TEXT
+            exit 0
+          end
+          opts.on('--local', 'Search locally, no network access') do
+            command.local = true
+          end
+          opts.on('-a', '--all', 'Display all addon versions') do
+            command.all = true
+          end
+          opts.on('--prerelease', 'Display prerelease versions') do
+            command.prerelease = true
+          end
+          opts.on('--gem-name', 'Display rubygem name instead of shortened yap addon name') do
+            command.show_gem_name = true
+          end
+          opts.on('-v', '--version VERSION', 'Specify version of addon to search') do |version|
+            command.version = version
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/yap/cli/options/generate.rb

@@ -0,0 +1,59 @@
+module Yap
+  module Cli
+    class Options::Generate
+      include OptionsLoader
+
+      attr_reader :command, :options
+
+      def initialize(options:)
+        @options = options
+        @exit_status = 0
+      end
+
+      def parse(args)
+        if args.empty?
+          args.unshift '--help'
+          STDERR.puts "generate must be called with a component type!"
+          @exit_status = 1
+          puts
+        end
+
+        option_parser.order!(args)
+      end
+
+      def command
+        @command ||= load_command('generate').new
+      end
+
+      private
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = <<-TEXT.gsub(/^\s*\|/, '')
+            |Usage: #{opts.program_name} generate [component-type] [options]
+            |
+            |#{Term::ANSIColor.cyan('yap generate')} can be used to generate yap components, like an addon.
+            |
+            |Generate commands:
+            |
+            |  #{Term::ANSIColor.yellow('addon')} - generates a yap addon skeleton
+            |
+            |Generate options:
+          TEXT
+
+          opts.on('-h', '--help', 'Prints this help') do
+            puts opts
+            puts
+            puts  <<-TEXT.gsub(/^\s*\|/, '')
+              |Example: Generating an addon
+              |
+              |   #{opts.program_name} generate addon magical-key-bindings
+              |
+            TEXT
+            exit @exit_status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yap/cli/options/generate/addon.rb

@@ -0,0 +1,63 @@
+module Yap
+  module Cli
+    class Options::Generate::Addon
+      include OptionsLoader
+
+      attr_reader :command, :options
+
+      def initialize(options:)
+        @options = options
+        @exit_status = 0
+      end
+
+      def parse(args)
+        @addon_name = args.shift unless args.first =~ /^-/
+        unless @addon_name
+          args.unshift '--help'
+          STDERR.puts "Missing addon-name!"
+          @exit_status = 1
+          puts
+        end
+        option_parser.order!(args)
+      end
+
+      def command
+        @command ||= load_command('generate/addon').new(@addon_name)
+      end
+
+      def help_message
+        option_parser.to_s
+      end
+
+      private
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = <<-TEXT.gsub(/^\s*\|/, '')
+            |Usage: #{opts.program_name} generate addon [addon-name] [options]
+            |
+            |#{Term::ANSIColor.cyan('yap addon')} can be used to generate a yap addon skeleton provided an addon name.
+            |
+            |Generate addon options:
+          TEXT
+
+          opts.on('-h', '--help', 'Prints this help') do
+            puts opts
+            puts
+            puts  <<-TEXT.gsub(/^\s*\|/, '')
+              |Example: Generating an addon
+              |
+              |   #{opts.program_name} generate addon magical-key-bindings
+              |
+            TEXT
+            exit @exit_status
+          end
+
+          opts.on('--skip-git', 'Skip git initialization') do
+            command.use_git = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yap/configuration.rb

@@ -10,6 +10,8 @@ module Yap
   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
@@ -31,16 +33,21 @@ module Yap
       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"
-      ]
+        # "#{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",

data/lib/yap/gem_helper.rb

@@ -0,0 +1,195 @@
+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