hairballs 0.0.1

data/lib/hairballs/plugins/require_project_lib.rb

@@ -0,0 +1,17 @@
+require_relative '../../hairballs'
+
+# Adds the Object#require_project_lib method as a shortcut for
+#
+#     require 'lib/my_library'          # Or...
+#     require 'lib/my/nested/project'   # i.e. gem = my-nested-project
+#
+Hairballs.add_plugin(:require_project_lib) do |plugin|
+  plugin.on_load do
+    Object.class_eval do
+      def require_project_lib
+        require_dir = File.join(*Hairballs.project_name.split('-'))
+        require_relative "#{Dir.pwd}/lib/#{require_dir}"
+      end
+    end
+  end
+end

data/lib/hairballs/plugins/tab_completion_for_files.rb

@@ -0,0 +1,35 @@
+require_relative '../../hairballs'
+
+# Adds the ability to tab-complete files that are in the current directory.
+#
+# Example:
+#
+#     # If in the hairballs project root, doing this...
+#     irb> File.read("READ⇥
+#     # Will complete like this...
+#     irb> File.read("README.md"
+#
+Hairballs.add_plugin(:tab_completion_for_files) do |plugin|
+  plugin.on_load do
+    Hairballs.completion_procs << proc do |string|
+      Dir['*'].grep(/^#{Regexp.escape(string)}*/)
+    end
+
+    if defined? ::IRB::InputCompletor::CompletionProc
+      Hairballs.completion_procs << ::IRB::InputCompletor::CompletionProc
+    end
+
+    completion_proc = Proc.new do |string|
+      Hairballs.completion_procs.map do |proc|
+        proc.call(string)
+      end.flatten.uniq
+    end
+
+    if Readline.respond_to?('basic_word_break_characters=')
+      Readline.basic_word_break_characters= " \"'\t\n`><=;|&{("
+    end
+
+    Readline.completion_append_character = nil
+    Readline.completion_proc = completion_proc
+  end
+end

data/lib/hairballs/plugins/wirble.rb

@@ -0,0 +1,11 @@
+require_relative '../../hairballs'
+
+# Just loads Wirble.
+Hairballs.add_plugin(:wirble) do |plugin|
+  plugin.libraries %w(wirble)
+
+  plugin.on_load do
+    Wirble.init
+    Wirble.colorize
+  end
+end

data/lib/hairballs/prompt.rb

@@ -0,0 +1,64 @@
+class Hairballs
+  # Hairballs representation of IRB.conf[:PROMPT].  Method names here make
+  # prompt types clearer.
+  #
+  # TODO: Make it nicer to define Pry prompts.
+  class Prompt
+    # @param [Boolean]
+    attr_accessor :auto_indent
+
+    # The normal prompt string.  Same as
+    # IRB.conf[:PROMPT][ prompt name ][:PROMPT_I]
+    #
+    # @param [String]
+    attr_accessor :normal
+    alias_method :i, :normal
+    alias_method :i=, :normal=
+
+    # The prompt for when strings wrap multiple lines.  Same as
+    # IRB.conf[:PROMPT][ prompt name ][:PROMPT_S]
+    #
+    # @param [String]
+    attr_accessor :continued_string
+    alias_method :s, :continued_string
+    alias_method :s=, :continued_string=
+
+    # The prompt for when statements wrap multiple lines.  Same as
+    # IRB.conf[:PROMPT][ prompt name ][:PROMPT_C]
+    #
+    # @param [String]
+    attr_accessor :continued_statement
+    alias_method :c, :continued_statement
+    alias_method :c=, :continued_statement=
+
+    # The prompt for when statements include indentation.  Same as
+    # IRB.conf[:PROMPT][ prompt name ][:PROMPT_N]
+    #
+    # @param [String]
+    attr_accessor :indented_code
+    alias_method :n, :indented_code
+    alias_method :n=, :indented_code=
+
+    # The prompt for return values.  Same as
+    # IRB.conf[:PROMPT][ prompt name ][:RETURN]
+    #
+    # @param [String]
+    attr_accessor :return_format
+
+    # @return [Hash] A set of key/value pairs that can be used to pass to a
+    #   IRB.conf[:PROMPT][ prompt name ].
+    def irb_configuration
+      vputs 'Setting up prompt...'
+
+      prompt_values = {}
+      prompt_values[:AUTO_INDENT] = @auto_indent if @auto_indent
+      prompt_values[:PROMPT_C] = continued_statement unless continued_statement.empty?
+      prompt_values[:PROMPT_I] = normal unless normal.empty?
+      prompt_values[:PROMPT_N] = indented_code unless indented_code.empty?
+      prompt_values[:PROMPT_S] = continued_string unless continued_string.empty?
+      prompt_values[:RETURN] = @return_format if @return_format
+
+      prompt_values
+    end
+  end
+end

data/lib/hairballs/theme.rb

@@ -0,0 +1,110 @@
+require_relative 'library_helpers'
+require_relative 'prompt'
+
+class Hairballs
+  # Themes primarily provide a means for customizing the look of your IRB
+  # prompt, although you're at liberty to also do any other Ruby stuff you'd
+  # like, including load up common Hairballs::Plugins.
+  #
+  # Unless you know you do, you probably don't need to use this directly;
+  # +Hairballs.add_theme()+ and +Hairballs.use_theme()+ should cover most use
+  # cases.
+  class Theme
+    include LibraryHelpers
+
+    # Just an identifier for the Theme.  Don't name two themes the same
+    # name--that will cause problems.
+    #
+    # @param [Symbol]
+    attr_accessor :name
+
+    # Tells Hairballs to do some hackery to let Themes use gems that aren't
+    # specified in your app's Gemfile.  This alleviates you from having to
+    # declare gems in your Gemfile simply for the sake of managing your personal
+    # IRB preferences.
+    #
+    # @param [Boolean]
+    attr_accessor :extend_bundler
+
+    # @param name [Symbol]
+    def initialize(name)
+      @name = name
+      @prompt = Prompt.new
+      @extend_bundler = false
+    end
+
+    # Tell IRB to use this Theme.
+    def use!
+      do_bundler_extending if @extend_bundler
+      require_libraries
+      set_up_prompt
+    end
+
+    # The name of the Theme, but in the format that IRB.conf[:PROMPT] likes (an
+    # all-caps Symbol).
+    #
+    # @return [Symbol]
+    def irb_name
+      @name.to_s.upcase.to_sym
+    end
+
+    # @return [Hairballs::Prompt]
+    def prompt(&block)
+      if block_given?
+        @prompt_block = block
+      else
+        @prompt
+      end
+    end
+
+    #---------------------------------------------------------------------------
+    # PRIVATES
+    #---------------------------------------------------------------------------
+
+    private
+
+    # Does all the things that are required for getting IRB to use your Theme.
+    def set_up_prompt
+      @prompt_block.call(@prompt)
+
+      if IRB.conf[:PROMPT].nil? && defined?(Pry)
+        set_up_pry_prompt
+        set_up_pry_printer
+      elsif IRB.conf[:PROMPT]
+        set_up_irb_prompt
+      else
+        message = "[Hairballs] Seems like you're not using Pry *or* IRB."
+        puts "#{message}  Skipping prompt setup."
+      end
+    end
+
+    def set_up_irb_prompt
+      IRB.conf[:PROMPT][irb_name] = @prompt.irb_configuration
+      IRB.conf[:PROMPT_MODE] = irb_name
+      IRB.CurrentContext.prompt_mode = irb_name if IRB.CurrentContext
+    end
+
+    def set_up_pry_prompt
+      if @prompt.normal && @prompt.continued_statement
+        ::Pry.config.prompt = [
+          proc { @prompt.normal }, proc { @prompt.continued_statement }
+        ]
+      elsif @prompt.normal
+        ::Pry.config.prompt = -> { @prompt.normal }
+      else
+        vputs 'Neither "normal" nor "continued_statement" prompts configured.'
+      end
+    end
+
+    def set_up_pry_printer
+      puts "@pompt return format: #{@prompt.return_format}"
+      if @prompt.return_format
+        Pry.config.print = proc do |output, value|
+          output.printf @prompt.return_format, value.inspect
+        end
+      else
+        vputs '"return_format" not configured.'
+      end
+    end
+  end
+end

data/lib/hairballs/themes/turboladen.rb

@@ -0,0 +1,34 @@
+require_relative '../../hairballs'
+
+Hairballs.add_theme(:turboladen) do |theme|
+  theme.libraries do
+    libs_to_require = %w(
+      irb/completion
+      looksee
+      colorize
+    )
+
+    libs_to_require +
+      case RUBY_PLATFORM
+      when /mswin32|mingw32/
+        %w(win32console)
+      when /darwin/
+        %w(terminal-notifier)
+      else
+        []
+      end
+  end
+
+  theme.prompt do |prompt|
+    preface = proc do |status = '  '|
+      "⟪#{Hairballs.project_name.light_blue}⟫#{status}%03n"
+    end
+
+    prompt.auto_indent = true
+    prompt.normal = "#{preface.call}:%i> "
+    prompt.continued_string = "#{preface.call('❊%l'.yellow)}:%i> "
+    prompt.continued_statement = "#{preface.call('❊?'.yellow)}:%i> "
+    prompt.indented_code = "#{preface.call('✚ '.yellow)}:%i> "
+    prompt.return_format = "➥ %s\n"
+  end
+end

data/lib/hairballs/themes/turboladen_rails.rb

@@ -0,0 +1,33 @@
+require_relative '../../hairballs'
+
+Hairballs.add_theme(:turboladen_rails) do |theme|
+  theme.libraries do
+    libs_to_require = %w(
+      irb/completion
+      looksee
+      colorize
+    )
+
+    libs_to_require +
+      case RUBY_PLATFORM
+      when /mswin32|mingw32/
+        %w(win32console)
+      when /darwin/
+        %w(terminal-notifier)
+      else
+        []
+      end
+  end
+
+  theme.extend_bundler = true
+
+  theme.prompt do |prompt|
+    prompt.auto_indent = true
+    preface = Hairballs.project_name.light_blue
+    prompt.normal = "#{preface}> "
+    prompt.continued_string = "#{preface}#{'❊%l'.yellow}> "
+    prompt.continued_statement = "#{preface}#{'⇥'.yellow} %i> "
+    prompt.indented_code = "#{preface}#{'⇥'.yellow} %i> "
+    prompt.return_format = "➥ %s\n"
+  end
+end

data/lib/hairballs/version.rb

@@ -0,0 +1,3 @@
+class Hairballs
+  VERSION = '0.0.1'
+end

data/lib/hairballs.rb

@@ -0,0 +1,113 @@
+require_relative 'hairballs/ext/kernel_vputs'
+require_relative 'hairballs/exceptions'
+require_relative 'hairballs/theme'
+require_relative 'hairballs/plugin'
+require_relative 'hairballs/version'
+
+# Home of the Hairballs DSL for defining and using Themes and Plugins.
+class Hairballs
+  class << self
+    # @return [Hairballs::Theme]
+    attr_reader :current_theme
+
+    # @return [Array<Hairballs::Theme>]
+    def themes
+      @themes ||= []
+    end
+
+    # Builds a new Hairballs::Theme and adds it to the list of `.themes` that
+    # can be used.
+    #
+    # @param name [Symbol] Name to give the new Theme.
+    # @return [Theme]
+    def add_theme(name)
+      theme = Theme.new(name)
+      yield theme
+      themes << theme
+      vputs "Added theme: #{name}"
+
+      theme
+    end
+
+    # Tells IRB to use the Hairballs::Theme of +theme_name+.
+    #
+    # @param theme_name [Symbol] The name of the Theme to use/switch to.
+    def use_theme(theme_name)
+      switch_to = themes.find { |theme| theme.name == theme_name }
+      fail ThemeUseFailure.new(theme_name) unless switch_to
+      vputs "Switched to theme: #{theme_name}"
+
+      switch_to.use!
+      @current_theme = switch_to
+
+      true
+    end
+
+    # All Hairballs::Plugins available to be loaded.
+    #
+    # @return [Array<Hairballs::Plugin>]
+    def plugins
+      @plugins ||= []
+    end
+
+    # All Hairballs::Plugins that have been loaded.
+    #
+    # @return [Array<Hairballs::Plugin>]
+    def loaded_plugins
+      @loaded_plugins ||= []
+    end
+
+    # Builds a new Hairballs::Plugin and adds it to thelist of `.plugins` that
+    # can be used.
+    #
+    # @param name [Symbol]
+    # @param options [Hash] Plugin-dependent options to define.  These get
+    #   passed along the the Hairballs::Plugin object and are used as attributes
+    #   of the plugin.
+    def add_plugin(name, **options)
+      plugin = Plugin.new(name, options)
+      yield plugin
+      plugins << plugin
+      vputs "Added plugin: #{name}"
+
+      plugin
+    end
+
+    # Searches for the Hairballs::Plugin by the +plugin_name+, then loads it.
+    # Raises
+    # @param plugin_name [Symbol]
+    def load_plugin(plugin_name, **options)
+      plugin_to_use = plugins.find { |plugin| plugin.name == plugin_name }
+      fail PluginNotFound.new(plugin_name) unless plugin_to_use
+      vputs "Using plugin: #{plugin_name}"
+
+      plugin_to_use.load!(options)
+      loaded_plugins << plugin_to_use
+
+      true
+    end
+
+    # Name of the relative directory.
+    #
+    # @return [String]
+    def project_name
+      @project_name ||= File.basename(Dir.pwd)
+    end
+
+    # Is IRB getting loaded for a rails console?
+    #
+    # @return [Boolean]
+    def rails?
+      ENV.has_key?('RAILS_ENV') || !!defined?(Rails)
+    end
+
+    # Used for maintaining all possible completion Procs, thus allowing many
+    # different plugins to define a Proc for completion without overriding Procs
+    # defined for other plugins.
+    #
+    # @return [Array<Proc>]
+    def completion_procs
+      @completion_procs ||= []
+    end
+  end
+end

data/spec/hairballs_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+require 'hairballs'
+
+describe Hairballs do
+  subject { described_class }
+
+  describe '.themes' do
+    subject { described_class.themes }
+    it { is_expected.to be_an Array }
+  end
+
+  describe '.add_theme' do
+    let(:theme) { double 'Hairballs::Theme' }
+    context 'block given and name param is a Symbol' do
+      before do
+        expect(Hairballs::Theme).to receive(:new).with(:test).and_return theme
+      end
+
+      it 'yields the Theme' do
+        expect { |b| subject.add_theme(:test, &b) }.to yield_with_args(theme)
+      end
+
+      it 'adds the Theme to @themes' do
+        expect(subject.themes).to receive(:<<).with(theme)
+        subject.add_theme(:test) { |_| }
+      end
+
+      it 'returns the Theme' do
+        expect(subject.add_theme(:test) { |_| }).to eq theme
+      end
+    end
+
+    context 'no block given' do
+      before do
+        allow(Hairballs::Theme).to receive(:new).and_return theme
+      end
+
+      it 'raises a LocalJumpError' do
+        expect { subject.add_theme(:test) }.to raise_exception(LocalJumpError)
+      end
+    end
+  end
+
+  describe '.use_theme' do
+    let(:theme) { double 'Hairballs::Theme', name: :test }
+
+    context 'theme_name represents an added theme' do
+      before(:example) do
+        expect(subject.themes).to receive(:find).and_return theme
+      end
+
+      it 'does not raise a ThemeUseFailure' do
+        allow(theme).to receive(:use!)
+
+        expect do
+          subject.use_theme(:test)
+        end.to_not raise_exception
+      end
+
+      it 'tells the theme to #use!' do
+        expect(theme).to receive(:use!)
+        subject.use_theme(:test)
+      end
+
+      it 'sets @current_theme to the new theme' do
+        allow(theme).to receive(:use!)
+
+        expect { subject.use_theme(:test) }.
+          to change { subject.instance_variable_get(:@current_theme) }.
+          to(theme)
+      end
+    end
+
+    context 'theme_name does not represent an added theme' do
+      it 'raises a ThemeUseFailure' do
+        expect do
+          described_class.use_theme(:meow)
+        end.to raise_exception(Hairballs::ThemeUseFailure)
+      end
+    end
+  end
+
+  describe '.plugins' do
+    subject { described_class.plugins }
+    it { is_expected.to be_an Array }
+  end
+
+  describe '.loaded_plugins' do
+    subject { described_class.loaded_plugins }
+    it { is_expected.to be_an Array }
+  end
+
+  describe '.add_plugin' do
+    let(:plugin) { double 'Hairballs::Plugin' }
+
+    context 'block given and name param is a Symbol' do
+      before do
+        expect(Hairballs::Plugin).to receive(:new).with(:test, {}).and_return plugin
+      end
+
+      it 'yields the Plugin' do
+        expect { |b| subject.add_plugin(:test, &b) }.to yield_with_args(plugin)
+      end
+
+      it 'adds the Plugin to @plugins' do
+        expect(subject.plugins).to receive(:<<).with(plugin)
+        subject.add_plugin(:test) { |_| }
+      end
+
+      it 'returns the Plugin' do
+        expect(subject.add_plugin(:test) { |_| }).to eq plugin
+      end
+    end
+
+    context 'no block given' do
+      before do
+        allow(Hairballs::Plugin).to receive(:new).and_return plugin
+      end
+
+      it 'raises a LocalJumpError' do
+        expect { subject.add_plugin(:test) }.to raise_exception(LocalJumpError)
+      end
+    end
+  end
+
+  describe '.load_plugin' do
+    let(:plugin) { double 'Hairballs::Plugin', name: :test }
+
+    context 'theme_name represents an added plugin' do
+      before(:example) do
+        expect(subject.plugins).to receive(:find).and_return plugin
+      end
+
+      it 'does not raise an exception' do
+        allow(plugin).to receive(:load!)
+
+        expect do
+          subject.load_plugin(:test)
+        end.to_not raise_exception
+      end
+
+      it 'tells the plugin to #load!' do
+        expect(plugin).to receive(:load!)
+        subject.load_plugin(:test)
+      end
+
+      it 'updates @loaded_plugins with the new theme' do
+        allow(plugin).to receive(:load!)
+
+        expect { subject.load_plugin(:test) }.
+          to change { subject.loaded_plugins.size }.
+          by(1)
+      end
+    end
+
+    context 'plugin_name does not represent an added plugin' do
+      it 'raises a PluginNotFound' do
+        expect do
+          described_class.load_plugin(:meow)
+        end.to raise_exception(Hairballs::PluginNotFound)
+      end
+    end
+  end
+
+  describe '.project_name' do
+    subject { described_class.project_name }
+    it { is_expected.to eq 'hairballs' }
+  end
+
+  describe '.rails?' do
+    subject { described_class.rails? }
+
+    context 'not using Rails' do
+      it { is_expected.to eq false }
+    end
+
+    context 'using Rails' do
+      context 'RAILS_ENV is defined' do
+        before { ENV['RAILS_ENV'] = 'blargh' }
+        after { ENV.delete('RAILS_ENV') }
+        it { is_expected.to eq true }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+$:.unshift(File.expand_path('../lib/hairballs', File.dirname(__FILE__)))
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  # config.filter_run :focus
+  # config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  # config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  # if config.files_to_run.one?
+  #   # Use the documentation formatter for detailed output,
+  #   # unless a formatter has already been configured
+  #   # (e.g. via a command-line flag).
+  #   config.default_formatter = 'doc'
+  # end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 3
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  # Kernel.srand config.seed
+end