pangolin 0.3.0

data/spec/jar_cmd_spec.rb

@@ -0,0 +1,121 @@
+describe "jar command" do
+  
+  it "should pass the first argument to the constructor of Jar" do
+    output = 'archive.jar'
+    
+    instance = create_non_exec_jar(output)
+    
+    Jar.should_receive(:new).with(output, nil, nil).and_return(instance)
+    
+    jar output
+  end
+  
+  it "should pass the first and second arguments to the constructor of Jar" do
+    output = 'archive.jar'
+    files  = ['one/two.class', 'three/four.txt']
+    
+    Jar.should_receive(:new).with(output, files, nil).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:execute).and_return(true)
+      instance
+    end
+    
+    jar output, files
+  end
+  
+  it "should yield a Jar object if a block is given" do
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return(instance)
+    
+    jar('archive.jar') do |conf|
+      conf.should be_instance_of(Jar)
+    end
+  end
+  
+  it "should set properties on the yielded Jar instance" do
+    base_dir    = 'build'
+    compression = 3
+    
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return do
+      instance.should_receive(:base_dir=).with(base_dir)
+      instance.should_receive(:compression=).with(compression)
+      instance
+    end
+    
+    jar('archive.jar') do |conf|
+      conf.base_dir    = base_dir
+      conf.compression = compression
+    end
+  end
+  
+  it "should call #execute after yielding" do
+    Jar.should_receive(:new).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:execute).and_return(true)
+      instance
+    end
+    
+    jar('archive.jar') { }
+  end
+  
+  it "should call #execute in non-yield mode" do
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return(instance)
+    
+    jar 'archive.jar', :compression => 4
+  end
+  
+  it "should fail if #execute returns false" do
+    instance = mock('Jar')
+    instance.should_receive(:execute).and_return(false)
+    
+    Jar.should_receive(:new).and_return(instance)
+    
+    lambda { jar 'archive.jar' }.should raise_error
+  end
+  
+  it "should set the properties specified in the options parameter" do
+    base_dir    = 'build'
+    compression = 4
+    
+    Jar.should_receive(:new).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:base_dir=).with(base_dir)
+      instance.should_receive(:compression=).with(compression)
+      instance.should_receive(:verbose=).with(false)
+      instance.should_receive(:execute).and_return(true)
+      instance
+    end
+    
+    jar 'archive.jar', ['build/two/three.class'], :base_dir => base_dir, :compression => compression, :verbose => false
+  end
+  
+  it "should raise an exception for an invalid option" do
+    lambda {
+      jar 'archive.jar', ['Main.class'], :bogus => 'option'
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should pass the base_dir option straight to the constructor" do
+    output   = 'output.jar'
+    files    = [__FILE__]
+    base_dir = File.dirname(__FILE__)
+    
+    instance = create_non_exec_jar(output, files)
+    
+    Jar.should_receive(:new).with(output, files, base_dir).and_return(instance)
+    
+    jar output, files, :base_dir => base_dir
+  end
+  
+  def create_non_exec_jar( output, files = nil )
+    instance = Jar.new(output, files)
+    instance.should_receive(:execute).and_return(true) # stop the real #execute from being called    
+    instance
+  end
+  
+end

data/spec/jar_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+describe Jar do
+  
+  before(:each) do
+    @output = 'archive.jar'
+    @jar    = Jar.new(@output)
+  end
+  
+  describe " defaults" do
+    
+    it "should set the output file specified in the constructor" do
+      @jar.output.should == @output
+    end
+    
+    it "should have a default compression rate between 0 and 9" do
+      (@jar.compression >= 0).should be_true
+      (@jar.compression <= 9).should be_true
+    end
+    
+    it "should have a default manifest" do
+      @jar.manifest_string.should_not be_nil
+    end
+    
+    it "should have no entries" do
+      @jar.entries.should be_empty
+    end
+    
+  end
+  
+  describe "#initialize" do
+    
+    it "should take a path to the output file as parameters" do
+      output = 'path/to/output.jar'
+      
+      jar = Jar.new(output)
+      
+      jar.output.should == output
+    end
+    
+    it "should take a path to the output and a list of files as parameters" do
+      output = 'output.jar'
+      files  = [__FILE__]
+      
+      jar = Jar.new(output, files)
+      
+      jar.output.should == output
+      jar.entries.should == [__FILE__]
+    end
+    
+  end
+  
+  describe "#archive_path" do
+    
+    it "should remove the base dir path from the archive path" do
+      @jar.find_archive_path('build/com/example/HelloWorld.class', 'build').should == 'com/example/HelloWorld.class'
+    end
+    
+    it "should not remove anything from a file not in the base dir path" do
+      @jar.find_archive_path('some/other/path', 'build').should == 'some/other/path'
+    end
+    
+    it "should not remove anything from a file path if the base dir path is nil" do
+      @jar.find_archive_path('some/other/path', nil).should == 'some/other/path'
+    end
+    
+  end
+  
+  describe " manifest" do
+    
+    it "should include the Built-By key" do
+      @jar.manifest_string.include?('Built-By').should be_true
+    end
+    
+    it "should include added attributes" do
+      @jar.manifest = {'abc' => '123'}
+      
+      @jar.manifest_string.include?('abc: 123').should be_true
+    end
+    
+    it "should write the attributes on the right format" do
+      @jar.manifest = {'one' => '1', 'two' => '2', 'three' => '3'}
+      
+      @jar.manifest_string.include?("one: 1\n").should be_true
+      @jar.manifest_string.include?("two: 2\n").should be_true
+      @jar.manifest_string.include?("three: 3\n").should be_true
+    end
+        
+    it "should not begin with whitespace" do
+      @jar.manifest_string[0..1].should_not match(/\s/)
+    end
+    
+    it "should reject an empty attribute name" do
+      lambda {
+        @jar.manifest = {'' => '432'}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should reject nil as attribute name" do
+      lambda {
+        @jar.manifest = {nil => 'Hello world'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should reject an attribute name containing a space" do
+      lambda {
+        @jar.manifest = {'Hello World' => 'foo'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should reject an attribute name containing a colon" do
+      lambda {
+        @jar.manifest = {'Hello:World' => 'foo'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should accept a variety of legal attribute names" do
+      lambda {
+        @jar.manifest = {
+          'Manifest-Version' => 'foo',
+          'Created-By' => 'foo',
+          'Signature-Version' => 'foo',
+          'Class-Path' => 'foo'
+        }
+      }.should_not raise_error
+    end
+    
+    it "should ignore case when setting attributes" do
+      @jar.manifest = {'Hello' => 'World', 'hello' => 'Theo'}
+      
+      @jar.manifest_string.include?('Hello: World').should be_false
+      @jar.manifest_string.include?('hello: Theo').should be_true
+    end
+        
+  end
+  
+  describe "#main_class=" do
+    
+    it "should set the Main-Class attribute" do
+      @jar.main_class = 'com.example.Main'
+      
+      @jar.manifest_string.include?('Main-Class: com.example.Main').should be_true
+    end
+    
+  end
+
+  describe "#add_file" do
+    
+    it "should add an entry" do
+      path = __FILE__
+      
+      @jar.add_file(path)
+      
+      @jar.entries.include?(path).should be_true
+    end
+    
+    it "should add an entry at the specified archive path" do
+      path = __FILE__
+      archive_path = 'some/other/path.rb'
+      
+      @jar.add_file(path, archive_path)
+      
+      @jar.entries.include?(path).should be_false
+      @jar.entries.include?(archive_path).should be_true
+    end
+    
+    it "should raise an exception if the file doesn't exist" do
+      lambda {
+        @jar.add_file('some/bogus/path')
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if the argument is a directory" do
+      lambda {
+        @jar.add_file(File.dirname(__FILE__))
+      }.should raise_error(ArgumentError)
+    end
+            
+  end
+  
+  describe "#add_blob" do
+    
+    it "should add an entry" do
+      archive_path = 'some/path/to/a/file.txt'
+      
+      @jar.add_blob('one two three', archive_path)
+      
+      @jar.entries.include?(archive_path).should be_true
+    end
+            
+  end
+  
+  describe "#add_files" do
+    
+    it "should add all files" do
+      files = Dir.glob(File.dirname(__FILE__) + '/*.rb')
+      
+      @jar.add_files(files)
+      
+      files.each do |file|
+        @jar.entries.include?(file).should be_true
+      end
+    end
+    
+    it "should remove the base dir from all file paths" do
+      files = Dir.glob(File.dirname(__FILE__) + '/*.rb').map { |f| File.expand_path(f) }
+      base_dir = File.expand_path(File.dirname(__FILE__ + '/..'))
+      
+      @jar.add_files(files, base_dir)
+      
+      files.each do |file|
+        @jar.entries.include?(file.gsub(base_dir + '/', '')).should be_true
+      end
+    end
+    
+    it "should raise an exception if any of the files is a directory" do
+      files = [__FILE__, File.dirname(__FILE__)]
+      
+      lambda {
+        @jar.add_files(files)
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if any file doesn't exist" do
+      files = [__FILE__, 'some/bogus/path.txt']
+      
+      lambda {
+        @jar.add_files(files)
+      }.should raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe "#remove_entry" do
+    
+    it "should remove an added file" do
+      @jar.add_file(__FILE__)
+      @jar.remove_entry(__FILE__)
+
+      @jar.entries.include?(__FILE__).should be_false
+    end
+    
+    it "should remove an added blob" do
+      @jar.add_blob('foobar', 'foo/bar')
+      @jar.remove_entry('foo/bar')
+      
+      @jar.entries.include?('foo/bar').should be_false
+    end
+    
+    it "should not do anything when removing an entry that does not exist" do
+      lambda {
+        @jar.remove_entry('non/existent/entry')
+      }.should_not change(@jar, :entries)
+    end
+    
+  end
+  
+end

data/spec/javac_cmd_spec.rb

@@ -0,0 +1,101 @@
+describe "javac command" do
+  
+  it "should pass the first argument to the constructor of Javac" do
+    files = ['one/two.java', 'three/four.java']
+    
+    instance = Javac.new(*files)
+    instance.should_receive(:execute).and_return(true) # stop the real execute from being called
+    
+    Javac.should_receive(:new).with(*files).and_return(instance)
+    
+    javac files
+  end
+  
+  it "should yield a Javac object if a block is given" do
+    # prepare a stub that prevents the real #execute being called
+    instance = Javac.new
+    instance.should_receive(:execute).and_return(true)
+    
+    Javac.should_receive(:new).and_return(instance)
+    
+    javac('Main.java') do |conf|
+      conf.should be_instance_of(Javac)
+    end
+  end
+  
+  it "should set properties on the yielded Javac instance" do
+    destination = 'build'
+    source_path = ['xyz', 'abc']
+    
+    instance = Javac.new('Main.java')
+    
+    Javac.should_receive(:new).and_return do
+      instance.should_receive(:destination=).with(destination)
+      instance.should_receive(:source_path=).with(source_path)
+      instance.should_receive(:execute).and_return(true) # stop the real execute from being called
+      instance
+    end
+    
+    javac('Main.java') do |conf|
+      conf.destination = destination
+      conf.source_path = source_path
+    end
+  end
+  
+  it "should call #execute after yielding" do
+    Javac.should_receive(:new).and_return do
+      instance = mock('JavacInstance')
+      instance.should_receive(:execute).and_return(true)
+      instance
+    end
+    
+    javac('Main.java') { }
+  end
+  
+  it "should call #execute in non-yield mode" do
+    files = ['one/two.java', 'three/four.java']
+    
+    instance = Javac.new(*files)
+    
+    Javac.should_receive(:new).with(*files).and_return do
+      instance.should_receive(:execute).and_return(true)
+      instance
+    end
+    
+    javac files, :destination => 'build'
+  end
+  
+  it "should fail if #execute returns false" do
+    instance = mock('Javac')
+    instance.should_receive(:execute).and_return(false)
+    
+    Javac.should_receive(:new).and_return(instance)
+    
+    lambda { javac ['Hello', 'World'] }.should raise_error
+  end
+  
+  it "should set the properties specified in the options parameter" do
+    files       = ['one/two.java', 'three/four.java']
+    destination = 'build'
+    source_path = ['src', 'common/src']
+    
+    instance = mock('JavacInstance')
+    
+    Javac.should_receive(:new).with(*files).and_return do
+      instance.should_receive(:destination=).with(destination)
+      instance.should_receive(:source_path=).with(source_path)
+      instance.should_receive(:warnings=).with(false)
+      instance.should_receive(:execute).and_return(true) # stop the real execute from being called
+      instance
+    end
+    
+    javac files, :destination => destination, :source_path => source_path, :warnings => false
+  end
+  
+  it "should raise an exception for an invalid option" do
+    lambda {
+      javac ['Main.java'], :bogus => 'option'
+    }.should raise_error(ArgumentError)
+  end
+  
+end