scide 0.0.12 → 0.1.0

data/spec/cli/setup_spec.rb

@@ -0,0 +1,82 @@
+require 'helper'
+
+describe 'scide setup' do
+
+  let(:argv){ [ 'setup' ] }
+  let(:expected_args){ [] }
+  let(:expected_options){ {} }
+  let(:expected_output){ '' }
+
+  before :each do
+    Scide.stub :setup
+    Scide.stub(:list).and_raise(StandardError.new('list should not be called'))
+    Scide.stub(:open).and_raise(StandardError.new('open should not be called'))
+  end
+
+  shared_examples_for "setup" do
+
+    let(:config_file){ '~/some/.screenrc' }
+    let(:expected_output){ config_file }
+
+    it "should output the path to the created file" do
+      Scide.stub setup: '~/some/.screenrc'
+      expect_success
+    end
+
+    context "if it fails" do
+     
+      before :each do
+        Scide.stub(:setup).and_raise(Scide::Error.new('fubar'))
+      end
+
+      it "should output the error to stderr" do
+        expect_failure "fubar#{Scide::Program::BACKTRACE_NOTICE}"
+      end
+
+      context "with the trace option" do
+        
+        let(:argv){ super().unshift '--trace' }
+
+        it "should raise the error" do
+          expect_failure "fubar", true
+        end
+      end
+    end
+  end
+
+  it_behaves_like "setup"
+
+  [ '-p', '--projects' ].each do |opt|
+    context "with the #{opt} option" do
+      let(:projects_dir){ '~/Projects' }
+      let(:expected_options){ { projects: projects_dir } }
+      let(:argv){ super() + [ opt, projects_dir ] }
+      it_behaves_like "setup"
+    end
+  end
+
+  def expect_success output = nil
+    args = expected_args + (expected_options.empty? ? [] : [ expected_options ])
+    Scide.should_receive(:setup).with *args
+    program = Scide::Program.new argv
+    stdout, stderr = StringIO.new, StringIO.new
+    $stdout, $stderr = stdout, stderr
+    expect{ program.run! }.to_not raise_error
+    $stdout, $stderr = STDOUT, STDERR
+    expect(Paint.unpaint(stdout.string.chomp "\n")).to eq(output || expected_output)
+    expect(stderr.string).to be_empty
+  end
+
+  def expect_failure message, expect_raise = false, code = 1, &block
+    program = Scide::Program.new argv
+    if expect_raise
+      expect{ program.run! }.to raise_error(Scide::Error){ |e| expect(e.message).to eq(message) }
+    else
+      stderr = StringIO.new
+      $stderr = stderr
+      expect{ program.run! }.to raise_error(SystemExit){ |e| expect(e.status).to eq(code) }
+      $stderr = STDERR
+      expect(Paint.unpaint(stderr.string.strip)).to eq(message)
+    end
+  end
+end

data/spec/helper.rb

@@ -2,12 +2,6 @@ require 'rubygems'
 require 'bundler'
 require 'simplecov'
 
-# to silence streams
-require 'active_support/core_ext/kernel/reporting'
-
-# test coverage
-SimpleCov.start
-
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -17,31 +11,25 @@ rescue Bundler::BundlerError => e
 end
 
 require 'rspec'
-require 'shoulda'
+require 'fakefs/spec_helpers'
 
-class SpecHelper
-  def self.result name
-    File.open(File.join(File.dirname(__FILE__), 'results', "#{name}.screen"), 'r').read
+RSpec.configure do |config|
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
   end
 
-  def self.silence
-    silence_stream(STDOUT) do
-      silence_stream(STDERR) do
-        yield
-      end
-    end
+  config.before :suite do
+    ENV.delete_if{ |k,v| k.match /\ASCIDE_/ }
   end
 
-  def self.should_fail exit_on_fail, condition, msg
-    if exit_on_fail
-      "should exit with status #{Scide::EXIT[condition]} #{msg}"
-    else
-      "should raise an error with condition #{condition} #{msg}"
-    end
+  config.after :each do
+    ENV.delete_if{ |k,v| k.match /\ASCIDE_/ }
   end
 end
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+# test coverage
+SimpleCov.start
+
 require 'scide'
 

data/spec/list_spec.rb

@@ -0,0 +1,113 @@
+require 'helper'
+
+describe 'Scide.list' do
+  include FakeFS::SpecHelpers
+
+  let(:default_projects_dir){ File.expand_path('~/src') }
+  let(:custom_projects_dir){ File.expand_path('~/Projects') }
+  let(:env_projects_dir){ nil }
+  let(:options){ {} }
+
+  before :each do
+    FileUtils.mkdir_p File.expand_path('~')
+    ENV['SCIDE_PROJECTS'] = env_projects_dir if env_projects_dir
+  end
+
+  shared_examples_for "listings" do
+
+    it "should fail if the projects directory is a file" do
+      FileUtils.mkdir_p File.dirname(projects_dir)
+      FileUtils.touch projects_dir
+      expect_failure /no such directory/i
+    end
+
+    context "if the projects directory doesn't exist" do
+
+      it "should fail if current directory is the home directory" do
+        Dir.chdir setup('~', false)
+        expect_failure /no such directory/i
+      end
+
+      it "should fail if the current directory isn't a project" do
+        Dir.chdir setup('~/some', false)
+        expect_failure /no such directory/i
+      end
+
+      it "should return the current directory if it's a project" do
+        Dir.chdir setup('~/some')
+        expect(list).to eq([ '.' ])
+      end
+    end
+
+    context "if the projects directory exists" do
+
+      before :each do
+        FileUtils.mkdir_p projects_dir
+      end
+
+      it "should return an empty list if there are no projects" do
+        expect(list).to be_empty
+      end
+
+      it "should return the current directory if it's a project" do
+        Dir.chdir setup('~/some')
+        expect(list).to eq([ '.' ])
+      end
+
+      it "should return the projects with a .screenrc file in the projects directory" do
+        setup File.join(projects_dir, 'a')
+        setup File.join(projects_dir, 'b'), false
+        setup File.join(projects_dir, 'c')
+        setup File.join(projects_dir, 'd')
+        setup File.join(projects_dir, 'e'), false
+        expect(list).to eq([ 'a', 'c', 'd' ])
+      end
+
+      it "should return the projects in the projects directory and the current directory" do
+        Dir.chdir setup('~/some')
+        setup File.join(projects_dir, 'a')
+        setup File.join(projects_dir, 'b')
+        setup File.join(projects_dir, 'c'), false
+        expect(list).to eq([ '.', 'a', 'b' ])
+      end
+
+      it "should not return the projects directory" do
+        setup projects_dir
+        expect(list).to be_empty
+      end
+    end
+  end
+
+  context "with the default projects directory" do
+    let(:projects_dir){ default_projects_dir }
+    it_behaves_like "listings"
+  end
+
+  context "with a custom projects directory set by option" do
+    let(:projects_dir){ custom_projects_dir }
+    let(:options){ { projects: custom_projects_dir } }
+    it_behaves_like "listings"
+  end
+
+  context "with a custom projects directory set by environment variable" do
+    let(:projects_dir){ custom_projects_dir }
+    let(:env_projects_dir){ custom_projects_dir }
+    it_behaves_like "listings"
+  end
+
+  def setup dir, config = true
+    dir = File.expand_path dir
+    FileUtils.mkdir_p dir
+    FileUtils.touch File.join(dir, '.screenrc') if config
+    dir
+  end
+
+  def expect_failure *args, &block
+    block = lambda{ list } unless block
+    expect(&block).to raise_error(Scide::Error){ |e| args.each{ |msg| expect(e.message).to match(msg) } }
+  end
+
+  def list
+    Scide.list options
+  end
+end

data/spec/open_spec.rb

@@ -0,0 +1,228 @@
+require 'helper'
+require 'fileutils'
+
+describe 'Scide.open' do
+  include FakeFS::SpecHelpers
+
+  let(:default_projects_dir){ File.expand_path('~/src') }
+  let(:custom_projects_dir){ File.expand_path('~/Projects') }
+  let(:env_projects_dir){ nil }
+  let(:system_result){ true }
+  let(:name){ nil }
+  let(:options){ {} }
+  let(:open_args){ (name ? [ name ] : []) + (options.empty? ? [] : [ options ]) }
+  let(:expected_screenrc){ Regexp.escape '.screenrc' }
+
+  before :each do
+
+    # for temporary files
+    FileUtils.mkdir_p '/tmp'
+
+    # for which
+    FileUtils.mkdir_p '/usr/bin'
+    FileUtils.touch '/usr/bin/screen'
+    FileUtils.chmod 0755, '/usr/bin/screen'
+
+    # home folder
+    FileUtils.mkdir_p File.expand_path('~')
+
+    ENV['SCIDE_PROJECTS'] = env_projects_dir if env_projects_dir
+
+    Kernel.stub system: system_result
+  end
+
+  it "should fail if screen is not in the path" do
+    Which.stub which: nil
+    expect_failure(/screen must be in the path/i){ Scide.open }
+  end
+
+  it "should fail if more than one project name is given" do
+    expect_failure(/only one project name/i){ Scide.open 'a', 'b' }
+  end
+
+  it "should not open the home directory" do
+    Dir.chdir File.expand_path('~')
+    expect_failure(/home directory/i){ Scide.open }
+  end
+
+  shared_examples_for "a screen wrapper" do
+
+    it "should execute the command" do
+      expect_success /\A#{expected_chdir}screen -U -c #{expected_screenrc}\Z/
+    end
+
+    context "with a custom binary set by option" do
+
+      let(:custom_bin){ '/bin/custom-screen' }
+      let(:options){ super().merge bin: custom_bin }
+
+      it "should execute the command with that binary" do
+        expect_success /\A#{expected_chdir}#{Regexp.escape custom_bin} -U -c #{expected_screenrc}\Z/
+      end
+    end
+
+    context "with a custom binary set by environment variable" do
+
+      let(:custom_bin){ '/bin/custom-screen' }
+      before(:each){ ENV['SCIDE_BIN'] = custom_bin }
+
+      it "should execute the command with that binary" do
+        expect_success /\A#{expected_chdir}#{Regexp.escape custom_bin} -U -c #{expected_screenrc}\Z/
+      end
+    end
+
+    context "with custom screen options set by option" do
+
+      let(:custom_screen){ '-r -x' }
+      let(:options){ super().merge screen: custom_screen }
+
+      it "should execute the command with those options" do
+        expect_success /\A#{expected_chdir}screen -r -x -c #{expected_screenrc}\Z/
+      end
+    end
+
+    context "with custom screen options set by environment variable" do
+
+      let(:custom_screen){ '-r -x' }
+      before(:each){ ENV['SCIDE_SCREEN'] = custom_screen }
+
+      it "should execute the command with those options" do
+        expect_success /\A#{expected_chdir}screen -r -x -c #{expected_screenrc}\Z/
+      end
+    end
+
+    context "with the noop option" do
+      
+      let(:options){ super().merge noop: true }
+
+      it "should print the command" do
+        expect_success false, /\A#{expected_chdir}screen -U -c #{expected_screenrc}\Z/
+      end
+    end
+  end
+
+  context "for a project in the current directory" do
+
+    let(:file){ '/projects/a/.screenrc' }
+    let(:dir){ File.dirname file }
+    before(:each){ Dir.chdir setup(dir, false) }
+
+    it "should fail if there is no configuration file" do
+      expect_failure /no such configuration/i
+    end
+
+    it "should fail if the configuration is not a file" do
+      FileUtils.mkdir_p file
+      expect_failure /not a file/i
+    end
+
+    context "with the auto option" do
+      let(:expected_chdir){ nil }
+      let(:expected_screenrc){ '.+' }
+      let(:options){ super().merge auto: true }
+      it_behaves_like "a screen wrapper"
+    end
+
+    context "if the project is valid" do
+      let(:expected_chdir){ nil }
+      before(:each){ FileUtils.touch file }
+      it_behaves_like "a screen wrapper"
+    end
+  end
+
+  shared_examples_for "a project in a configured directory" do
+
+    it "should fail if the project directory doesn't exist" do
+      expect_failure /no such directory/i
+    end
+
+    it "should fail if the project directory is not a directory" do
+      FileUtils.mkdir_p File.dirname(dir)
+      FileUtils.touch dir
+      expect_failure /no such directory/i
+    end
+
+    it "should fail if there is no configuration file" do
+      setup dir, false
+      expect_failure /no such configuration/i
+    end
+
+    it "should fail if the configuration is not a file" do
+      FileUtils.mkdir_p file
+      expect_failure /not a file/i
+    end
+
+    context "with the auto option" do
+      let(:expected_chdir){ Regexp.escape "cd #{Shellwords.escape dir} && " }
+      let(:expected_screenrc){ '.+' }
+      let(:options){ super().merge auto: true }
+      before(:each){ setup dir, false }
+      it_behaves_like "a screen wrapper"
+    end
+
+    context "if the project is valid" do
+      let(:expected_chdir){ Regexp.escape "cd #{Shellwords.escape dir} && " }
+      before(:each){ setup dir }
+      it_behaves_like "a screen wrapper"
+    end
+  end
+
+  context "for a project in the default project directory" do
+    let(:name){ 'a' }
+    let(:file){ File.join default_projects_dir, name, '.screenrc' }
+    let(:dir){ File.dirname file }
+    it_behaves_like "a project in a configured directory"
+  end
+
+  context "for a project in a custom project directory set by option" do
+    let(:name){ 'a' }
+    let(:file){ File.join custom_projects_dir, name, '.screenrc' }
+    let(:dir){ File.dirname file }
+    let(:options){ { projects: custom_projects_dir } }
+    it_behaves_like "a project in a configured directory"
+  end
+
+  context "for a project in a custom project directory set by environment variable" do
+    let(:name){ 'a' }
+    let(:file){ File.join custom_projects_dir, name, '.screenrc' }
+    let(:dir){ File.dirname file }
+    let(:env_projects_dir){ custom_projects_dir }
+    it_behaves_like "a project in a configured directory"
+  end
+
+  def open
+    Scide.open *open_args
+  end
+
+  def setup dir, config = true
+    dir = File.expand_path dir
+    FileUtils.mkdir_p dir
+    FileUtils.touch File.join(dir, '.screenrc') if config
+    dir
+  end
+
+  def expect_success command, expected_result = nil, &block
+
+    if command
+      Kernel.should_receive(:system).with command
+    else
+      Kernel.should_not_receive(:system)
+    end
+
+    block = lambda{ open } unless block
+
+    result = nil
+    expect{ result = block.call }.to_not raise_error
+
+    if !expected_result
+      expect(result).to be_true if open_args.empty?
+    elsif !command
+      expect(result).to match(expected_result)
+    end
+  end
+
+  def expect_failure *args, &block
+    block = lambda{ open } unless block
+    expect(&block).to raise_error(Scide::Error){ |e| args.each{ |msg| expect(e.message).to match(msg) } }
+  end
+end

data/spec/setup_spec.rb

@@ -0,0 +1,106 @@
+require 'helper'
+
+describe 'Scide.setup' do
+  include FakeFS::SpecHelpers
+
+  let(:default_projects_dir){ File.expand_path('~/src') }
+  let(:custom_projects_dir){ File.expand_path('~/Projects') }
+  let(:env_projects_dir){ nil }
+  let(:expected_contents){ 'foo' }
+  let(:name){ nil }
+  let(:options){ {} }
+  let(:setup_args){ (name ? [ name ] : []) + (options.empty? ? [] : [ options ]) }
+
+  before :each do
+    FileUtils.mkdir_p File.expand_path('~')
+    ENV['SCIDE_PROJECTS'] = env_projects_dir if env_projects_dir
+    Scide.stub auto_config: expected_contents
+  end
+
+  shared_examples_for "setting up" do
+
+    it "should fail if more than one project name is given" do
+      expect_failure(/only one project name/i){ Scide.setup 'a', 'b' }
+    end
+
+    it "should not set up the home directory" do
+      Dir.chdir File.expand_path('~')
+      expect_failure /home directory/i
+    end
+
+    context "the current directory" do
+
+      let(:dir){ '~/some' }
+
+      it "should fail if a .screenrc file already exists" do
+        Dir.chdir setup(dir)
+        expect_failure /already exists/i
+      end
+
+      it "should setup the default configuration" do
+        Dir.chdir setup(dir, false)
+        expect_success File.join(dir, '.screenrc')
+      end
+    end
+
+    context "a project directory" do
+
+      let(:name){ 'a' }
+      let(:project_dir){ File.join projects_dir, name }
+
+      before :each do
+        FileUtils.mkdir_p projects_dir
+      end
+
+      it "should fail if a .screenrc file already exists" do
+        Dir.chdir setup(project_dir)
+        expect_failure /already exists/i
+      end
+
+      it "should setup the default configuration" do
+        Dir.chdir setup(project_dir, false)
+        expect_success File.join(project_dir, '.screenrc')
+      end
+    end
+  end
+
+  context "with the default projects directory" do
+    let(:projects_dir){ default_projects_dir }
+    it_behaves_like "setting up"
+  end
+
+  context "with a custom projects directory set by option" do
+    let(:projects_dir){ custom_projects_dir }
+    let(:options){ { projects: custom_projects_dir } }
+    it_behaves_like "setting up"
+  end
+
+  context "with a custom projects directory set by environment variable" do
+    let(:projects_dir){ custom_projects_dir }
+    let(:env_projects_dir){ custom_projects_dir }
+    it_behaves_like "setting up"
+  end
+
+  def setup dir, config = true
+    dir = File.expand_path dir
+    FileUtils.mkdir_p dir
+    FileUtils.touch File.join(dir, '.screenrc') if config
+    dir
+  end
+
+  def expect_success path, noop = false
+    result = nil
+    expect{ result = do_setup *setup_args }.to_not raise_error
+    expect(result).to eq(File.expand_path(path))
+    expect(File.read(result)).to eq(expected_contents) unless noop
+  end
+
+  def expect_failure *args, &block
+    block = lambda{ do_setup *setup_args } unless block
+    expect(&block).to raise_error(Scide::Error){ |e| args.each{ |msg| expect(e.message).to match(msg) } }
+  end
+
+  def do_setup *args
+    Scide.setup *args
+  end
+end

data/spec/version_spec.rb

@@ -1,8 +1,6 @@
 require 'helper'
 
-describe 'Scide::VERSION' do
-
-  it "should be the correct version" do
-    Scide::VERSION.should == File.open(File.join(File.dirname(__FILE__), '..', 'VERSION'), 'r').read
-  end
+describe 'Version' do
+  subject{ Scide::VERSION }
+  it{ should eq(File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))) }
 end