csd 0.1.5 → 0.1.6

data/lib/csd/vendor/term/ansicolor.rb

@@ -0,0 +1,113 @@
+module CSD
+  module Vendor
+    # Author
+    # 
+    # Florian Frank <flori@ping.de>
+    #
+    # License
+    # 
+    # This is free software; you can redistribute it and/or modify
+    # it under the terms of the GNU General Public License Version 2
+    # as published by the Free Software Foundation: GNU GPL.  module Term
+    #
+    module Term
+      # The ANSIColor module can be used for namespacing and mixed into your own classes.
+      #
+      module ANSIColor
+        # :stopdoc:
+        ATTRIBUTES = [
+          [ :clear        ,   0 ], 
+          [ :reset        ,   0 ],     # synonym for :clear
+          [ :bold         ,   1 ], 
+          [ :dark         ,   2 ], 
+          [ :italic       ,   3 ],     # not widely implemented
+          [ :underline    ,   4 ], 
+          [ :blink        ,   5 ], 
+          [ :rapid_blink  ,   6 ],     # not widely implemented
+          [ :negative     ,   7 ],     # no reverse because of String#reverse
+          [ :concealed    ,   8 ], 
+          [ :strikethrough,   9 ],     # not widely implemented
+          [ :black        ,  30 ], 
+          [ :red          ,  31 ], 
+          [ :green        ,  32 ], 
+          [ :yellow       ,  33 ], 
+          [ :blue         ,  34 ], 
+          [ :magenta      ,  35 ], 
+          [ :cyan         ,  36 ], 
+          [ :white        ,  37 ], 
+          [ :on_black     ,  40 ], 
+          [ :on_red       ,  41 ], 
+          [ :on_green     ,  42 ], 
+          [ :on_yellow    ,  43 ], 
+          [ :on_blue      ,  44 ], 
+          [ :on_magenta   ,  45 ], 
+          [ :on_cyan      ,  46 ], 
+          [ :on_white     ,  47 ], 
+        ]
+
+        ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+        # :startdoc:
+
+        # Returns true, if the coloring function of this module
+        # is switched on, false otherwise.
+        def self.coloring?
+          @coloring
+        end
+
+        # Turns the coloring on or off globally, so you can easily do
+        # this for example:
+        #  Term::ANSIColor::coloring = STDOUT.isatty
+        def self.coloring=(val)
+          @coloring = val
+        end
+        self.coloring = true
+
+        ATTRIBUTES.each do |c, v|
+          eval %Q{
+              def #{c}(string = nil)
+                result = ''
+                result << "\e[#{v}m" if Term::ANSIColor.coloring?
+                if block_given?
+                  result << yield
+                elsif string
+                  result << string
+                elsif respond_to?(:to_str)
+                  result << to_str
+                else
+                  return result #only switch on
+                end
+                result << "\e[0m" if Term::ANSIColor.coloring?
+                result
+              end
+          }
+        end
+
+        # Regular expression that is used to scan for ANSI-sequences while
+        # uncoloring strings.
+        COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+        # Returns an uncolored version of the string, that is all
+        # ANSI-sequences are stripped from the string.
+        def uncolored(string = nil) # :yields:
+          if block_given?
+            yield.gsub(COLORED_REGEXP, '')
+          elsif string
+            string.gsub(COLORED_REGEXP, '')
+          elsif respond_to?(:to_str)
+            to_str.gsub(COLORED_REGEXP, '')
+          else
+            ''
+          end
+        end
+
+        module_function
+
+        # Returns an array of all Term::ANSIColor attributes as symbols.
+        def attributes
+          ATTRIBUTE_NAMES
+        end
+        extend self
+      end
+    end
+  end
+end

data/lib/csd/version.rb

@@ -1,10 +1,19 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), 'path')
+# -*- encoding: UTF-8 -*-
+require 'csd/container'
 
 module CSD
   
-  # This global variable holds the version number of this gem by reading the VERSION file.
+  # This global variable holds the version number of this gem by trying to read the VERSION file.
+  # If the VERSION file cannot be read, it will be defined to 0.0.0 as a fallback.
+  # Ideally it would be hardcoded in this file, because it cannot be guaranteed that the VERSION
+  # file exists (see http://weblog.rubyonrails.org/2009/9/1/gem-packaging-best-practices). But we
+  # use it anyway, because Jeweler (a gem to create gems more easily) needs it and the risk is not that big.
   #
-  Version = VERSION = File.read(File.join(Path.gem, 'VERSION')) unless defined?(Version)
+  Version = VERSION = begin
+    File.read(File.join(Path.gem, 'VERSION'))
+  rescue Errno::ENOENT => e
+    UI.debug "The VERSION file could not be found. Setting `Version´ to 0.0.0"
+    '0.0.0'
+  end
   
 end

data/test/application/test_minisip.rb

@@ -0,0 +1,45 @@
+require 'helper'
+require 'csd/application/minisip'
+
+class TestDir < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "The Minisip application" do
+  
+    setup do
+      Options.clear
+      @app = Application::Minisip::Base.new
+    end
+
+    teardown do
+    end
+    
+    should "respond to valid actions" do
+      assert @app.respond_to?(:compile)
+    end
+    
+    should "know how to identify a subset of libraries with --only" do
+      Options.only = nil
+      assert_equal Application::Minisip::Base::LIBRARIES, @app.libraries
+      Options.only = %w{ libmcrypto }
+      assert_equal %w{ libmcrypto }, @app.libraries
+      Options.only = %w{ does-not-exist }
+      assert @app.libraries == []
+      Options.only = Application::Minisip::Base::LIBRARIES
+      assert_equal Application::Minisip::Base::LIBRARIES, @app.libraries
+      Options.only = %w{ minisip libmutil }
+      assert_equal %w{ libmutil minisip }, @app.libraries
+    end
+    
+    context "when downloading source code" do
+  
+      should "dummy" do
+        assert true
+      end
+      
+    end # context "when downloading source code"
+  
+  end # context "The Minisip application"
+  
+end

data/test/functional/test_applications.rb

@@ -64,23 +64,17 @@ class TestApplications < Test::Unit::TestCase
       end # context "the application module"
       
     end # context "and considering a valid application, find"
+    
+    context "find" do
       
-  end # context "When analyzing arguments"
-
-    #context "all" do
-
-      #should "return all apropriete Application objects as an array" do
-      #  dirs = Dir.directories(Path.applications)
-      #  apps = Applications.all
-      #  assert_equal dirs.size, apps.size
-      #  Applications.all do |app|
-      #    assert_includes directories, 'app'
-      #  end
-      #  
-      #end
+      should "do not evaluate to +true+ for an invalid application search term" do
+        assert !Applications.find(nil)
+        assert !Applications.find('')
+        assert !Applications.find('i-for-sure-do-not-exist')
+      end
       
-    #end # context "directories"
-  
-  #end # context "As a Dir function"
+    end
+      
+  end # context "When analyzing arguments"
 
 end

data/test/functional/test_commands.rb

@@ -5,13 +5,35 @@ class TestCommands < Test::Unit::TestCase
   
   include CSD
   
+  DUMMY_TEXT = %q{PART I
+
+NIGHT
+
+A high vaulted narrow Gothic chamber.
+FAUST, restless, seated at his desk.
+
+FAUST
+
+I HAVE, alas! Philosophy,
+Medicine, Jurisprudence too,
+And to my cost Theology,
+With ardent labour, studied through.
+And here I stand, with all my lore,
+Poor fool, no wiser than before.
+Magister, doctor styled, indeed,
+Already these ten years I lead,
+Up, down, across, and to and fro,
+My pupils by the nose,--and learn,
+That we in truth can nothing know!}
+
+  DUMMY_GIT = 'http://github.com/csd/dummy.git'
+  
   context "As a directory function" do
   
     setup do
       Options.silent = true
       Options.reveal = false
-      Options.dry    = false
-      @tmp    = Dir.mktmpdir
+      @tmp    = Pathname.new Dir.mktmpdir
       @dir    = Pathname.new File.join(@tmp, 'folder')
       @subdir = Pathname.new File.join(@dir, 'subfolder')
     end
@@ -24,7 +46,7 @@ class TestCommands < Test::Unit::TestCase
   
       should "return the proper CommandResult if the directory already existed" do
         ensure_mkdir(@dir)
-        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
+        assert_kind_of(CommandResult, result = Cmd.mkdir(@dir))
         assert result.success?
         assert result.already_existed?
         assert result.writable?
@@ -32,33 +54,43 @@ class TestCommands < Test::Unit::TestCase
       
       should "return a successful CommandResult but not actually do anything in reveal mode" do
         Options.reveal = true
-        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
+        assert_kind_of(CommandResult, result = Cmd.mkdir(@dir))
         assert !@dir.directory?
         assert result.success?
         assert !result.already_existed?
         assert result.writable?
       end
       
-      should "return a failing CommandResult but not actually do anything in dry mode" do
-        Options.dry = true
-        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
-        assert !@dir.directory?
+      should "create the directory if it doesn't exist yet" do
+        assert_kind_of(CommandResult, result = Cmd.mkdir(@dir))
+        assert result.success?
+        assert !result.already_existed?
+        assert result.writable?
+      end
+      
+      should "notify if there is no permission to create a new directory without die_on_failure" do
+        ensure_mkdir(@dir)
+        @dir.chmod(0000)
+        assert_kind_of(CommandResult, result = Cmd.mkdir(File.join(@dir, 'subdir_in_readonly_dir'), :die_on_failure => false))
         assert !result.success?
         assert !result.already_existed?
         assert !result.writable?
+        @dir.chmod(0777) # Cleanup
       end
       
-      should "create the directory if it doesn't exist yet" do
-        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
-        assert result.success?
-        assert !result.already_existed?
-        assert result.writable?
+      should "notify if there is no permission to create a new directory with die_on_failure" do
+        ensure_mkdir(@dir)
+        @dir.chmod(0000)
+        assert_raise(Error::UI::Die) {
+          Cmd.mkdir(File.join(@dir, 'subdir_in_readonly_dir'), :die_on_failure => true)
+        }
+        @dir.chmod(0777) # Cleanup
       end
       
-      should "notify if there is no permission to create the directory" do
+      should "notify if there is no permission to create an existing directory" do
         ensure_mkdir(@dir)
         @dir.chmod(0000)
-        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
+        assert_kind_of(CommandResult, result = Cmd.mkdir(@dir))
         assert result.success?
         assert result.already_existed?
         assert !result.writable?
@@ -70,34 +102,46 @@ class TestCommands < Test::Unit::TestCase
     context "cd" do
       
       should "return a CommanResult with success? if the directory was changed successfully" do
-        assert_kind_of(Commands::CommandResult, result = Cmd.cd('/'))
+        assert_kind_of(CommandResult, result = Cmd.cd('/'))
         assert result.success?
-        assert_kind_of(Commands::CommandResult, result = Cmd.cd(@tmp))
+        assert_kind_of(CommandResult, result = Cmd.cd(@tmp))
         assert result.success?
       end
       
-      should "realize when the target is not a directory, but a file or something" do
+      should "realize when the target is not a directory, but a file or something without die_on_failure" do
         testfile_path = File.join(@tmp, 'testfile')
         File.new(testfile_path, 'w')
-        assert_kind_of(Commands::CommandResult, result = Cmd.cd(testfile_path))
+        assert_kind_of(CommandResult, result = Cmd.cd(testfile_path, :die_on_failure => false))
         assert !result.success?
       end
       
-      should "realize when the target doesn't exist" do
-        assert_kind_of(Commands::CommandResult, result = Cmd.cd('/i/for/sure/dont/exist'))
+      should "realize when the target is not a directory, but a file or something with die_on_failure" do
+        testfile_path = File.join(@tmp, 'testfile')
+        assert_raise(Error::UI::Die) {
+          Cmd.cd(testfile_path, :die_on_failure => true)
+        }
+      end
+      
+      should "realize when the target doesn't exist without die_on_failure" do
+        assert_kind_of(CommandResult, result = Cmd.cd('/i/for/sure/dont/exist', :die_on_failure => false))
         assert !result.success?
       end
+
+      should "realize when the target doesn't exist with die_on_failure" do
+        assert_raise(Error::UI::Die) {
+          Cmd.cd('/i/for/sure/dont/exist', :die_on_failure => true)
+        }
+      end
       
       should "fake changing the directory in reveal mode" do
         Options.reveal = true
         current_pwd = Dir.pwd
-        assert_kind_of(Commands::CommandResult, result = Cmd.cd('/i/for/sure/dont/exist'))
+        assert_kind_of(CommandResult, result = Cmd.cd('/i/for/sure/dont/exist'))
         assert result.success?
         assert_equal current_pwd, Dir.pwd
       end
       
       should "actually change the directory in dry mode" do
-        Options.dry = true
         assert_not_equal '/', Dir.pwd
         assert result = Cmd.cd('/')
         assert result.success?
@@ -106,6 +150,199 @@ class TestCommands < Test::Unit::TestCase
       
     end # context "cd"
   
+    context "when working with files" do
+      
+      setup do
+        ensure_mkdir(@dir)
+        ensure_mkdir(@subdir)
+        @file1 = Pathname.new File.join(@tmp, 'file1')
+        @file2 = Pathname.new File.join(@tmp, 'file2')
+        @file3 = Pathname.new File.join(@dir, 'file3')
+        [@file1, @file2, @file3].each { |file| assert FileUtils.touch(file) }
+      end
+
+      teardown do
+        assert FileUtils.rm_r(@tmp)
+        @tmp = Pathname.new Dir.mktmpdir
+      end
+      
+      context "copy" do
+
+        should "copy one file into another folder" do
+          assert_kind_of(CommandResult, result = Cmd.copy(@file1, @subdir))
+          assert result.success?
+          assert File.exist?(File.join(@subdir, File.basename(@file1)))
+        end
+
+        should "copy several files into another folder" do
+          assert_kind_of(CommandResult, result = Cmd.copy([@file1, @file2, @file3], @subdir))
+          assert result.success?
+          [@file1, @file2, @file3].each do |file|
+            assert File.exist?(File.join(@subdir, File.basename(file)))
+          end
+        end
+        
+        should "know when a source file doesn't exist without die_on_failure" do
+          assert_kind_of(CommandResult, result = Cmd.copy('/no/source', @subdir, :die_on_failure => false))
+          assert !result.success?
+        end
+        
+        should "know when a source file doesn't exist with die_on_failure" do
+          assert_raise(Error::UI::Die) {
+            Cmd.copy('/no/source', @subdir, :die_on_failure => true)
+          }
+        end
+        
+        should "know when a destination directory doesn't exist without die_on_failure" do
+          assert_kind_of(CommandResult, result = Cmd.copy(@file1, '/no/destination', :die_on_failure => false))
+          assert !result.success?
+        end
+        
+        should "know when a destination directory doesn't exist with die_on_failure" do
+          assert_raise(Error::UI::Die) {
+            Cmd.copy(@file1, '/no/destination', :die_on_failure => true)
+          }
+        end
+        
+      end # context "copy"
+
+      context "move" do
+
+        should "move one file into another folder" do
+          assert_kind_of(CommandResult, result = Cmd.move(@file1, @subdir))
+          assert result.success?
+          assert !File.exist?(@file1)
+          assert File.exist?(File.join(@subdir, File.basename(@file1)))
+        end
+
+        should "move several files into another folder" do
+          assert_kind_of(CommandResult, result = Cmd.move([@file1, @file2, @file3], @subdir))
+          assert result.success?
+          [@file1, @file2, @file3].each do |file|
+            assert !File.exist?(file)
+            assert File.exist?(File.join(@subdir, File.basename(file)))
+          end
+        end
+        
+        should "know when a source file doesn't exist without die_on_failure" do
+          assert_kind_of(CommandResult, result = Cmd.move('/no/source', @subdir, :die_on_failure => false))
+          assert !result.success?
+        end
+
+        should "know when a source file doesn't exist with die_on_failure" do
+          assert_raise(Error::UI::Die) {
+            Cmd.move('/no/source', @subdir, :die_on_failure => true)
+          }
+        end
+        
+        should "not mind when a destination doesn't exist even with die_on_failure" do
+          assert_kind_of(CommandResult, result = Cmd.move(@file1, File.join(@subdir, 'newfile'), :die_on_failure => true))
+          assert result.success?
+          assert !File.exist?(@file1)
+          assert File.exist?(File.join(@subdir, 'newfile'))
+        end
+        
+      end # context "move"
+      
+      context "replace" do
+      
+        setup do
+          File.open(@file1, 'w') { |f| assert f.write(DUMMY_TEXT) }
+        end
+
+        should "be unsuccessful if the file doesn't exist without die_on_failure" do
+          assert_kind_of(CommandResult, result = Cmd.replace('/i/am/not/there', 'FAUST', 'GOETHE', :die_on_failure => false))
+          assert !result.success?
+        end
+        
+        should "be unsuccessful if the file doesn't exist with die_on_failure" do
+          assert_raise(Error::UI::Die) {
+            Cmd.replace('/i/am/not/there', 'FAUST', 'GOETHE')
+          }
+        end
+        
+        should "do a simple replacement in a file" do
+          assert_kind_of(CommandResult, result = Cmd.replace(@file1, 'FAUST', 'GOETHE'))
+          assert result.success?
+          assert_equal DUMMY_TEXT.gsub('FAUST', 'GOETHE'), File.read(@file1)
+        end
+        
+        should "do nothing if the file doesnt have anything to replace" do
+          assert_kind_of(CommandResult, result = Cmd.replace(@file1, 'ASDF', 'FDSA'))
+          assert_equal DUMMY_TEXT, File.read(@file1)
+          assert result.success?
+        end
+        
+        should "replace multiple items in one file" do
+          Cmd.replace @file1 do |r|
+            assert_kind_of(CommandResult, r.replace('FAUST', 'GOETHE'))
+            assert_equal DUMMY_TEXT.gsub('FAUST', 'GOETHE'), File.read(@file1)
+            assert_kind_of(CommandResult, r.replace("Philosophy,\n", 'Philosophy, '))
+            assert File.read(@file1).scan('Philosophy, Medicine')
+          end
+        end
+        
+      end # context "replace"
+      
+    end # context "when working with files"
+  
   end # context "As a directory function"
+  
+  context "run" do
+
+    setup do
+      Options.silent = true
+      Options.reveal = false
+    end
+    
+    should "return a successfull CommandResult if the command was OK" do
+      assert_kind_of(CommandResult, result = Cmd.run('cd'))
+      assert result.success?
+    end
+
+    should "return a non-successfull CommandResult if the command was bad without die_on_failure" do
+      assert_kind_of(CommandResult, result = Cmd.run('this-command-does-not-exist', :die_on_failure => false))
+      assert !result.success?
+    end
+    
+  end
+  
+  context "git_clone" do
+    
+    setup do
+      # For some gross reasons the Jeweler::Tasks.new instance modifies the ENV, trying to tell GIT some things
+      # that disturb our testing here. We need to undo this here, and it is not a nice solution, but it works.
+      ENV.keys.select { |k| k =~ /^GIT_/ }.each { |k| ENV.delete(k) }
+      Options.silent = true
+      Options.reveal = false
+      @tmp = Pathname.new Dir.mktmpdir
+      @dir = Pathname.new(File.join(@tmp, 'dummy'))
+      Dir.chdir @tmp # Since we're removing the directory in the teardown, we should better not be in it
+    end
+
+    teardown do
+      assert FileUtils.rm_r(@tmp)
+    end
+    
+    should "not successfully download a non-existent git repository without die_on_failure" do
+      assert_kind_of(CommandResult, result = Cmd.git_clone('an invalid git repository', 'invalid_git_repository.git', @dir, :die_on_failure => false))
+      assert !result.success?
+    end
+    
+    should "download a simple git repository" do
+      assert_kind_of(CommandResult, result = Cmd.git_clone('a sample git repository', DUMMY_GIT, @dir))
+      assert result.success?
+      assert @dir.directory?
+      assert File.exist?(File.join(@dir, 'dummy.txt'))
+    end
+    
+    should "do nothing at the destination in reveal mode" do
+      Options.reveal = true
+      assert_kind_of(CommandResult, result = Cmd.git_clone('a sample git repository', DUMMY_GIT, @dir))
+      assert result.success?
+      assert !@dir.directory?
+    end
+    
+  end
 
 end