csd 0.0.15 → 0.0.16

data/lib/csd/path.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), 'global_open_struct')
+
+module CSD
+  class Path < GlobalOpenStruct
+    
+    def self.root
+      @@root ||= Dir.pwd
+    end
+    
+    def self.root=(path)
+      @@root = path
+    end
+    
+    def self.gem
+      @@gem ||= File.expand_path(File.join(File.dirname(__FILE__), '..' ,'..'))
+    end
+    
+    def self.vendor
+      @@vendor ||= File.join(gem, 'vendor')
+    end
+    
+    def self.applications
+      @@applications ||= File.expand_path(File.join(gem, 'lib', 'csd', 'application'))
+    end
+    
+    def self.applications=(path)
+      @@applications = File.expand_path(path)
+    end
+    
+  end
+end

data/lib/csd/ui.rb

@@ -0,0 +1 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'ui', '*.rb')) { |file| require file }

data/lib/csd/ui/cli.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'ui')
+
+module CSD
+  class CLI < UI
+    
+  end
+end

data/lib/csd/ui/ui.rb

@@ -0,0 +1,46 @@
+module CSD
+  class UI
+    
+    include Gem::UserInteraction
+    
+    # These are all possible user interactions provided by the UI
+    #
+    INTERACTIONS = %w{ separator debug info warn error ask ask_yes_no }
+    
+    def separator
+      say
+    end
+    
+    def debug(message)
+      say "DEBUG: #{message}".magenta if Options.debug and !Options.silent
+    end
+    
+    def info(message)
+      say message if !Options.silent
+    end
+    
+    def warn(message)
+      say message.red if !Options.silent
+    end
+
+    def error(message)
+      if !Options.silent
+        say 'ERROR: '.red.blink + message.red
+      end
+    end
+    
+    def die(message)
+      say message.red.blink if !Options.silent
+      exit
+    end
+    
+    protected
+    
+    # This is just a convenience wrapper so that +UI.myinteraction+ will map to +CSD.ui.myinteraction+
+    #
+    def self.method_missing(meth, *args, &block)
+      INTERACTIONS.include?(meth.to_s) ? CSD.ui.send(meth.to_sym, *args, &block) : super
+    end
+
+  end
+end

data/lib/csd/version.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'path')
+
+module CSD
+  
+  # This global variable holds the version number of this gem by reading the VERSION file.
+  #
+  Version = VERSION = File.read(File.join(Path.gem, 'VERSION'))
+  
+end

data/lib/term/ansicolor.rb

@@ -0,0 +1,102 @@
+require 'term/ansicolor/version'
+
+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 ], 
+      [ :underscore   ,   4 ],     # synonym for :underline
+      [ :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

data/lib/term/ansicolor/version.rb

@@ -0,0 +1,10 @@
+module Term
+  module ANSIColor
+    # Term::ANSIColor version
+    VERSION         = '1.0.5'
+    VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+    VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+    VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+    VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  end
+end

data/test/functional/test_applications.rb

@@ -0,0 +1,86 @@
+require 'helper'
+require 'ostruct'
+
+class TestApplications < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "When analyzing arguments" do
+  
+    setup do
+      ARGV.clear
+      assert ARGV.empty?
+      Options.clear
+    end
+    
+    context "and considering a valid application" do
+
+      setup do
+        @app = 'minisip'
+        assert Applications.find(@app)
+      end
+      
+      context "the find function" do
+    
+        should "find an application in the first argument" do
+          ARGV.push(@app)
+          assert_equal @app, Applications.current!.name
+        end
+      
+        should "find an application in the second argument" do
+          ARGV.push('dummy')
+          ARGV.push(@app)
+          assert_equal @app, Applications.current!.name
+        end
+      
+        should "find an application in the third argument" do
+          ARGV.push('foo')
+          ARGV.push('bar')
+          ARGV.push(@app)
+          assert_equal @app, Applications.current!.name
+        end
+      
+        should "set nothing, if there is no valid app" do
+          ARGV.push('foo')
+          ARGV.push('bar')
+          ARGV.push('bob')
+          assert !Applications.current!
+        end
+        
+      end # context "the find function"
+      
+      context "the application module" do
+      
+        should "know its name" do
+          assert_equal @app, Applications.find(@app).name
+        end
+        
+        should "respond to options with a string" do
+          assert_kind_of(String, Applications.find(@app).options)
+          assert_kind_of(String, Applications.find(@app).options('install'))
+          assert_kind_of(String, Applications.find(@app).options('not_a_valid_action'))
+        end
+      
+      end # context "the application module"
+      
+    end # context "and considering a valid application, find"
+      
+  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
+      
+    #end # context "directories"
+  
+  #end # context "As a Dir function"
+
+end

data/test/functional/test_commands.rb

@@ -1,58 +1,55 @@
 require 'helper'
 require 'ostruct'
 
-class Cmd
-  include Csd::Commands
-  attr_accessor :options
-  def initialize
-    @options = OpenStruct.new({ :silent => true, :quiet => true, :dry => false })
-  end
-end
-
 class TestCommands < Test::Unit::TestCase
   
+  include CSD
+  
   context "As a directory function" do
   
     setup do
-      @cmd    = Cmd.new
+      Options.silent = true
+      Options.reveal = false
+      Options.dry    = false
       @tmp    = Dir.mktmpdir
       @dir    = Pathname.new File.join(@tmp, 'folder')
       @subdir = Pathname.new File.join(@dir, 'subfolder')
     end
 
     teardown do
-      FileUtils.rm_r(@tmp)
+      assert FileUtils.rm_r(@tmp)
     end
     
     context "mkdir" do
   
       should "return the proper CommandResult if the directory already existed" do
         ensure_mkdir(@dir)
-        assert_kind_of(Cmd::CommandResult, result = @cmd.mkdir(@dir))
+        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
         assert result.success?
         assert result.already_existed?
         assert result.writable?
       end
       
-      should "return the proper CommandResult if the directory already existed in dry mode" do
-        @cmd.options.dry = true
-        ensure_mkdir(@dir)
-        assert_kind_of(Cmd::CommandResult, result = @cmd.mkdir(@dir))
+      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 !@dir.directory?
         assert result.success?
-        assert result.already_existed?
+        assert !result.already_existed?
         assert result.writable?
       end
       
-      should "create the directory if it doesn't exist yet" do
-        assert_kind_of(Cmd::CommandResult, result = @cmd.mkdir(@dir))
-        assert result.success?
+      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?
+        assert !result.success?
         assert !result.already_existed?
-        assert result.writable?
+        assert !result.writable?
       end
       
-      should "create the directory if it doesn't exist yet in dry mode" do
-        @cmd.options.dry = true
-        assert_kind_of(Cmd::CommandResult, result = @cmd.mkdir(@dir))
+      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?
@@ -61,11 +58,11 @@ class TestCommands < Test::Unit::TestCase
       should "notify if there is no permission to create the directory" do
         ensure_mkdir(@dir)
         @dir.chmod(0000)
-        assert_kind_of(Cmd::CommandResult, result = @cmd.mkdir(@dir))
+        assert_kind_of(Commands::CommandResult, result = Cmd.mkdir(@dir))
         assert result.success?
         assert result.already_existed?
         assert !result.writable?
-        Pathname.new(@dir).chmod(0777) # Cleanup
+        @dir.chmod(0777) # Cleanup
       end
       
     end # context "mkdir"
@@ -73,24 +70,40 @@ class TestCommands < Test::Unit::TestCase
     context "cd" do
       
       should "return a CommanResult with success? if the directory was changed successfully" do
-        assert_kind_of(Cmd::CommandResult, result = @cmd.cd('/'))
+        assert_kind_of(Commands::CommandResult, result = Cmd.cd('/'))
         assert result.success?
-        assert_kind_of(Cmd::CommandResult, result = @cmd.cd(@tmp))
+        assert_kind_of(Commands::CommandResult, result = Cmd.cd(@tmp))
         assert result.success?
       end
       
       should "realize when the target is not a directory, but a file or something" do
         testfile_path = File.join(@tmp, 'testfile')
         File.new(testfile_path, 'w')
-        assert_kind_of(Cmd::CommandResult, result = @cmd.cd(testfile_path))
+        assert_kind_of(Commands::CommandResult, result = Cmd.cd(testfile_path))
         assert !result.success?
       end
       
       should "realize when the target doesn't exist" do
-        assert_kind_of(Cmd::CommandResult, result = @cmd.cd('/i/for/sure/dont/exist'))
+        assert_kind_of(Commands::CommandResult, result = Cmd.cd('/i/for/sure/dont/exist'))
         assert !result.success?
       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 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?
+        assert_equal '/', Dir.pwd
+      end
+      
     end # context "cd"
   
   end # context "As a directory function"

data/test/functional/test_options.rb

@@ -0,0 +1,98 @@
+require 'helper'
+
+class TestOptions < Test::Unit::TestCase
+  
+  include CSD
+  
+  context "When analyzing arguments" do
+  
+    setup do
+      ARGV.clear
+      assert ARGV.empty?
+      Options.clear
+    end
+  
+    context "and identifying just help/action/application, parse_literals" do
+      
+      teardown do
+        assert ARGV.empty?
+      end
+    
+      should "not set anything if there is nothing" do
+        Options.parse_literals
+        assert !Options.help
+        assert !Options.application
+        assert !Options.action
+      end
+    
+      should "find a lonely help parameter" do
+        ARGV.push 'help'
+        Options.parse_literals
+        assert Options.help
+        assert !Options.application
+        assert !Options.action
+      end
+        
+      context "together with a valid application" do
+    
+        setup do
+          @app = 'minisip'
+          assert Applications.find(@app)
+        end
+    
+        should "find the lonely application" do
+          ARGV.push @app
+          Options.parse_literals
+          assert !Options.help
+          assert_equal @app, Options.application
+          assert !Options.action
+        end
+        
+        should "find an action along with the application" do
+          ARGV.push 'myaction'
+          ARGV.push @app
+          Options.parse_literals
+          assert !Options.help
+          assert_equal 'myaction', Options.action
+          assert_equal @app, Options.application
+        end
+        
+        should "find an action along with the application in help mode" do
+          ARGV.push 'help'
+          ARGV.push 'myaction'
+          ARGV.push @app
+          Options.parse_literals
+          assert Options.help
+          assert_equal 'myaction', Options.action
+          assert_equal @app, Options.application
+        end
+        
+        should "understand whether an action is invalid" do
+          ARGV.push 'help'
+          ARGV.push 'invalid_action'
+          ARGV.push @app
+          Options.parse_literals
+          Options.actions = {'valid_action' => 'I am valid'}
+          assert_includes 'valid_action', Options.actions
+          assert !Options.valid_action?
+        end
+    
+      end # context "together with a valid application"
+    
+    end # context "and identifying help/action/application, parse_literals"
+  
+    context "and identifying help/action/application together with scopes, parse_literals" do
+      
+      should "know when it is a lonely non-application literal parameter" do
+        ARGV.push('myaction')
+        Options.parse_literals
+        assert !Options.help
+        assert !Options.application
+        assert !Options.action
+      end
+      
+    end # context "and identifying help/action/application together with scopes, parse_literals"
+  
+  end # context "When analyzing the options"
+
+end