csd 0.1.18 → 0.2.0

data/lib/csd/application/minisip/unix.rb

@@ -9,12 +9,13 @@ module CSD
         # This method presents a general overview about the task that is to be performed.
         #
         def introduction
+          UI.debug "Components to be processed: #{components.inspect}"
           if Options.developer
-            Core.introduction
-            # FFmpeg.introduction
-            # HDVIPER.introduction
-            # X264.introduction
-            # Plugins.introduction
+            Core.introduction    if component? 'core'
+            FFmpeg.introduction  if component? 'ffmpeg'
+            HDVIPER.introduction if component? 'hdviper'
+            X264.introduction    if component? 'x264'
+            Plugins.introduction if component? 'plugins'
             UI.separator
           end
           super
@@ -24,7 +25,11 @@ module CSD
         #
         def compile
           UI.separator
-          UI.info "This operation will compile MiniSIP and its dependencies.".green.bold
+          if all_components?
+            UI.info "This operation will install MiniSIP and its dependencies.".green.bold
+          else
+            UI.info "This operation will install the #{Options.scope} component of MiniSIP.".green.bold
+          end
           UI.separator
           install_mode = Options.this_user ? 'Only for this user (inside the working directory)' : 'For all users (sudo)'
           UI.info " Installation mode:       ".green.bold + install_mode.yellow
@@ -45,18 +50,19 @@ module CSD
         #
         def compile!
           create_working_directory
-          HDVIPER.compile
+          HDVIPER.compile          if component? 'hdviper'
           if Options.ffmpeg_first
-            X264.compile
-            FFmpeg.compile
-            Core.compile
+            X264.compile           if component? 'x264'
+            FFmpeg.compile         if component? 'ffmpeg'
+            Core.compile           if component? 'core'
           else
-            Core.compile
-            X264.compile
-            FFmpeg.compile
+            Core.compile           if component? 'core'
+            X264.compile           if component? 'x264'
+            FFmpeg.compile         if component? 'ffmpeg'
           end
-          Plugins.compile
-          Gnome.compile
+          Plugins.compile          if component? 'plugins'
+          Network.compile          if component? 'network'
+          Gnome.compile            if component? 'gnome'
           congratulations
         end
         
@@ -65,9 +71,10 @@ module CSD
             Core.run_gtkgui
           else
             cleanup_working_directory
+            return unless all_components?
             UI.separator
-            UI.info "MiniSIP installation complete.".green.bold
-            UI.info "Please have a look in your Applications menu -> Internet."
+            UI.info "               MiniSIP installation complete.".green.bold
+            UI.info "  Please have a look in your applications menu -> Internet."
             UI.separator
             # Core.run_gtkgui # At this point we could run MiniSIP instead of ending the AI -- if we wanted to.
           end

data/lib/csd/application/minisip/unix/linux/debian.rb

@@ -8,10 +8,10 @@ module CSD
         
         # A list of apt-get packages that are required to compile minisip including hdviper and ffmpeg
         #
-        DEBIAN_DEPENDENCIES = %w{ automake build-essential checkinstall git-core libnotify-bin libasound2-dev libavcodec-dev libglademm-2.4-dev libgtkmm-2.4-dev libltdl3-dev libsdl-dev libsdl-ttf2.0-dev libssl-dev libtool libswscale-dev libx11-dev libxv-dev nasm subversion yasm }
+        DEBIAN_DEPENDENCIES = %w{ automake build-essential checkinstall git-core libasound2-dev libavcodec-dev libglademm-2.4-dev libgtkmm-2.4-dev libltdl3-dev libnotify-bin libsdl-dev libsdl-ttf2.0-dev libssl-dev libswscale-dev libtool libx11-dev libxv-dev nasm subversion yasm }
 
         def compile!
-          aptitude if Options.apt_get
+          aptitude
           after_aptitude
           super
         end
@@ -20,14 +20,22 @@ module CSD
         end
         
         def package!
+          create_working_directory
           Core.modify_libminisip_rules # TODO: Oursource into Component::Core
           super
         end
         
         def aptitude
-          UI.info "Installing Debian dependencies".green.bold
-          Cmd.run("sudo apt-get update")
-          Cmd.run("sudo apt-get install #{DEBIAN_DEPENDENCIES.sort.join(' ')} --yes --fix-missing")
+          return unless Options.apt_get
+          UI.info "Installing Debian dependencies for MiniSIP".green.bold
+          Cmd.run 'sudo apt-get update', :announce_pwd => false
+          Cmd.run "sudo apt-get install #{DEBIAN_DEPENDENCIES.sort.join(' ')} --yes --fix-missing", :announce_pwd => false
+          # For some reason OpenGL crashes if we try to use this packet.
+          # return unless Gem::Platform.local.ubuntu_10? or Options.reveal
+          # UI.info "Installing 2D/3D acceleration for ATI graphic cards".green.bold
+          # Note that aptitude will not fail if the package cannot be found. This is very useful, because fglrx does not
+          # exist on Ubuntu 9.10, yet this command will not fail. Apt-get install would fail.
+          # Cmd.run "sudo aptitude install fglrx -y", :announce_pwd => false, :die_on_failure => false
         end
         
       end

data/lib/csd/application/minisip/unix/linux/debian/ubuntu10.rb

@@ -7,6 +7,7 @@ module CSD
       class Ubuntu10 < Debian
         
         def after_aptitude
+          create_working_directory
           fix_ubuntu_10_04
           super
         end
@@ -24,8 +25,8 @@ module CSD
             end
             # We cannot use Cmd.copy here, because Cmd.copy has no superuser privileges.
             # And since we are for sure on Ubuntu, these commands will work.
-            Cmd.run("sudo cp #{Path.giomm_header} #{Path.giomm_header_backup}")
-            Cmd.run("sudo cp #{Path.new_giomm_header} #{Path.giomm_header}")
+            Cmd.run "sudo cp #{Path.giomm_header} #{Path.giomm_header_backup}", :announce_pwd => false
+            Cmd.run "sudo cp #{Path.new_giomm_header} #{Path.giomm_header}", :announce_pwd => false
           end
         end
         

data/lib/csd/applications.rb

@@ -27,7 +27,7 @@ module CSD
     #
     def self.all(&block)
       result = []
-      Dir.directories(Path.applications) do |dir|
+      Dir.directories(Path.applications).sort.each do |dir|
         next if dir == 'default'
         if app = find(dir)
           block_given? ? yield(app) : result << app

data/lib/csd/commands.rb

@@ -173,14 +173,19 @@ module CSD
       #
       def self.replace(pattern, substitution, params={})
         result = CommandResult.new
-        default_params = { :die_on_failure => true }
+        default_params = { :die_on_failure => true, :only_first_occurence => false }
         params = default_params.merge(params)
         begin
-          UI.info "   Replacing".yellow
+          new_file_content = if params[:only_first_occurence]
+            UI.info "   Replacing the first occurence of".yellow
+            File.read(self.filepath).sub(pattern.to_s, substitution.to_s)
+          else
+            UI.info "   Replacing".yellow
+            File.read(self.filepath).gsub(pattern.to_s, substitution.to_s)
+          end
           UI.info "   `#{pattern}´".blue
           UI.info "   with".yellow
           UI.info "   `#{substitution.to_s.gsub("\n", "\n    ")}´".white
-          new_file_content = File.read(self.filepath).gsub(pattern.to_s, substitution.to_s)
           File.open(self.filepath, 'w+') { |file| file << new_file_content } unless Options.reveal
           result.success = true
         rescue Errno::ENOENT => e
@@ -212,7 +217,7 @@ module CSD
     #
     # This method returns a CommandResult object with the following values:
     #
-    # [+output?+] The command's output as a +String+ (with newline delimiters). Note that the status code can be accessed via the global variable <tt>$?</tt>.
+    # [+output+] The command's output as a +String+ (with newline delimiters). Note that the status code can be accessed via the global variable <tt>$?</tt>.
     # [+status?+] Contains <tt>$?</tt> and all the methods Ruby provides for it.
     # [+success?+] +true+ if the command was successful, +nil+ if not (internally <tt>$?.success?</tt> is called).
     #
@@ -314,7 +319,20 @@ module CSD
         Cmd.run("git clone #{repository} #{destination}", :announce_pwd => false)
       end
     end
-  
+    
+    # This downloads a file. It could be replaced by Ruby internals in the future to make it work in Windows.
+    # The CommandResult of <tt>Cmd.run</tt> is returned, so <tt>result.success?</tt> will indicate whether
+    # the download was successful or not.
+    #
+    def download(url, destination)
+      if Cmd.run('curl -h', :internal => true, :die_on_failure => false).success?
+        # Darwin
+        Cmd.run "curl #{url} --location -o #{destination}", :die_on_failure => false, :announce_pwd => false
+      elsif Cmd.run('wget -h', :internal => true, :die_on_failure => false).success?
+        # Linux
+        Cmd.run "wget #{url} -O #{destination}", :die_on_failure => false, :announce_pwd => false
+      end
+    end
   end
   
   # Objects of this class can be returned by Commands. Since it is an OpenStruct object,

data/lib/csd/extensions/gem/platform.rb

@@ -22,6 +22,18 @@ module CSD
           kernel_version and kernel_version =~ /Debian|Ubuntu/
         end
         
+        # Determines whether the OS is Ubuntu. Returns +true+ or +false+.
+        #
+        def ubuntu?
+          kernel_version and kernel_version =~ /Ubuntu/
+        end
+        
+        # Determines whether the OS is Ubuntu 10. Returns +true+ or +false+.
+        #
+        def ubuntu_10?
+          ubuntu? and %w{ 2.6.32-21-generic 2.6.32-22-generic }.include?(kernel_release)
+        end
+        
         # On linux systems, this method returns the current kernel version.
         #
         def kernel_version

data/lib/csd/options_parser.rb

@@ -17,20 +17,27 @@ module CSD
     end
     
     def valid_action?
-      public_actions    = actions['public'] ? self.actions['public'].map { |pair| pair.keys.first } : []
-      developer_actions = actions['developer'] ? self.actions['developer'].map { |pair| pair.keys.first } : []
-      all_actions = public_actions + developer_actions
-      all_actions.include?(self.action)
+      self.actions_names.include?(self.action)
+    end
+    
+    def valid_scope?
+      self.scopes_names.include?(self.scope)
     end
     
     def define_actions_and_scopes
       if Applications.current
         # Here we overwrite the default supported actions and scopes with the application specific ones
-        UI.debug "#{self.class} loads the actions of #{Applications.current} now"
-        self.actions = Applications.current.actions
+        UI.debug "#{self.class}#define_actions_and_scopes loads the actions of #{Applications.current} now"
+        self.actions       = Applications.current.actions
+        public_actions    = actions['public'] ? self.actions['public'].map { |pair| pair.keys.first } : []
+        developer_actions = actions['developer'] ? self.actions['developer'].map { |pair| pair.keys.first } : []
+        self.actions_names = public_actions + developer_actions
+        UI.debug "#{self.class}#define_actions_and_scopes identified the actions #{self.actions_names.inspect}"
         # At this point we know that the first argument is no option, but *some* action (may it be valid or not)
-        UI.debug "#{self.class} loads the scopes of #{Applications.current} now"
-        self.scopes  = Applications.current.scopes(self.action)
+        UI.debug "#{self.class}#define_actions_and_scopes loads the scopes of #{Applications.current} now"
+        self.scopes       = Applications.current.scopes(self.action)
+        self.scopes_names = self.scopes.map { |pair| pair.keys.first }
+        UI.debug "#{self.class}#define_actions_and_scopes identified the scopes #{self.scopes_names.inspect}"
       end
     end
     
@@ -38,8 +45,10 @@ module CSD
       # Resetting all attributes to nil (because e.g. an application instance might have modified or added some).
       super()
       # First we define all valid actions and scopes
-      self.actions = []
-      self.scopes  = []
+      self.actions       = []
+      self.actions_names = []
+      self.scopes        = []
+      self.scopes_names  = []
       # Then we define the default literals
       self.help        = false
       self.application = nil
@@ -79,7 +88,13 @@ module CSD
           self.action      = ARGV.shift
           self.application = ARGV.shift # Removing the application name from the argument list
         end
+        # The only thing that is left is the scope, by now shifted from the third to the first location.
+        # A literal must now be the desired scope
+        if ARGV.first and not ARGV.first.starts_with?('-')
+          self.scope = ARGV.shift
+        end
       end
+      UI.debug "#{self.class}#parse_literals identified the application `#{self.application}´, the action `#{self.action}´ and the scope `#{self.scope}´"
     end
     
     # Parse all options that the user gave as command parameter. Note that this function strips the options
@@ -87,8 +102,13 @@ module CSD
     #
     def parse_options
       OptionParser.new do |opts|
-        self.banner = Applications.current ? 'OPTIONS' : "Usage: ".bold + "#{CSD.executable} [help] [TASK] APPLICATION [OPTIONS]"
+        self.banner = "Usage: ".bold + "#{CSD.executable} [help] #{Options.action} #{Applications.current.name if Applications.current} [COMPONENT] [OPTIONS]".cyan
         opts.banner = self.banner.magenta.bold
+        
+        unless Options.scopes_names.empty?
+          opts.headline "COMPONENTS".green.bold
+          scopes.flatten.each { |scope| opts.list_item(scope.keys.first, scope.values.first) }
+        end
 
         # Here we load application-specific options file.
         # TODO: There must be a better way for this in general than to eval the raw ruby code

data/test/application/test_minisip.rb

@@ -12,6 +12,38 @@ class TestMinisip < Test::Unit::TestCase
       Options.clear
       Options.testmode = true
     end
+    
+    context "Debian instance" do
+      
+      setup do
+        @debian = ::CSD::Application::Minisip::Debian.new
+      end
+
+      context "*in theory* when compiling" do
+
+        setup do
+          Options.clear
+          @debian.define_relative_paths
+          Options.clear Application::Minisip.default_options('install')
+          Options.reveal = true
+          Options.testmode = true
+        end
+        
+        should "by default run apt-get commands" do
+          assert Options.apt_get
+          out, err = capture { @debian.compile! }
+          assert_match /apt\-get update/, out
+          assert_match /apt\-get install/, out
+        end
+        
+        should "skip apt-get if demanded" do
+          Options.apt_get = false
+          out, err = capture { @debian.compile! }
+          assert_no_match /apt\-get/, out
+        end
+      
+      end
+    end
 
     context "Core component" do
       
@@ -37,7 +69,7 @@ class TestMinisip < Test::Unit::TestCase
         setup do
           Options.clear
           @base.define_relative_paths
-          Options.clear Application::Minisip.default_options('compile')
+          Options.clear Application::Minisip.default_options('install')
           Options.reveal = true
           Options.testmode = true
         end
@@ -48,7 +80,7 @@ class TestMinisip < Test::Unit::TestCase
           assert Options.make
           assert Options.make_install
         end
-
+        
         should "know how to checkout the default branch of the source code" do
           out, err = capture { Core.checkout }
           assert_match /git clone /, out
@@ -56,7 +88,7 @@ class TestMinisip < Test::Unit::TestCase
           assert_no_match /git checkout/, out
           assert err.empty?
         end
-      
+        
         should "know how to checkout a particular branch of the source code" do
           Options.branch = 'cuttingedge'
           out, err = capture { Core.checkout }
@@ -64,7 +96,7 @@ class TestMinisip < Test::Unit::TestCase
           assert_match /git checkout .+ cuttingedge/, out
           assert err.empty?
         end
-      
+        
         should "use sudo make install instead of make install by default" do
           out, err = capture { Core.compile }
           # TODO: This should be a more strict test
@@ -80,8 +112,8 @@ class TestMinisip < Test::Unit::TestCase
         should "remove ffmpeg before compiling minisip" do
           Options.debug = true
           out, err = capture { Core.compile }
-          assert_match /MILESTONE: removing_ffmpeg.+MILESTONE: processing_libminisip/m, out
-          assert_no_match /MILESTONE: processing_libminisip.+MILESTONE: removing_ffmpeg/m, out
+          assert_match /MILESTONE_removing_ffmpeg.+MILESTONE_processing_libminisip/m, out
+          assert_no_match /MILESTONE_processing_libminisip.+MILESTONE_removing_ffmpeg/m, out
         end
         
         should "not link the library in this-user-mode" do
@@ -91,7 +123,32 @@ class TestMinisip < Test::Unit::TestCase
           out, err = capture { Core.compile }
           assert_no_match /ldconfig/, out
         end
+        
+        should "process libraries without parameters when demanded" do
+          Options.debug = true
+          Options.blank_minisip_configuration = true
+          out, err = capture { Core.compile_libraries }
+          assert_match /MILESTONE_processing_libmstun/, out
+          assert_match /MILESTONE_processing_libminisip/, out
+          assert_match /MILESTONE_processing_minisip/, out
+          assert_no_match /FLAGS/, out 
+          assert_no_match /enable/, out 
+        end
 
+        should "have no --enable-debug flag by default" do
+          Options.debug = true
+          out, err = capture { Core.compile_libraries }
+          assert_no_match /enable\-debug/, out
+        end
+        
+        should "use --enable-debug flag if demanded" do
+          Options.debug = true
+          Options.enable_debug = true
+          out, err = capture { Core.compile_libraries }
+          assert_match /MILESTONE_processing_libminisip.+\-\-enable\-debug.+MILESTONE_processing_minisip.+\-\-enable\-debug/m, out
+          assert_no_match /\-\-enable\-debug.+MILESTONE_processing_libminisip/m, out
+        end
+        
       end # context "in theory when compiling"
 
       context "in practice" do

data/test/functional/test_options.rb

@@ -23,6 +23,7 @@ class TestOptions < Test::Unit::TestCase
         assert !Options.help
         assert !Options.application
         assert !Options.action
+        assert !Options.scope
       end
     
       should "find a lonely help parameter" do
@@ -31,6 +32,7 @@ class TestOptions < Test::Unit::TestCase
         assert Options.help
         assert !Options.application
         assert !Options.action
+        assert !Options.scope
       end
         
       context "together with a valid application" do
@@ -46,6 +48,7 @@ class TestOptions < Test::Unit::TestCase
           assert !Options.help
           assert_equal @app, Options.application
           assert !Options.action
+          assert !Options.scope
         end
         
         should "find an action along with the application" do
@@ -55,6 +58,18 @@ class TestOptions < Test::Unit::TestCase
           assert !Options.help
           assert_equal 'myaction', Options.action
           assert_equal @app, Options.application
+          assert !Options.scope
+        end
+        
+        should "find an action along with the application and a scope" do
+          ARGV.push 'myaction'
+          ARGV.push @app
+          ARGV.push 'myscope'
+          Options.parse_literals
+          assert !Options.help
+          assert_equal 'myaction', Options.action
+          assert_equal @app, Options.application
+          assert_equal 'myscope', Options.scope
         end
         
         should "find an action along with the application in help mode" do
@@ -65,6 +80,19 @@ class TestOptions < Test::Unit::TestCase
           assert Options.help
           assert_equal 'myaction', Options.action
           assert_equal @app, Options.application
+          assert !Options.scope
+        end
+        
+        should "find an action along with the application and a scope in help mode" do
+          ARGV.push 'help'
+          ARGV.push 'myaction'
+          ARGV.push @app
+          ARGV.push 'myscope'
+          Options.parse_literals
+          assert Options.help
+          assert_equal 'myaction', Options.action
+          assert_equal @app, Options.application
+          assert_equal 'myscope', Options.scope
         end
         
         should "understand whether an action is invalid" do
@@ -72,11 +100,62 @@ class TestOptions < Test::Unit::TestCase
           ARGV.push 'invalid_action'
           ARGV.push @app
           Options.parse_literals
-          Options.actions = {'valid_action' => 'I am valid'}
-          assert_includes 'valid_action', Options.actions
+          Options.actions_names = ['valid_action']
           assert !Options.valid_action?
+          assert !Options.valid_scope?
+          assert !Options.scope
         end
-    
+
+        should "understand whether an action is invalid when a scope is given" do
+          ARGV.push 'help'
+          ARGV.push 'invalid_action'
+          ARGV.push @app
+          ARGV.push 'myscope'
+          Options.parse_literals
+          Options.actions_names = ['valid_action']
+          assert !Options.valid_action?
+          assert !Options.valid_scope?
+          assert_equal 'myscope', Options.scope
+        end
+        
+        should "understand whether an action is valid when a scope is given" do
+          ARGV.push 'help'
+          ARGV.push 'valid_action'
+          ARGV.push @app
+          ARGV.push 'myscope'
+          Options.parse_literals
+          Options.actions_names = ['valid_action']
+          assert Options.valid_action?
+          assert !Options.valid_scope?
+          assert_equal 'myscope', Options.scope
+        end
+        
+        should "understand whether a scope is invalid when a valid action is given" do
+          ARGV.push 'help'
+          ARGV.push 'valid_action'
+          ARGV.push @app
+          ARGV.push 'invalid_scope'
+          Options.parse_literals
+          Options.actions_names = ['valid_action']
+          Options.scopes_names = ['valid_scope']
+          assert Options.valid_action?
+          assert !Options.valid_scope?
+          assert_equal 'invalid_scope', Options.scope
+        end
+        
+        should "understand whether a scope is valid when a valid action is given" do
+          ARGV.push 'help'
+          ARGV.push 'valid_action'
+          ARGV.push @app
+          ARGV.push 'valid_scope'
+          Options.parse_literals
+          Options.actions_names = ['valid_action']
+          Options.scopes_names = ['valid_scope']
+          assert Options.valid_action?
+          assert Options.valid_scope?
+          assert_equal 'valid_scope', Options.scope
+        end
+        
       end # context "together with a valid application"
     
     end # context "and identifying help/action/application, parse_literals"