ruby-screen 0.9.0

data/spec/configuration/description_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RubyScreen::Configuration::Description do
+  before { @configuration = RubyScreen::Configuration::Description.new }
+
+  it "should delegate #to_screen_configuration to Configuration::Generator" do
+    configuration_string = "my configuration string"
+    generator_mock = mock("mock Configuration::Generator")
+    generator_mock.should_receive(:to_screen_configuration).and_return(configuration_string)
+    RubyScreen::Configuration::Generator.should_receive(:new).and_return(generator_mock)
+    @configuration.to_screen_configuration.should equal(configuration_string)
+  end
+
+  describe "customizations" do
+    it "should be able to be added and retrieved" do
+      @configuration.add_customization(:startup_message, "off")
+      @configuration.add_customization(:foo, "bar")
+
+      customizations = @configuration.customizations
+      customizations[:startup_message].should eql("off")
+      customizations[:foo].should eql("bar")
+    end
+
+    it "should overwrite customizations with the same name on subsequent addition" do
+      @configuration.add_customization(:foo, "bar")
+      @configuration.add_customization(:foo, "new value")
+      @configuration.customizations[:foo].should eql("new value")
+    end
+  end
+
+  describe "working_directory" do
+    it "should be nil on initialization" do
+      @configuration.working_directory.should be_nil
+    end
+
+    it "should be able to be set" do
+      @configuration.working_directory = "/my/dir/"
+      @configuration.working_directory.should eql("/my/dir/")
+    end
+
+    it "should call File.expand_path when setting a working_directory that begins with a '~'" do
+      File.should_receive(:expand_path).and_return("from_expand_path")
+      @configuration.working_directory = "~/path"
+      @configuration.working_directory.should eql("from_expand_path")
+    end
+  end
+
+  describe "#append_directory" do
+    it "should properly add directory names to the current working_directory" do
+      @configuration.working_directory = "/first"
+      @configuration.append_directory("second")
+      @configuration.working_directory.should eql("/first/second")
+    end
+
+    it "should handle directories that have leading and/or trailing slashes" do
+      @configuration.working_directory = "/first"
+      @configuration.append_directory("/second")
+      @configuration.working_directory.should eql("/first/second")
+      @configuration.append_directory("third/")
+      @configuration.working_directory.should eql("/first/second/third")
+    end
+
+    it "should work properly when no working_directory has been set" do
+      @configuration.working_directory.should be_nil
+      @configuration.append_directory("second")
+      @configuration.working_directory.should eql("second")
+    end
+
+    it "should correctly handle entries that begin with '~' and call File.expand_path on them" do
+      @configuration.working_directory = "something"
+      File.should_receive(:expand_path).with("~/path").and_return("from_expand_path")
+      @configuration.append_directory("~/path")
+      @configuration.working_directory.should eql("from_expand_path")
+    end
+  end
+
+  describe "windows" do
+    it "should be able to add numberless windows" do
+      @configuration.add_window("title" => "server window", "command" => "script/server")
+      numberless_windows = @configuration.numberless_windows
+      numberless_windows.length.should eql(1)
+      numberless_windows.first["title"].should eql("server window")
+      numberless_windows.first["command"].should eql("script/server")
+    end
+
+    it "should be able to add numbered windows" do
+      @configuration.add_window("title" => "My Window", "number" => 1)
+      numbered_windows = @configuration.numbered_windows
+      numbered_windows.length.should eql(1)
+      numbered_windows[1]["title"].should eql("My Window")
+    end
+  end
+end

data/spec/configuration/generator_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RubyScreen::Configuration::Generator, "#to_screen_configuration" do
+  before do
+    @description = mock("Configuration::Description mock")
+
+    @description.stub!(:customizations).and_return(
+      { :first => "custom", :second => "2" }
+    )
+
+    @description.stub!(:numbered_windows).and_return({
+      0 => { "title" => "misc" },
+      3 => { "title" => "three", "command" => "another command" },
+      9 => { "command" => "final command" }
+    })
+
+    @description.stub!(:numberless_windows).and_return([
+      { "title" => "second" },
+      { "command" => "command-only window" }
+    ])
+
+    @description.stub!(:initial_directory).and_return("initial/directory")
+
+    @original_shell = ENV["SHELL"]
+    ENV["SHELL"] = "/usr/bin/my_shell"
+
+    @configuration_string = RubyScreen::Configuration::Generator.new(@description).to_screen_configuration
+
+    ENV["SHELL"] = @original_shell
+  end
+
+  it "should include top level customizations" do
+    @configuration_string.should match(/first custom/)
+    @configuration_string.should match(/second 2/)
+  end
+
+  it "should include numbered windows" do
+    s1 = "screen -t misc 0"
+    s2 = "screen -t three 3 sh -c \"another command; /usr/bin/my_shell\""
+    s3 = "screen 9 sh -c \"final command; /usr/bin/my_shell\""
+    @configuration_string.should match(/#{s1}\s#{s2}\s#{s3}/)
+  end
+
+  it "should include numberless windows" do
+    n1 = "screen -t second"
+    n2 = "screen sh -c \"command-only window; /usr/bin/my_shell\""
+    @configuration_string.should match(/#{n1}\s#{n2}/)
+  end
+end

data/spec/configuration/parser/block_processor_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe RubyScreen::Configuration::Parser::BlockProcessor do
+  before { @mock_description = mock("Description") }
+
+  after { RubyScreen::Configuration::Parser::BlockProcessor.new(@preferences_hash, @mock_description) }
+
+  it "should call Description#add_window for any window configurations" do
+    @mock_description.should_receive(:add_window).with({ "window1" => "settings1" }).ordered
+    @mock_description.should_receive(:add_window).with({ "window2" => "settings2" }).ordered
+
+    @preferences_hash = {
+      "windows" => [
+        { "window1" => "settings1" },
+        { "window2" => "settings2" }
+      ]
+    }
+  end
+
+  it "should call Description#working_directory for any working_directory settings" do
+    @mock_description = mock("Description")
+    @mock_description.should_receive(:working_directory=).with("dir")
+
+    @preferences_hash = { "working_directory" => "dir" }
+  end
+
+  it "should call Description#append_directory for any relative_directory settings" do
+    @mock_description.should_receive(:append_directory).with("dir")
+
+    @preferences_hash = { "relative_directory" => "dir" }
+  end
+
+  it "should call Description#add_customization for any abritrary settings" do
+    @mock_description.should_receive(:add_customization).with("key1", "val1")
+    @mock_description.should_receive(:add_customization).with("key2", "val2")
+
+    @preferences_hash = { "key1" => "val1", "key2" => "val2" }
+  end
+
+  it "should change any boolean values to the strings 'on' and 'off'" do
+    @mock_description.should_receive(:add_customization).with("true_thing", "on")
+    @mock_description.should_receive(:add_customization).with("false_thing", "off")
+
+    @preferences_hash = { "true_thing" => true, "false_thing" => false }
+  end
+end

data/spec/configuration/parser/iterator_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe RubyScreen::Configuration::Parser::Iterator do
+  def capture_yield(arguments, hash)
+    @iterator = RubyScreen::Configuration::Parser::Iterator.new(arguments, hash)
+    @yielded = []
+    @iterator.each_applicable_configuration_block { |b| @yielded << b }
+  end
+
+  describe "with no nested configurations" do
+    it "should return the top level items in the hash" do
+      capture_yield([], { "one" => 1 })
+
+      @yielded.length.should eql(1)
+      @yielded[0].should == { "one" => 1 }
+    end
+  end
+
+  describe "with nested configurations" do
+    it "should not yield any nested configurations that the arguments do not specify" do
+      capture_yield([], { "one" => 1, "nested" => { "two" => 2 } })
+
+      @yielded.length.should eql(1)
+      @yielded[0].should == { "one" => 1 }
+    end
+
+    it "should yield nested configuration hashes one at a time as dictated by the arguments" do
+      capture_yield(["nested"], { "one" => 1, "nested" => { "two" => 2 } })
+
+      @yielded.length.should eql(2)
+      @yielded[0].should == { "one" => 1 }
+      @yielded[1].should == { "two" => 2 }
+    end
+  end
+end

data/spec/configuration/parser/nesting_hash_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe RubyScreen::Configuration::Parser::NestingHash do
+  nested_preferences_hash = {
+    "top" => "top_level",
+    "nested1" => {
+      "one" => 1,
+      "nested2" => {
+        "two" => 2,
+        "nested3" => {
+          "three" => 3
+        }
+      },
+      "nested2.5" => {
+        "nested4" => {
+           "four" => 4
+  }}}}
+
+  duplicate_preferences_hash = {
+    "first" => {
+      "the_same" => {
+        "second" => {
+          "the_same" => {
+  }}}}}
+
+  before { nested_preferences_hash.extend(RubyScreen::Configuration::Parser::NestingHash) }
+
+  it "should define a find_nested_key method when extended" do
+    nested_preferences_hash.should respond_to(:find_nested_key)
+  end
+
+  describe "#find_nested_key" do
+    it "should return nil when a search result isn't found" do
+      nested_preferences_hash.find_nested_key("wang").should be_nil
+    end
+
+    it "should return an array of the hierarchy of hash keys that lead to the key that was searched for" do
+      nested_preferences_hash.find_nested_key("nested2").should eql(["nested1", "nested2"])
+      nested_preferences_hash.find_nested_key("nested4").should eql(["nested1", "nested2.5", "nested4"])
+    end
+
+    describe "given a hash with duplicate keys" do
+      it "should raise a DuplicateKeyException" do
+        lambda {
+          duplicate_preferences_hash.extend(RubyScreen::Configuration::Parser::NestingHash)
+        }.should raise_error(DuplicateKeyException)
+
+      end
+
+      it "should contain the name of the duplicated hash key in the exception" do
+        begin
+          duplicate_preferences_hash.extend(RubyScreen::Configuration::Parser::NestingHash)
+        rescue DuplicateKeyException => e
+          e.key.should eql("the_same")
+        end
+      end
+    end
+  end
+end

data/spec/configuration/parser_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RubyScreen::Configuration::Parser do
+  before do
+    @preferences_hash = { "preferences" => "hash" }
+    @preferences_hash.stub!(:find_nested_key).and_return(["first", "second"])
+
+    @mock_iterator = mock("Iterator")
+    @mock_iterator.stub!(:each_applicable_configuration_block)
+    RubyScreen::Configuration::Parser::Iterator.stub!(:new).and_return(@mock_iterator)
+
+    @mock_description = mock("Description")
+    @mock_description.stub!(:append_directory)
+    RubyScreen::Configuration::Description.stub!(:new).and_return(@mock_description)
+  end
+
+  after do
+    arguments = ["first_argument", "second_argument", "third_argument"]
+    RubyScreen::Configuration::Parser.parse(arguments, @preferences_hash)
+  end
+
+  it "should extend the preferences_hash with the NestingHash module" do
+    @preferences_hash.should_receive(:extend).with(RubyScreen::Configuration::Parser::NestingHash)
+  end
+
+  it "should call #find_nested_key on the preferences_hash with the first argument" do
+    @preferences_hash.should_receive(:find_nested_key).with("first_argument")
+  end
+
+  it "should instantiate a new Iterator with the path returned by #find_nested_key and preferences_hash" do
+    RubyScreen::Configuration::Parser::Iterator.should_receive(:new).with(["first", "second"], @preferences_hash).and_return(@mock_iterator)
+  end
+
+  it "should set the configuration path to a blank array if no key is found" do
+    @preferences_hash.stub!(:find_nested_key).and_return(nil)
+    RubyScreen::Configuration::Parser::Iterator.should_receive(:new).with([], @preferences_hash).and_return(@mock_iterator)
+  end
+
+   it "should catch a DuplicateKeyException from the preferences_hash and abort if so, naming the offending key" do
+    @preferences_hash.should_receive(:extend).and_raise(DuplicateKeyException.new("problem_key"))
+    Kernel.should_receive(:abort).with /problem_key/
+   end
+
+  it "should instantiate a new Description" do
+    RubyScreen::Configuration::Description.should_receive(:new).and_return(@mock_description)
+  end
+
+  it "should call the Iterator#each_applicable_configuration_block and pass the yielded block to a BlockProcessor" do
+    mock_configuration_block = mock("Configuration Block")
+    @mock_iterator.should_receive(:each_applicable_configuration_block).and_yield(mock_configuration_block)
+    RubyScreen::Configuration::Parser::BlockProcessor.should_receive(:new).with(mock_configuration_block, @mock_description)
+  end
+
+  # Oi, what a cluster.  Can't specify global ordering, and to do this perfectly I'd have to mock a ton.
+  it "should call Description#append_directory for each additional argument only after main configuration has been parsed" do
+    @iterated = false
+    @second_arg_called = false
+    @third_arg_called = false
+
+    @mock_iterator.should_receive(:each_applicable_configuration_block) { @iterated = true }
+    @mock_description.should_receive(:append_directory).twice { |arg|
+      fail "Called out of order, additional arguments added before configuration processed!" unless @iterated
+
+      if arg == "second_argument" && !@second_arg_called && !@third_arg_called
+        @second_arg_called = true
+      elsif arg == "third_argument" && @second_arg_called && !@third_arg_called
+        @third_arg_called = true
+      else
+        fail "Called out of order, with arg #{arg}"
+      end
+    }
+  end
+end

data/spec/executer_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyScreen::Executer do
+  before do
+    @description = mock("mock Configuration::Description")
+    @description.stub!(:to_screen_configuration)
+    @description.stub!(:working_directory)
+
+    @file_mock = mock("mock File")
+    @file_mock.stub!(:print)
+    File.stub!(:open).and_yield(@file_mock)
+    File.stub!(:exists?).and_return(true)
+    File.stub!(:directory?).and_return(true)
+    Dir.stub!(:chdir)
+    Dir.stub!(:tmpdir).and_return("/tmp")
+    Kernel.stub!(:exec)
+  end
+
+  after { RubyScreen::Executer.new(@description) }
+
+  describe "provided a valid Configuration::Description" do
+    describe "#initialize" do
+      it "should request the file systems' temporary directory" do
+        Dir.should_receive(:tmpdir).any_number_of_times.and_return("/tmp")
+      end
+
+      it "should open a file to store the compiled screen configuration" do
+        File.should_receive(:open).with("/tmp/.ruby-screen.compiled_configuration", "w").and_yield(@file_mock)
+      end
+
+      it "should check that the working_directory from the Description is valid" do
+        @description.stub!(:working_directory).and_return("initial/directory/path")
+        File.should_receive(:exists?).with("initial/directory/path").and_return(true)
+        File.should_receive(:directory?).with("initial/directory/path").and_return(true)
+      end
+
+      it "should attempt to change directory to correct working directory" do
+        @description.should_receive(:working_directory).any_number_of_times.and_return("initial/directory/path")
+        Dir.should_receive(:chdir).with("initial/directory/path")
+      end
+
+      it "should write compiled configuration from description to the opened file" do
+        @description.should_receive(:to_screen_configuration).and_return("my configuration string")
+        @file_mock.should_receive(:print).with("my configuration string")
+      end
+
+      it "should exec screen, passing the path to the compiled configuration" do
+        Kernel.should_receive(:exec).with("screen -c /tmp/.ruby-screen.compiled_configuration")
+      end
+    end
+  end
+
+  describe "provided a Configuration::Description with an invalid working directory" do
+    before do
+      @description.stub!(:working_directory).and_return("initial/directory/path")
+      File.stub!(:exists?).and_return(false)
+    end
+
+    it "should abort with an error" do
+      Kernel.should_receive(:abort).with(/initial\/directory\/path/)
+    end
+  end
+end

data/spec/preferences_loader_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RubyScreen::PreferencesLoader do
+  before do
+    @original_home = ENV["HOME"]
+    ENV["HOME"] = "/my/home/path"
+
+    YAML.stub!(:load)
+    erb = mock("ERB Mock")
+    erb.stub!(:result)
+    ERB.stub!(:new).and_return(erb)
+    IO.stub!(:read)
+  end
+
+  after { ENV["HOME"] = @original_home }
+
+  it "should call IO#read with the default file path" do
+    IO.should_receive(:read).with("/my/home/path/.ruby-screen.yml")
+    RubyScreen::PreferencesLoader.load
+  end
+
+  it "should display a helpful error message when the file cannot be loaded" do
+    lambda {
+      Kernel.should_receive(:abort).with(/\.ruby-screen\.yml/)
+      IO.stub!(:read).and_raise("not want!")
+      RubyScreen::PreferencesLoader.load
+    }.should_not raise_error
+  end
+
+  it "should pass output from IO#read through ERB#new, and call #result" do
+    read_results = mock("read results")
+    IO.stub!(:read).and_return(read_results)
+    erb_mock = mock("ERB Mock")
+    erb_mock.should_receive(:result)
+    ERB.should_receive(:new).and_return(erb_mock)
+    RubyScreen::PreferencesLoader.load
+  end
+
+  it "should pass return value from erb results to YAML#load" do
+    erb_mock = mock("ERB Mock")
+    erb_mock.stub!(:result).and_return("return from erb")
+    ERB.stub!(:new).and_return(erb_mock)
+    YAML.should_receive(:load).with("return from erb").and_return("return from YAML")
+    RubyScreen::PreferencesLoader.load.should eql("return from YAML")
+  end
+end