scide 0.0.12 → 0.1.0

data/spec/config_spec.rb

@@ -1,113 +0,0 @@
-require 'helper'
-require 'fileutils'
-
-describe Scide::Config do
-
-  it "should use the default config file if not given" do
-    conf = Scide::Config.new
-    conf.file.should == Scide::Config::DEFAULT_CONFIG_FILE
-  end
-
-  it "should use the given config file" do
-    conf = Scide::Config.new '/tmp/fubar'
-    conf.file.should == '/tmp/fubar'
-  end
-
-  it "should be empty when not loaded" do
-    conf = Scide::Config.new
-    conf.screen.should be_nil
-    conf.global.should be_nil
-    conf.projects.should be_nil
-  end
-
-  it "should be filled when loaded" do
-    file = File.join File.dirname(__FILE__), 'results', 'config1.yml'
-    conf = Scide::Config.new file
-    make_load conf
-    conf.screen.should be_a(HashWithIndifferentAccess)
-    conf.global.should be_a(Scide::Global)
-    conf.projects.should be_a(HashWithIndifferentAccess)
-    conf.projects[:project1].should be_a(Scide::Project)
-  end
-
-  [ true, false ].each do |exit_on_fail|
-    describe "Errors with exit on fail #{exit_on_fail}" do
-      before :each do
-        Scide.exit_on_fail = exit_on_fail
-      end
-
-      after :each do
-        Scide.exit_on_fail = true
-      end
-      
-      it SpecHelper.should_fail(exit_on_fail, :config_not_found, "when the config file does not exist") do
-        bad_file = "/tmp/IHateYouIfYouAddedThisFileJustToMakeMyTestFail"
-        conf = Scide::Config.new bad_file
-        load_should_fail(conf, :config_not_found)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :config_not_readable, "if the config file is not readable") do
-        unreadable_file = Tempfile.new 'scide-unreadable'
-        FileUtils.chmod 0200, unreadable_file.path
-        conf = Scide::Config.new unreadable_file.path
-        load_should_fail(conf, :config_not_readable)
-        unreadable_file.unlink
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :unexpected, "if the config file cannot be read") do
-        file = File.join File.dirname(__FILE__), 'results', 'config1.yml'
-        conf = Scide::Config.new file
-        conf.stub!(:load_config){ raise 'bug' }
-        load_should_fail(conf, :unexpected)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :malformed_config, "if the config file is not valid YAML") do
-        file = File.join File.dirname(__FILE__), 'results', 'malformed_config.yml'
-        conf = Scide::Config.new file
-        load_should_fail(conf, :malformed_config)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :invalid_config, "if the configuration is not a hash") do
-        conf = Scide::Config.new
-        conf.stub!(:check_config){}
-        conf.stub!(:load_config){ "- 'a'\n- 'b'" }
-        load_should_fail(conf, :invalid_config)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :invalid_config, "if the screen configuration is not a hash") do
-        conf = Scide::Config.new
-        conf.stub!(:check_config){}
-        conf.stub!(:load_config){ "screen:\n- 'a'\n- 'b'" }
-        load_should_fail(conf, :invalid_config)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :invalid_config, "if the projects configuration is not a hash") do
-        conf = Scide::Config.new
-        conf.stub!(:check_config){}
-        conf.stub!(:load_config){ "projects:\n- 'a'\n- 'b'" }
-        load_should_fail(conf, :invalid_config)
-      end
-
-      it SpecHelper.should_fail(exit_on_fail, :invalid_config, "if the configuration is otherwise invalid") do
-        conf = Scide::Config.new
-        conf.stub!(:check_config){}
-        conf.stub!(:load_config){ "global:\n  a: true\nprojects:\n  a:\n    - 'a'\n    - 'b'" }
-        load_should_fail(conf, :invalid_config)
-      end
-    end
-  end
-
-  private
-
-  def make_load conf
-    SpecHelper.silence{ conf.load! }
-  end
-
-  def load_should_fail conf, condition
-    if Scide.exit_on_fail
-      lambda{ make_load conf }.should raise_error(SystemExit){ |err| err.status.should == Scide::EXIT[condition] }
-    else
-      lambda{ make_load conf }.should raise_error(Scide::Error){ |err| err.condition.should == condition }
-    end
-  end
-end

data/spec/global_spec.rb

@@ -1,38 +0,0 @@
-require 'helper'
-
-describe Scide::Global do
-
-  it "should take the given path if absolute" do
-    global = Scide::Global.new :path => '/tmp'
-    global.path.should == '/tmp'
-  end
-
-  it "should expand the given path from the home directory if relative" do
-    global = Scide::Global.new :path => 'fubar'
-    global.path.should == File.join(File.expand_path('~'), 'fubar')
-  end
-
-  it "should use the home directory if no path is given" do
-    global = Scide::Global.new({})
-    global.path.should == File.expand_path('~')
-  end
-
-  it "should duplicate the given options" do
-    options = { :a => 1, :b => true }
-    global = Scide::Global.new :options => options
-    global.options.should == options
-    global.options.should_not equal(options)
-  end
-
-  it "should raise an error if the contents are not a hash" do
-    [ nil, '   ', [] ].each do |not_hash|
-      lambda{ Scide::Global.new not_hash }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "should raise an error if its options are not nil and not a hash" do
-    [ '   ', [] ].each do |not_hash|
-      lambda{ Scide::Global.new :options => not_hash }.should raise_error(ArgumentError)
-    end
-  end
-end

data/spec/opts_spec.rb

@@ -1,42 +0,0 @@
-require 'helper'
-
-describe Scide::Opts do
-
-  before :each do
-    @opts = Scide::Opts.new
-  end
-  
-  it "should add the help flag" do
-    [ '-h', '--help' ].each do |flag|
-      lambda{ parse!([flag]) }.should raise_error(SystemExit){ |err| err.status.should == 0 }
-    end
-  end
-
-  it "should add the usage flag" do
-    [ '-u', '--usage' ].each do |flag|
-      lambda{ parse!([flag]) }.should raise_error(SystemExit){ |err| err.status.should == 0 }
-    end
-  end
-
-  it "should add the version flag" do
-    expected_version = File.open(File.join(File.dirname(__FILE__), '..', 'VERSION'), 'r').read
-    lambda{ parse!([ '--version' ]) }.should raise_error(SystemExit){ |err| err.status.should == 0 }
-  end
-
-  it "should add the dry run flag" do
-    parse!([ '--dry-run' ])
-    @opts.funnel[:'dry-run'].should == true
-  end
-
-  it "should exit with status 2 for unknown arguments" do
-    [ '-x', '--fubar', '-4' ].each do |unknown|
-      lambda{ parse!([unknown]) }.should raise_error(SystemExit){ |err| err.status.should == 2 }
-    end
-  end
-
-  private
-
-  def parse! args
-    silence_stream(STDOUT){ silence_stream(STDERR){ @opts.parse! args } }
-  end
-end

data/spec/project_spec.rb

@@ -1,171 +0,0 @@
-require 'helper'
-
-describe Scide::Project do
-  
-  before :each do
-    @path = '/tmp'
-    @options = { :a => 1, :b => true }
-    @global = double('global')
-    @global.stub(:path){ @path }
-    @global.stub(:options){ @options }
-  end
-
-  it "should add the project key to the global path by default" do
-    pro = Scide::Project.new @global, 'fubar', :windows => []
-    pro.path.should == File.join(@path, pro.key)
-  end
-
-  it "should add its path to the global path if relative" do
-    pro = Scide::Project.new @global, 'fubar', :windows => [], :path => 'foo'
-    pro.path.should == File.join(@path, 'foo')
-  end
-
-  it "should use its path if absolute" do
-    pro = Scide::Project.new @global, 'fubar', :windows => [], :path => '/foo'
-    pro.path.should == '/foo'
-  end
-
-  it "should use its path if there is no global path" do
-    global_no_path = double('global')
-    global_no_path.stub(:path){ nil }
-    global_no_path.stub(:options){ { :a => 1, :b => true } }
-    pro = Scide::Project.new global_no_path, 'fubar', :windows => [], :path => '/foo'
-    pro.path.should == '/foo'
-  end
-
-  it "should expand its path if relative" do
-    global_relative = double('global')
-    global_relative.stub(:path){ nil }
-    global_relative.stub(:options){ { :a => 1, :b => true } }
-    pro = Scide::Project.new global_relative, 'fubar', :windows => []
-    pro.path.should == File.join(File.expand_path('~'), 'fubar')
-  end
-
-  it "should duplicate global options" do
-    @global.should_receive :path
-    @global.should_receive :options
-    pro = Scide::Project.new @global, 'fubar', :windows => []
-    pro.options.should_not equal(@options)
-  end
-
-  it "should add name and path to options" do
-    additional_options = { :name => 'fubar', :path => File.join(@path, 'fubar') }
-    pro = Scide::Project.new @global, 'fubar', :windows => []
-    pro.options.should == @options.merge(additional_options)
-  end
-
-  it "should override global name and path" do
-    global_with_name_and_path = double('global')
-    global_with_name_and_path.stub(:path){ @path }
-    global_with_name_and_path.stub(:options){ { :name => 'global', :path => '/global' } }
-    pro = Scide::Project.new global_with_name_and_path, 'fubar', :windows => []
-    pro.options[:name].should_not == 'global'
-    pro.options[:path].should_not == '/global'
-  end
-
-  it "should merge given options" do
-    additional_options = { :name => 'fubar', :path => File.join(@path, 'fubar') }
-    new_options = { :name => 'fubar2', :path => '/tmp2', :b => false, :c => 'foo' }
-    pro = Scide::Project.new @global, 'fubar', :windows => [], :options => new_options
-    pro.options.should == @options.merge(additional_options).merge(new_options)
-  end
-
-  describe 'Sample Configuration' do
-    before :each do
-      @contents = {
-        :windows => [
-          'window1 EDIT',
-          { :name => 'window2', :command => 'SHOW', :contents => 'ssh example.com' },
-          'window3 TAIL file.txt',
-          { :string => 'window4 RUN ls -la' },
-          'window5'
-        ],
-        :default_window => :window4
-      }
-      @project = Scide::Project.new @global, 'fubar', @contents
-    end
-
-    it "should create five windows" do
-      @project.windows.length.should == 5
-      @project.windows.each{ |w| w.should be_a(Scide::Window) }
-    end
-
-    it "should create the correct commands" do
-      @project.windows[0].command.should be_a(Scide::Commands::Edit)
-      @project.windows[1].command.should be_a(Scide::Commands::Show)
-      @project.windows[2].command.should be_a(Scide::Commands::Tail)
-      @project.windows[3].command.should be_a(Scide::Commands::Run)
-      @project.windows[4].command.should be_nil
-    end
-
-    it "should find the correct default window" do
-      @project.default_window.should == @project.windows[3]
-    end
-
-    it "should create the correct GNU Screen configuration" do
-      @project.to_screen.should == SpecHelper.result(:project1)
-    end
-
-    describe 'Default Window' do
-      before :each do
-        @default_window_contents = @contents.dup
-      end
-
-      it "should find the default window with a fixnum" do
-        @default_window_contents[:default_window] = 0
-        project = Scide::Project.new(@global, 'fubar', @default_window_contents)
-        project.default_window.should == project.windows[0]
-      end
-
-      it "should find the default window with a negative fixnum" do
-        @default_window_contents[:default_window] = -4
-        project = Scide::Project.new(@global, 'fubar', @default_window_contents)
-        project.default_window.should == project.windows[1]
-      end
-
-      it "should find the default window with a string" do
-        @default_window_contents[:default_window] = 'window3'
-        project = Scide::Project.new(@global, 'fubar', @default_window_contents)
-        project.default_window.should == project.windows[2]
-      end
-
-      it "should find the default window with a symbol" do
-        @default_window_contents[:default_window] = :window5
-        project = Scide::Project.new(@global, 'fubar', @default_window_contents)
-        project.default_window.should == project.windows[4]
-      end
-
-      it "should raise an error if the default window is not a fixnum, string or symbol" do
-        [ [], {}, 0.4 ].each do |invalid|
-          @default_window_contents[:default_window] = invalid
-          lambda{ Scide::Project.new @global, 'fubar', @default_window_contents }.should raise_error(ArgumentError)
-        end
-      end
-
-      it "should raise an error if the default window is unknown" do
-        [ 'unknown', :unknown, -10, -6, 5, 10 ].each do |invalid|
-          @default_window_contents[:default_window] = invalid
-          lambda{ Scide::Project.new @global, 'fubar', @default_window_contents }.should raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  it "should raise an error if the contents are not a hash" do
-    [ nil, '   ', [] ].each do |not_hash|
-      lambda{ Scide::Project.new @global, 'fubar', not_hash }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "should raise an error if its windows are nil or not an array" do
-    [ nil, '   ', {} ].each do |not_array|
-      lambda{ Scide::Project.new @global, 'fubar', :windows => not_array }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "should raise an error if its options are not nil and not a hash" do
-    [ '   ', [] ].each do |not_hash|
-      lambda{ Scide::Project.new @global, 'fubar', :windows => [], :options => not_hash }.should raise_error(ArgumentError)
-    end
-  end
-end

data/spec/results/config1.yml

@@ -1,14 +0,0 @@
-screen:
-  hardstatus: 'dummy'
-global:
-  path: '/tmp'
-projects:
-  project1:
-    windows:
-      - 'window1 EDIT'
-      - name: 'window2'
-        command: 'SHOW'
-        contents: 'ssh example.com'
-      - 'window3 TAIL file.txt'
-      - string: 'window4 RUN ls -la'
-      - 'window5'

data/spec/results/malformed_config.yml

@@ -1,2 +0,0 @@
-bad:
-	- yaml

data/spec/results/project1.screen

@@ -1,10 +0,0 @@
-screen -t window1 0
-stuff "$EDITOR\012"
-screen -t window2 1
-stuff "ssh example.com"
-screen -t window3 2
-stuff "tail -f file.txt\012"
-screen -t window4 3
-stuff "ls -la\012"
-screen -t window5 4
-select window4

data/spec/results/screen1.screen

@@ -1,14 +0,0 @@
-startup_message off
-hardstatus on
-hardstatus alwayslastline
-hardstatus string 'dummy'
-
-screen -t window1 0
-stuff "$EDITOR\012"
-screen -t window2 1
-stuff "ssh example.com"
-screen -t window3 2
-stuff "tail -f file.txt\012"
-screen -t window4 3
-stuff "ls -la\012"
-screen -t window5 4

data/spec/scide_spec.rb

@@ -1,38 +0,0 @@
-require 'helper'
-
-describe Scide do
-
-  before :each do
-    Scide.exit_on_fail = true
-  end
-
-  after :each do
-    Scide.exit_on_fail = true
-  end
-  
-  it "should have the correct version" do
-    Scide::VERSION.should == File.open(File.join(File.dirname(__FILE__), '..', 'VERSION'), 'r').read
-  end
-
-  it "should exit on fail by default" do
-    lambda{ SpecHelper.silence{ Scide.fail nil, 'fubar' } }.should raise_error(SystemExit)
-  end
-
-  it "should exit with the correct status code" do
-    Scide::EXIT.each_pair do |condition,code|
-      lambda{ SpecHelper.silence{ Scide.fail condition, 'fubar' } }.should raise_error(SystemExit){ |err| err.status.should == code }
-    end
-  end
-
-  it "should raise an error on fail if configured to do so" do
-    Scide.exit_on_fail = false
-    lambda{ Scide.fail nil, 'fubar' }.should raise_error(Scide::Error)
-  end
-
-  it "should raise an error with the correct condition" do
-    Scide.exit_on_fail = false
-    Scide::EXIT.each_pair do |condition,code|
-      lambda{ Scide.fail condition, 'fubar' }.should raise_error(Scide::Error){ |err| err.condition.should == condition }
-    end
-  end
-end

data/spec/screen_spec.rb

@@ -1,90 +0,0 @@
-require 'helper'
-
-describe Scide::Screen do
-
-  before :each do
-    @project = double('project')
-    @project.stub(:path){ '/tmp' }
-    @project.stub(:to_screen){ 'fubar' }
-  end
-
-  it "should generate a command to run screen at the given project's path" do
-    screen = Scide::Screen.new(@project, {})
-    @project.should_receive :path
-    screen.to_command('fubar').should == 'cd /tmp && screen -c fubar'
-  end
-
-  it "should generate a command to run screen with the given options" do
-    screen = Scide::Screen.new @project, :binary => '/usr/bin/screen', :args => '-U'
-    @project.should_receive :path
-    screen.to_command('fubar').should == 'cd /tmp && /usr/bin/screen -U -c fubar'
-  end
-
-  it "should generate a screen configuration file" do
-    global = double('global')
-    global.stub(:path){ nil }
-    global.stub(:options){ {} }
-    contents = {
-      :windows => [
-        'window1 EDIT',
-        { :name => 'window2', :command => 'SHOW', :contents => 'ssh example.com' },
-        'window3 TAIL file.txt',
-        { :string => 'window4 RUN ls -la' },
-        'window5'
-      ]
-    }
-    project = Scide::Project.new(global, 'fubar', contents)
-    screen = Scide::Screen.new project, :hardstatus => 'dummy'
-    screen.to_s.should == SpecHelper.result(:screen1)
-  end
-
-  it "should use the default hardstatus line if not given" do
-    screen = Scide::Screen.new(@project, {})
-    screen.hardstatus.should == Scide::Screen::DEFAULT_HARDSTATUS
-  end
-
-  it "should use the given hardstatus line" do
-    screen = Scide::Screen.new @project, :hardstatus => 'fubar'
-    screen.hardstatus.should == 'fubar'
-  end
-
-  it "should use the default binary if not given" do
-    screen = Scide::Screen.new(@project, {})
-    screen.binary.should == 'screen'
-  end
-
-  it "should use the given binary" do
-    screen = Scide::Screen.new @project, :binary => '/usr/bin/screen'
-    screen.binary.should == '/usr/bin/screen'
-  end
-
-  it "should use the given args" do
-    screen = Scide::Screen.new @project, :args => '-U'
-    screen.args.should == '-U'
-  end
-
-  it "should duplicate the given options" do
-    options = { :a => 1, :b => true }
-    screen = Scide::Screen.new @project, options
-    screen.options.should == options
-    screen.options.should_not equal(options)
-  end
-
-  it "should not raise any error if the screen binary is found" do
-    screen = '/usr/bin/screen'
-    Which.stub!(:which){ |name| screen } unless File.executable?(screen)
-    lambda{ SpecHelper.silence{ Scide::Screen.new(@project, :binary => screen).check_binary } }.should_not raise_error
-  end
-
-  it "should exit with status 4 if the screen binary is not found" do
-    bad_binary = "unknown"
-    Which.stub!(:which){ |name| nil }
-    lambda{ SpecHelper.silence{ Scide::Screen.new(@project, :binary => bad_binary).check_binary } }.should raise_error(SystemExit){ |err| err.status.should == 4 }
-  end
-
-  it "should raise an error if the options are not nil and not a hash" do
-    [ '   ', [] ].each do |not_hash|
-      lambda{ Scide::Screen.new @project, not_hash }.should raise_error(ArgumentError)
-    end
-  end
-end

data/spec/window_spec.rb

@@ -1,122 +0,0 @@
-require 'helper'
-
-describe Scide::Window do
-
-  before :each do
-    @options = { :a => 1, :b => true }
-    @project = double('project')
-    @project.stub(:options){ @options }
-  end
-
-  describe "String Initialization" do
-    it "should take the given name" do
-      win = Scide::Window.new @project, 'fubar'
-      win.name.should == 'fubar'
-    end
-
-    it "should create the correct command" do
-      win = Scide::Window.new @project, 'fubar EDIT'
-      win.command.should be_a(Scide::Commands::Edit)
-    end
-
-    it "should be initializable with a name and a command with no contents" do
-      lambda{ Scide::Window.new @project, 'fubar EDIT' }.should_not raise_error(ArgumentError)
-    end
-
-    it "should be initializable with a name and a command with contents" do
-      lambda{ Scide::Window.new @project, 'fubar TAIL file.txt' }.should_not raise_error(ArgumentError)
-    end
-
-    it "should raise an error when initialized without a name" do
-      lambda{ Scide::Window.new @project, '   ' }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error for unknown commands" do
-      lambda{ Scide::Window.new @project, 'fubar EDT' }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "Hash Initialization" do
-    it "should take the given name" do
-      win = Scide::Window.new @project, :name => 'fubar'
-      win.name.should == 'fubar'
-    end
-
-    it "should create the correct command" do
-      win = Scide::Window.new @project, :name => 'fubar', :command => 'EDIT'
-      win.command.should be_a(Scide::Commands::Edit)
-    end
-
-    it "should be initializable with a name and a command with no contents" do
-      lambda{ Scide::Window.new @project, :name => 'fubar', :command => 'EDIT' }.should_not raise_error(ArgumentError)
-    end
-
-    it "should be initializable with a name and a command with contents" do
-      lambda{ Scide::Window.new @project, :name => 'fubar', :command => 'EDIT', :contents => 'file.txt' }.should_not raise_error(ArgumentError)
-    end
-
-    it "should raise an error when initialized without a name" do
-      lambda{ Scide::Window.new @project, :fubar => true }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error for unknown commands" do
-      lambda{ Scide::Window.new @project, :name => 'fubar', :command => 'EDT' }.should raise_error(ArgumentError)
-    end
-
-    describe "String Option" do
-      
-      it "should take the given name" do
-        win = Scide::Window.new @project, :string => 'fubar'
-        win.name.should == 'fubar'
-      end
-
-      it "should create the correct command" do
-        win = Scide::Window.new @project, :string => 'fubar EDIT'
-        win.command.should be_a(Scide::Commands::Edit)
-      end
-
-      it "should be initializable with a name and a command with no contents" do
-        lambda{ Scide::Window.new @project, :string => 'fubar EDIT' }.should_not raise_error(ArgumentError)
-      end
-
-      it "should be initializable with a name and a command with contents" do
-        lambda{ Scide::Window.new @project, :string => 'fubar EDIT file.txt' }.should_not raise_error(ArgumentError)
-      end
-
-      it "should raise an error when initialized without a name" do
-        lambda{ Scide::Window.new @project, :string => '   ' }.should raise_error(ArgumentError)
-      end
-
-      it "should raise an error for unknown commands" do
-        lambda{ Scide::Window.new @project, :string => 'fubar EDT' }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  it "should raise an error when type of contents is unknown" do
-    lambda{ Scide::Window.new(@project, []) }.should raise_error(ArgumentError)
-  end
-
-  it "should duplicate project options" do
-    @project.should_receive :options
-    win = Scide::Window.new @project, 'fubar'
-    win.options.should == @options
-    win.options.should_not equal(@options)
-  end
-
-  it "should merge its options to project options" do
-    window_options = { :b => false, :c => 'foo' }
-    @project.should_receive :options
-    win = Scide::Window.new @project, :name => 'fubar', :options => window_options
-    win.options.should == @options.merge(window_options)
-  end
-
-  it "should generate a GNU Screen window" do
-    # without a command, hash initialization
-    win = Scide::Window.new @project, :name => 'fubar'
-    win.to_screen(0).should == 'screen -t fubar 0'
-    # with a command, string initialization
-    win = Scide::Window.new @project, 'fubar EDIT file.txt'
-    win.to_screen(0).should == %|screen -t fubar 0\n#{win.command.to_screen}|
-  end
-end