yap-shell 0.6.0 → 0.7.0

data/lib/yap/addon/path.rb

@@ -0,0 +1,56 @@
+module Yap
+  module Addon
+    class Path
+      def self.find_for_configuration(configuration)
+        addons_config_hsh = {}
+        if File.exists?(configuration.yap_addons_configuration_path)
+          addons_config_hsh = YAML.load_file(configuration.yap_addons_configuration_path)
+        end
+
+        new(configuration.addon_paths.flatten, addons_config_hsh).
+          references.sort_by(&:name)
+      end
+
+      attr_reader :references
+
+      def initialize(paths, addons_config_hsh={})
+        @paths = paths
+        @addons_config_hsh = addons_config_hsh
+      end
+
+      def references
+        @references ||= search_for_addons
+      end
+
+      private
+
+      def search_for_addons
+        @paths.each_with_object([]) do |path, results|
+          Dir["#{path}/*"].map do |directory|
+            next unless File.directory?(directory)
+
+            if File.basename(directory) =~ /(yap-shell-addon-(.*))-\d+\.\d+\.\d+/
+              require_as, name = $1, $2
+
+              addonrb_path = directory + "/lib/" + require_as + ".rb"
+              export_as = ExportAs.find_in_file(addonrb_path)
+              name = export_as if export_as
+              name = name.to_sym
+
+              enabled = !@addons_config_hsh.fetch(
+                name, { disabled: false }
+              )[:disabled]
+
+              results << Yap::Addon::Reference.new(
+                name: name,
+                require_as: require_as,
+                path: File.expand_path(directory),
+                enabled: enabled
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yap/addon/rc_file.rb

@@ -0,0 +1,21 @@
+module Yap
+  module Addon
+    class RcFile < Yap::Addon::Base
+      attr_reader :file
+
+      def initialize(file)
+        super(enabled: true)
+        @file = File.expand_path(file)
+      end
+
+      def addon_name
+        @file
+      end
+
+      def initialize_world(world)
+        Treefell['shell'].puts "initializing rcfile: #{file}"
+        world.instance_eval File.read(@file), @file
+      end
+    end
+  end
+end

data/lib/yap/addon/reference.rb

@@ -0,0 +1,22 @@
+module Yap
+  module Addon
+    class Reference
+      attr_reader :name, :require_as, :path
+
+      def initialize(name:, require_as:, path:, enabled: true)
+        @name = name
+        @require_as = require_as
+        @path = path
+        @enabled = enabled
+      end
+
+      def disabled?
+        !@enabled
+      end
+
+      def enabled?
+        @enabled
+      end
+    end
+  end
+end

data/lib/yap/cli.rb

@@ -0,0 +1,4 @@
+module Yap
+  module Cli
+  end
+end

data/lib/yap/cli/commands.rb

@@ -0,0 +1,6 @@
+module Yap
+  module Cli
+    module Commands
+    end
+  end
+end

data/lib/yap/cli/commands/addon.rb

@@ -0,0 +1,14 @@
+module Yap
+  module Cli
+    module Commands
+      class Addon
+        def initialize(addon_name)
+          @addon_name = addon_name
+        end
+
+        def process
+        end
+      end
+    end
+  end
+end

data/lib/yap/cli/commands/addon/disable.rb

@@ -0,0 +1,35 @@
+module Yap
+  module Cli
+    module Commands
+      class Addon::Disable
+        def initialize(addon_name)
+          @addon_name = addon_name
+        end
+
+        def process
+          configuration = Yap.configuration
+          addon_refs = Yap::Addon::Path.find_for_configuration(configuration)
+          addon_config_hsh = {}
+          found_addon_ref = nil
+          addon_refs.each do |addon_ref|
+            is_disabled = addon_ref.disabled?
+            if addon_ref.name.to_s == @addon_name.to_s
+              is_disabled = true
+              found_addon_ref = addon_ref
+            end
+            addon_config_hsh[addon_ref.name] = { disabled: is_disabled }
+          end
+
+          if found_addon_ref
+            destination = configuration.yap_addons_configuration_path.to_s
+            FileUtils.mkdir_p File.dirname(destination)
+            File.write destination, addon_config_hsh.to_yaml
+            puts "Addon #{found_addon_ref.name} has been disabled"
+          else
+            puts "Could not find addon with name #{@addon_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yap/cli/commands/addon/enable.rb

@@ -0,0 +1,35 @@
+module Yap
+  module Cli
+    module Commands
+      class Addon::Enable
+        def initialize(addon_name)
+          @addon_name = addon_name
+        end
+
+        def process
+          configuration = Yap.configuration
+          addon_refs = Yap::Addon::Path.find_for_configuration(configuration)
+          addon_config_hsh = {}
+          found_addon_ref = nil
+          addon_refs.each do |addon_ref|
+            is_disabled = addon_ref.disabled?
+            if addon_ref.name.to_s == @addon_name.to_s
+              is_disabled = false
+              found_addon_ref = addon_ref
+            end
+            addon_config_hsh[addon_ref.name] = { disabled: is_disabled }
+          end
+
+          if found_addon_ref
+            destination = configuration.yap_addons_configuration_path.to_s
+            FileUtils.mkdir_p File.dirname(destination)
+            File.write destination, addon_config_hsh.to_yaml
+            puts "Addon #{found_addon_ref.name} has been enabled"
+          else
+            puts "Could not find addon with name #{@addon_name}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Yap
+  module Cli
+    module Commands
+      class Addon::List
+        def filter=(filter_kind)
+          @filter = filter_kind
+        end
+
+        def process
+          configuration = Yap.configuration
+
+          addon_refs = ::Yap::Addon::Path.
+            find_for_configuration(configuration)
+          if addon_refs.empty?
+            puts <<-MSG.strip_heredoc
+              |No addons found searching paths:
+              |  - #{configuration.addon_paths.join("\n  -")}
+            MSG
+          elsif @filter == :enabled
+            addon_refs.select(&:enabled?).each do |addon_ref|
+              puts "#{addon_ref.name}"
+            end
+          elsif @filter == :disabled
+            addon_refs.select(&:disabled?).each do |addon_ref|
+              puts "#{addon_ref.name}"
+            end
+          else
+            addon_refs.each do |addon_ref|
+              enabled_or_disabled = addon_ref.enabled? ? 'enabled' : 'disabled'
+              puts "#{addon_ref.name} (#{enabled_or_disabled})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Yap
+  module Cli
+    module Commands
+      class Addon::Search
+        attr_accessor :all, :local, :prerelease, :search_term, :version
+        attr_accessor :show_gem_name
+
+        def process
+          options = []
+
+          if search_term.nil?
+            puts "No addons found. Please provide a search term."
+          end
+
+          options << '--all' if all
+          options << '--local' if local
+          options << '--prerelease' if prerelease
+          options << "--version #{version}" if version
+
+          print_addons gem_search(options)
+        end
+
+        def extract_gem_names_from_search(search_results)
+          search_results.lines.map(&:chomp).map do |line|
+            results = line.scan(/^(yap-shell-addon-(\S+))\s*\((\d+\.\d+\.\d+)\)/)
+            gem_name, _, _ = results.flatten
+            gem_name
+          end.compact
+        end
+
+        def gem_search(options)
+          search_results = `gem search #{options.join(' ')} yap-shell | grep #{search_term}`
+          gem_names = extract_gem_names_from_search search_results
+          gem_specs_for_gems gem_names
+        end
+
+        def gem_specs_for_gems(gem_names)
+          options = []
+          options << (local ? '-l' : '-r')
+          options << "--version #{version}" if version
+          gem_names.map do |gem_name|
+            YAML.load `gem spec #{options.join(' ')} #{gem_name}`
+          end
+        end
+
+        def print_addons(gemspecs)
+          headers = {
+            name: (show_gem_name ? "Rubygem" : "Addon Name"),
+            version: "Version",
+            date: "Date Released",
+            author: "Author",
+            summary: "Summary"
+          }
+          value_for = {
+            name: -> (s) {
+              if show_gem_name
+                s.name
+              else
+                s.name.scan(/^yap-shell-addon-(\S+)/).flatten.first
+              end
+            },
+            version: -> (s) { s.version.to_s },
+            date: -> (s) { s.date.to_date.to_s },
+            author: -> (s) { s.author },
+            summary: -> (s) { s.summary }
+          }
+
+          longest = {
+            name: gemspecs.map{ |s| value_for[:name].call(s) }.concat(Array(headers[:name])).map(&:length).max,
+            version: gemspecs.map{ |s| value_for[:version].call(s) }.concat(Array(headers[:version])).map(&:length).max,
+            date: gemspecs.map{ |s| value_for[:date].call(s) }.concat(Array(headers[:date])).map(&:length).max,
+            author: gemspecs.map{ |s| value_for[:author].call(s) }.concat(Array(headers[:author])).map(&:length).max,
+            summary: gemspecs.map{ |s| value_for[:summary].call(s) }.concat(Array(headers[:summary])).map(&:length).max
+          }
+
+          spacing = "  "
+          format_string = longest.reduce([]) do |str, (key, maxlength)|
+            str << "%-#{maxlength}s"
+          end.join(spacing)
+
+          output = gemspecs.map do |gemspec|
+            values = longest.keys.map { |key| value_for[key].call(gemspec) }
+            sprintf "#{format_string}", *values
+          end
+          output = output.join("\n")
+
+          highlighted_output = output.gsub(/(#{Regexp.escape(search_term)})/) do
+            Term::ANSIColor.cyan($1)
+          end
+
+          puts Term::ANSIColor.bright_black(
+            sprintf("#{format_string}", *longest.keys.map { |key| headers[key] })
+          )
+          puts highlighted_output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'fileutils'
+require 'term/ansicolor'
+
+module Yap
+  module Cli
+    module Commands
+      class Generate
+        def process
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+require 'fileutils'
+require 'term/ansicolor'
+
+module Yap
+  module Cli
+    module Commands
+      class Generate::Addon
+        attr_accessor :addon_name, :version, :use_git
+
+        def initialize(addon_name)
+          @addon_name = addon_name.gsub(/[^\w\-_]+/, '-').downcase
+          @version = '0.1.0'
+          @use_git = true
+        end
+
+        def doing(text, &block)
+          print "#{text}"
+          block.call
+          puts " #{Term::ANSIColor.green('done')}"
+        end
+
+        def process
+          puts "Creating addon #{Term::ANSIColor.yellow(addon_name)} in #{addon_dir}/"
+          puts
+
+          mkdir addon_dir
+          Dir.chdir addon_dir do
+            mkdir lib_path
+            write_file 'Gemfile', gemfile_contents
+            write_file gemspec_name, gemspec_contents
+            write_file 'LICENSE.txt', license_contents
+            write_file 'Rakefile', rakefile_contents
+            write_file 'README.md', readme_contents
+            write_file addonrb_path, addonrb_contents
+            mkdir lib_addon_path
+            write_file version_path, version_contents
+
+            puts
+            if use_git && `which git` && $?.exitstatus == 0
+              write_file '.gitignore', gitignore_contents
+              doing "git init . && git add . && git commit -m 'initial commit of #{addon_name}'" do
+                `git init . && git add . && git commit -m 'initial commit of #{addon_name} addon for yap'`
+              end
+            else
+              puts "Git initialization #{Term::ANSIColor.cyan('skipped')}"
+            end
+          end
+
+          puts
+          puts "Yap addon generated! A few helpful things to note:"
+          puts
+          puts <<-TEXT.gsub(/^\s*\|/, '')
+            |  * The #{Term::ANSIColor.yellow(addon_name)} addon has been generated in #{addon_dir}/
+            |  * It is a standard rubygem, has its own gemspec, and is named #{Term::ANSIColor.yellow(gem_safe_addon_name)}
+            |  * Yap loads the #{Term::ANSIColor.yellow(constant_name)}, found in #{addonrb_path} (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 #{gem_safe_addon_name}
+          TEXT
+          puts
+        end
+
+        private
+
+        def mkdir(path)
+          doing("Create directory: #{path}"){ FileUtils.mkdir_p path }
+        end
+
+        def write_file(path, contents)
+          doing "Creating file: #{path}" do
+            File.write path, contents
+          end
+        end
+
+        def addon_dir
+          gem_safe_addon_name
+        end
+
+        def addonrb_path
+          File.join(lib_path, gem_safe_addon_name + '.rb')
+        end
+
+        def addonrb_contents
+          contents = File.read(File.dirname(__FILE__) + '/addonrb.template')
+          contents % addonrb_template_variables
+        end
+
+        def addonrb_template_variables
+          export_as = addon_name
+          export_as = "'#{addon_name}'" if addon_name =~ /-/
+          {
+            addon_dir: addon_dir,
+            constant_name: constant_name,
+            export_as: export_as
+          }
+        end
+
+        def bundler_version
+          require 'bundler/version'
+          Bundler::VERSION.scan(/\d+\.\d+/).first ||
+            fail('Cannot determine bundler version')
+        end
+
+        def constant_name
+          gem_safe_addon_name.split(/\W+/).map(&:capitalize).join
+        end
+
+        def gemfile_contents
+          <<-GEMFILE.gsub(/^\s*\|/, '')
+            |source 'https://rubygems.org'
+            |
+            |# Specify your gem's dependencies in #{gemspec_name}
+            |gemspec
+          GEMFILE
+        end
+
+        def gem_safe_addon_name
+          "yap-shell-addon-#{addon_name}"
+        end
+
+        def gemspec_name
+          "#{gem_safe_addon_name}.gemspec"
+        end
+
+        def gemspec_contents
+          contents = File.read(File.dirname(__FILE__) + '/gemspec.template')
+          contents % gemspec_template_variables
+        end
+
+        def gemspec_template_variables
+          {
+            addon_dir: addon_dir,
+            constant_name: constant_name,
+            summary: "#{addon_name} summary goes here.",
+            description: "#{addon_name} description goes here.",
+            license: 'MIT',
+            authors: [],
+            email: 'you@example.com',
+            homepage: '',
+            bundler_version: bundler_version,
+            rake_version: rake_version,
+            rspec_version: rspec_version,
+            yap_version: yap_version
+          }
+        end
+
+        def gitignore_contents
+          <<-TEXT.gsub(/^\s*/, '')
+            *.gem
+            *.rbc
+            .bundle
+            .config
+            .yardoc
+            Gemfile.lock
+            InstalledFiles
+            _yardoc
+            coverage
+            doc/
+            lib/bundler/man
+            pkg
+            rdoc
+            spec/reports
+            test/tmp
+            test/version_tmp
+            tmp
+            *.bundle
+            *.so
+            *.o
+            *.a
+            mkmf.log
+            wiki/
+          TEXT
+        end
+
+        def lib_path
+          File.join('lib')
+        end
+
+        def lib_addon_path
+          File.join(lib_path, addon_dir)
+        end
+
+        def license_contents
+          contents = File.read(File.dirname(__FILE__) + '/license.template')
+          contents % license_template_variables
+        end
+
+        def license_template_variables
+          username = (`git config user.name` rescue 'YOUR_NAME')
+          { username: username }
+        end
+
+        def rake_version
+          require 'rake/version'
+          version_string = if Rake.const_defined?(:VERSION)
+            Rake::VERSION
+          else
+            Rake::Version::NUMBERS.join('.')
+          end
+          version_string.scan(/\d+\.\d+/).first ||
+            fail('Cannot determine rake version')
+        end
+
+        def rakefile_contents
+          File.read(File.dirname(__FILE__) + '/rakefile.template')
+        end
+
+        def readme_contents
+          contents = File.read(File.dirname(__FILE__) + '/readme.template')
+          contents % readme_template_variables
+        end
+
+        def readme_template_variables
+          {
+            addon_name: addon_name,
+            gem_safe_addon_name: gem_safe_addon_name,
+            lib_addon_path: lib_addon_path,
+            addon_dir: addon_dir,
+            constant_name: constant_name,
+            summary: "#{addon_name} summary goes here.",
+            description: "#{addon_name} description goes here.",
+            license: 'MIT',
+            authors: [],
+            email: 'you@example.com',
+            homepage: ''
+          }
+        end
+
+        def rspec_version
+          require 'rspec/version'
+          RSpec::Version::STRING.scan(/\d+\.\d+/).first ||
+            fail('Cannot determine rspec version')
+        end
+
+        def version_path
+          File.join(lib_addon_path, 'version.rb')
+        end
+
+        def version_contents
+          <<-RUBY.gsub(/^\s*\|/, '')
+            |module #{constant_name}
+            |  VERSION = '#{version}'
+            |end
+          RUBY
+        end
+
+        def yap_version
+          Yap::Shell::VERSION.scan(/\d+\.\d+/).first ||
+            fail('Cannot determine yap version')
+        end
+      end
+    end
+  end
+end