csd 0.1.5 → 0.1.6

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

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# -*- encoding: UTF-8 -*-
 require File.join(File.dirname(__FILE__), '..', 'unix')
 
 module CSD
@@ -6,16 +6,6 @@ module CSD
     module Minisip
       class Linux < Unix
         
-        def compile!
-          before_compile
-          Cmd.mkdir Path.work
-          make_hdviper if checkout_hdviper or Options.dry
-          checkout_minisip
-          checkout_plugins
-          make_minisip
-          after_compile
-        end
-        
       end
     end
   end

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

@@ -1,5 +1,5 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), '..', 'linux')
+# -*- encoding: UTF-8 -*-
+require 'csd/application/minisip/unix/linux'
 
 module CSD
   module Application
@@ -8,15 +8,16 @@ module CSD
         
         # A list of apt-get packages that are required by this application. 
         #
-        DEBIAN_DEPENDENCIES = %w{ libssl-dev libgtkmm-2.4-dev libglademm-2.4-dev libsdl-dev git-core subversion automake libtool libltdl3-dev build-essential libavcodec-dev libswscale-dev libasound2-dev libsdl-ttf2.0-dev nasm yasm ffmpeg }
+        DEBIAN_DEPENDENCIES = %w{ libxv-dev libssl-dev libgtkmm-2.4-dev libglademm-2.4-dev libsdl-dev git-core subversion automake libtool libltdl3-dev build-essential libavcodec-dev libswscale-dev libasound2-dev libsdl-ttf2.0-dev nasm yasm ffmpeg }
         
-        def before_compile
-          #fix_aclocal_dirlist
+        def compile!
           install_aptitude_dependencies if Options.apt_get
+          super
         end
         
-        def after_compile
-          ldconfig_and_gtkgui
+        def package!
+          modify_libminisip_rules
+          super
         end
         
         def install_aptitude_dependencies
@@ -26,27 +27,15 @@ module CSD
           end
         end
         
-        def fix_aclocal_dirlist
-          return
-          content = '/usr/local/share/aclocal'
-          target = Pathname.new('/usr/share/aclocal/dirlist')
-          unless target.exist? and File.new(target).read == content # TODO: replace with File.read
-            begin
-              File.new(target, 'w').write(content).close              
-            rescue Errno::EACCES => e
-              say "Please run the following commands with the right permissions.".red.bold
-              say "  sudo rm /usr/share/aclocal/dirlist".green.bold
-              say "  sudo touch /usr/share/aclocal/dirlist".green.bold
-              say "  sudo echo /usr/local/share/aclocal >> /usr/share/aclocal/dirlist".green.bold
-              exit
-            end
+        def modify_libminisip_rules
+          if File.exist? Path.repository_libminisip_rules_backup
+            UI.warn "The libminisip rules seem to be fixed already, I won't touch them now. Delete #{Path.repository_libminisip_rules_backup.enquote} to enforce it."
+          else
+            Cmd.copy Path.repository_libminisip_rules, Path.repository_libminisip_rules_backup
+            Cmd.replace Path.repository_libminisip_rules, 'AUTOMATED_INSTALLER_PLACEHOLDER=""', [cpp_flags, ld_flags].join(' ')
           end
         end
         
-        def ldconfig_and_gtkgui
-          Cmd.run(Path.build_gtkgui)
-        end
-        
       end
     end
   end

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

@@ -1,33 +1,32 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), '..', 'debian')
+# -*- encoding: UTF-8 -*-
+require 'csd/application/minisip/unix/linux/debian'
 
 module CSD
   module Application
     module Minisip
       class Ubuntu10 < Debian
-      
-        def before_compile
-          super
+        
+        def compile!
           fix_ubuntu_10_04
           exit if Options.only_fix_giomm
+          super
         end
         
         def fix_ubuntu_10_04
-          # TODO put backup file in Path.xxx
-          if File.exist?("#{Path.giomm_header}.ai-backup")
-            UI.warn "giomm-2.4 seems to be fixed already, I won't touch it. Delete `#{"#{Path.giomm_header}.ai-backup"}´ to enforce it."
+          if File.exist? Path.giomm_header_backup
+            UI.warn "giomm-2.4 seems to be fixed already, I won't touch it now. Delete #{Path.giomm_header_backup.enquote} to enforce it."
           else
             Path.new_giomm_header = File.join(Dir.mktmpdir, 'giomm.h')
             Cmd.copy(Path.giomm_header, Path.new_giomm_header)
-            Cmd.replace(Path.new_giomm_header, '#include <giomm/socket.h>', "/* ----- AI COMMENTING OUT START ----- \n#include <giomm/socket.h>")
-            Cmd.replace(Path.new_giomm_header, '#include <giomm/tcpconnection.h>', "#include <giomm/tcpconnection.h>\n ----- AI COMMENTING OUT END ----- */")
-            Cmd.replace(Path.new_giomm_header, '# include <giomm/unixconnection.h>', "// #include <giomm/unixconnection.h>  // COMMENTED OUT BY AI")
-            Cmd.run("sudo cp #{Path.giomm_header} #{Path.giomm_header}.ai-backup")
+            Cmd.replace Path.new_giomm_header do |r|
+              r.replace '#include <giomm/socket.h>', "/* ----- AI COMMENTING OUT START ----- \n#include <giomm/socket.h>"
+              r.replace '#include <giomm/tcpconnection.h>', "#include <giomm/tcpconnection.h>\n ----- AI COMMENTING OUT END ----- */"
+            end
+            Cmd.run("sudo cp #{Path.giomm_header} #{Path.giomm_header_backup}")
             Cmd.run("sudo cp #{Path.new_giomm_header} #{Path.giomm_header}")
           end
         end
       
-      
       end
     end
   end

data/lib/csd/applications.rb

@@ -1,7 +1,6 @@
-# encoding: utf-8
+# -*- encoding: UTF-8 -*-
 require 'ostruct'
-require 'active_support/inflector'
-require 'active_support/core_ext/string/inflections'
+require 'csd/extensions/core/string'
 
 module CSD
   
@@ -9,14 +8,15 @@ module CSD
   #
   class Applications
 
-    # Returns nil if application could not be found
+    # Returns the application module instance of +app_name+. Returns +nil+ if the application could not be found or loaded.
     #
     def self.find(app_name)
+      return nil if app_name.to_s.empty?
       begin
         UI.debug "Applications.find: Attempting to require `#{File.join(Path.applications, app_name.to_s)}´."
         require File.join(Path.applications, app_name.to_s)
         UI.debug "Applications.find: Attempting to load `#{app_name}´."
-        ActiveSupport::Inflector.constantize "CSD::Application::#{app_name.camelize}"
+        "CSD::Application::#{app_name.to_s.camelize}".constantize
       rescue LoadError => e
         UI.debug "Applications.find: The Application `#{app_name}´ could not be loaded properly."
         UI.debug "                   Reason: #{e}"

data/lib/csd/commands.rb

@@ -1,36 +1,18 @@
-# encoding: utf-8
+# -*- encoding: UTF-8 -*-
 require 'pathname'
 require 'ostruct'
 
 module CSD
-  # This module contains wrapper methods for standard file system operations. They are meant to be
+  # This class contains wrapper methods for standard file system operations. They are meant to be
   # a little bit more robust (e.g. raising no exceptions) and return elaborate feedback on their operation.
   # All of these methods, except for the +run+ method, are platform independent.
   #
-  module Commands
+  class Commands
     
     # The Process module is a collection of methods used to manipulate processes.
     # We use it to check whether we run as sudo or not by evaluating the uid of ths user (if it's 0 it's root)
     include Process
     
-    # Objects of this class can be returned by Commands. Since it is an OpenStruct object,
-    # it can contain an arbritary number of values.
-    #
-    class CommandResult < OpenStruct
-      
-      # This creates an convenient, read-only accessor for the OpenStruct object values.
-      # It simply maps methods that end with a <tt>?</tt> to the same method without <tt>?</tt>.
-      #
-      # ==== Examples
-      #
-      #   command_result.something? # => command_result.something
-      #
-      def method_missing(meth, *args, &block)
-        meth.to_s.ends_with?('?') ? self.send(meth.to_s.chop.to_sym, *args, &block) : super
-      end
-      
-    end
-    
     # Creates a directory recursively.
     #
     # ==== Returns
@@ -51,7 +33,9 @@ module CSD
     #
     #  mkdir('i/can/create/directories/recursively')
     #
-    def mkdir(target)
+    def mkdir(target, params={})
+      default_params = { :die_on_failure => true, :show_output => false }
+      params = default_params.merge(params)
       target = target.pathnamify
       result = CommandResult.new
       if target.directory?
@@ -61,10 +45,10 @@ module CSD
         begin
           UI.info "Creating directory: #{target}".cyan
           # Try to create the directory
-          target.mkpath unless (Options.dry or Options.reveal)
+          target.mkpath unless Options.reveal
         rescue Errno::EACCES => e
-           UI.error "Cannot create directory (no permission): #{target}"
-           return result
+          result.reason = "Cannot create directory (no permission): #{target}"
+          params[:die_on_failure] ? UI.die(result.reason) : UI.error(result.reason)
         end
       end
       result.success  = (target.directory? or Options.reveal)
@@ -80,67 +64,103 @@ module CSD
     #
     # [+success?+] +true+ if pwd is where it was requested to be after the operation, +nil+ if not.
     #
-    def cd(target)
+    def cd(target, params={})
+      default_params = { :die_on_failure => true, :show_output => false }
+      params = default_params.merge(params)
       target = target.pathnamify
       result = CommandResult.new
-      if target.directory? or Options.reveal
-        UI.info "cd #{target}".yellow
-        if Options.reveal
-          @pwd = target.to_s
-        else
+      UI.info "cd #{target}".yellow
+      if Options.reveal
+        # We need to fake changing the directory in reveal mode.
+        @pwd = target.to_s
+        result.success = true
+      else
+        begin
           Dir.chdir(target)
+          result.success = target.current_path?
+        rescue Exception => e
+          result.reason = "Cannot change to directory `#{target}´. Reason: #{e.message}"
+          params[:die_on_failure] ? UI.die(result.reason) : UI.error(result.reason)
         end
-      elsif target.exist?
-        UI.error "Cannot change to directory because it exists but is not a directory: #{target}".red
       end
-      result.success = (target.current_path? or Options.reveal)
       result
     end
     
     # Copies one or several files to the destination
     #
-    def copy(src, dest)
-      UI.info "Copying `#{src}´ to `#{dest}´".cyan
-      FileUtils.cp(src, dest) unless (Options.dry or Options.reveal)
+    def copy(src, dest, params={})
+      transfer(:copy, src, dest, params)
     end
     
     # Moves one or several files to the destination
     #
-    def move(src, dest)
-      UI.info "Moving `#{src}´ to `#{dest}´".cyan
-      FileUtils.mv(src, dest) unless (Options.dry or Options.reveal)
+    def move(src, dest, params={})
+      transfer(:move, src, dest, params)
     end
     
     # This returns the current pwd. However, it will return a fake result if we are in reveal-commands-mode.
     #
     def pwd
-      if Options.reveal
-        @pwd ||= Dir.pwd
-      else
-        Dir.pwd
+      begin
+        if Options.reveal
+          @pwd ||= Dir.pwd
+        else
+          Dir.pwd
+        end
+      rescue Errno::ENOENT => e
+        UI.debug "The current pwd could not be located. Was the directory removed?"
+        nil
       end
     end
     
-    # Replaces all occurences of a pattern in a file
-    #
-    # ==== Returns
+    # Replaces all occurences of a pattern in a file.
+    # In a block, it yields the Replacer class.
+    # Otherwise it calls the replace function in the Replacer class. 
     #
-    # This method returns a CommandResult object with the following values:
-    #
-    # [+success?+] +true+ if the replacement was successful, +nil+ if not.
+    def replace(filepath, pattern='', substitution='', params={}, &block)
+      params = pattern if pattern.is_a?(Hash)
+      default_params = { :die_on_failure => true }
+      params = default_params.merge(params)
+      UI.info "Modifying contents of `#{filepath}´ as follows:".cyan
+      Replacer.filepath = filepath
+      if block_given?
+        yield Replacer
+      else
+        Replacer.replace(pattern, substitution, params)
+      end
+    end
+    
+    # This class is yielded by the replace function in a block
     #
-    def replace(filepath, pattern, substitution)
-      result = CommandResult.new
-      begin
-        UI.info "Modifying contents of `#{filepath}´ as follows:".blue
-        UI.info "  (Replacing all occurences of `#{pattern}´ with `#{substitution}´)".blue
-        new_file_content = File.read(filepath).gsub(pattern, substitution)
-        File.open(filepath, 'w+') { |file| file << new_file_content } unless (Options.dry or Options.reveal)
-      rescue Errno::ENOENT => e
-        result.success = false
+    class Replacer
+      class << self
+        attr_accessor :filepath
+      end
+      
+      # Replaces all occurences of a pattern in a file
+      #
+      # ==== Returns
+      #
+      # This method returns a CommandResult object with the following values:
+      #
+      # [+success?+] +true+ if the replacement was successful, +nil+ if not.
+      #
+      def self.replace(pattern, substitution, params={})
+        result = CommandResult.new
+        default_params = { :die_on_failure => true }
+        params = default_params.merge(params)
+        begin
+          UI.info "   `#{pattern}´  =>  `#{substitution}´".blue
+          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
+          result.success = false
+          result.reason = "Could not perform replace operation! #{e.message}"
+          params[:die_on_failure] ? UI.die(result.reason) : UI.error(result.reason)
+        end
+        result
       end
-      result.success = true if Options.reveal
-      result
     end
     
     # Runs a command on the system.
@@ -153,52 +173,107 @@ module CSD
     #
     # The following options can be passed as a hash.
     #
-    # [+:exit_on_failure+] If the exit code of the command was not 0, exit the CSD application.
+    # [+:exit_on_failure+] If the exit code of the command was not 0, exit the CSD application (default: +true+).
+    # [+:silent+] Don't show the command's output prints by any means (default: +false+).
+    # [+:announce_pwd+] Before running the command, say in which path the command will be executed (default: +true+).
+    # [+:verbose+] Instead of printing just one `.´ per command output line, print the original command output lines (default: +false+).
     #
     def run(cmd, params={})
-      cmd = cmd.to_s
-      default_params = { :die_on_failure => true, :silent => false }
+      default_params = { :die_on_failure => true, :silent => false, :announce_pwd => true, :verbose => false }
+      params[:verbose] = true if Options.verbose
       params = default_params.merge(params)
-      unless params[:silent]
-        UI.info "Running command in #{pwd}".yellow
-        UI.info cmd.cyan
+      result = CommandResult.new
+      cmd = cmd.to_s
+      UI.error "The current working directory (aka 'pwd') could not be identified. It was probably deleted." and return unless pwd
+      UI.info "Running command in #{pwd}".yellow unless (!params[:announce_pwd] or params[:silent])
+      UI.info cmd.cyan unless params[:silent]
+      if Options.reveal
+        result.success = true
+        return result
       end
-      return '' if Options.reveal or Options.dry
-      ret = ''
+      result.output = ''
+      $stderr.reopen '/dev/null' if params[:silent] # This prevents even output of error messages from the executed commands
       IO.popen(cmd) do |stdout|
         stdout.each do |line|
-          UI.info "       #{line}" unless params[:silent]
-          ret << line
+          if params[:verbose]
+            UI.info "       #{line}" unless params[:silent]
+          else
+            $stdout.putc '.' unless params[:silent]
+            $stdout.flush
+          end
+          result.output << line
         end
       end
-      die_if_last_command_had_errors if params[:die_on_failure]
-      ret
+      UI.separator if (!params[:silent] and !params[:verbose]) # i.e. if dots are outputted, we should create a new line after them
+      result.success = $?.success?
+      if params[:die_on_failure] and !result.success
+        UI.info result.output unless params[:verbose] # In verbose mode, we don't need to repeat the unsuccessful command's output
+        UI.die "The last command was unsuccessful." 
+      end
+      result
+    end
+    
+    private
+    
+    # The common backend for copy and move operations.
+    #
+    def transfer(action, src, dest, params={})
+      default_params = { :die_on_failure => true }
+      params = default_params.merge(params)
+      result = CommandResult.new
+      UI.info "#{action == :copy ? 'Copying' : 'Moving'} `#{src}´ to `#{dest}´".cyan
+      begin
+        FileUtils.send(action, src, dest) unless Options.reveal
+        result.success = true
+      rescue Exception => e
+        result.success = false
+        result.reason = "Could not perform #{action} operation! #{e.message}"
+        params[:die_on_failure] ? UI.die(result.reason) : UI.error(result.reason)
+      end
+      result
     end
     
-    def die_if_last_command_had_errors
-      UI.die "The last command was unsuccessful." unless $?.success?
+    # Clones the master branch of a repository using +git+. +name+ is a +String+ used for UI outputs,
+    # +repository+ is the URL/path to the repository, +destination+ is an absolute or relative
+    # path to where the repository should be downloaded to.
+    #
+    # This command will not do anything if the destination already exists.
+    #
+    def git_clone(name, repository, destination, params={})
+      default_params = { :announce_pwd => false, :silent => true }
+      params = default_params.merge(params)
+      result = CommandResult.new
+      destination = destination.pathnamify
+      # At this point we break off if the destination already exists, but in reveal-mode we want to continue.
+      UI.warn "Skipping #{name} download, because the directory already exists: #{destination.enquote}" and return if (destination.directory? and !Options.reveal)
+      if destination.parent.writable? or Options.reveal
+        UI.info "Downloading #{name} to #{destination.enquote}".green.bold
+        result.success = Cmd.run("git clone #{repository} #{destination} #{('--quiet' if params[:silent])}", params.merge({:die_on_failure => false})).success?
+      else
+        UI.error "Could not download #{name} (no permission): #{destination.enquote}"
+        result.success = false
+      end
+      result
     end
   
   end
   
-  # Having a class to include all command modules
+  # Objects of this class can be returned by Commands. Since it is an OpenStruct object,
+  # it can contain an arbritary number of values.
   #
-  class CommandsInstance
-    include Commands
-  end
-  
-  # Wrapping the CommandsInstance class
-  #
-  class Cmd
-    COMMANDS = %w{ mkdir cd run replace copy move } unless defined?(COMMANDS)
+  class CommandResult < OpenStruct
     
-    def self.instance
-      @@instance ||= CommandsInstance.new
+    # This creates an convenient, read-only accessor for the OpenStruct object values.
+    # It simply maps methods that end with a <tt>?</tt> to the same method without <tt>?</tt>.
+    #
+    # ==== Examples
+    #
+    #   command_result.something? # => command_result.something
+    #
+    def method_missing(meth, *args, &block)
+      meth.to_s.ends_with?('?') ? self.send(meth.to_s.chop.to_sym, *args, &block) : super
     end
     
-    def self.method_missing(meth, *args, &block)
-      COMMANDS.include?(meth.to_s) ? instance.send(meth, *args, &block) : super
-    end
   end
   
 end