csd 0.0.15 → 0.0.16

data/lib/csd/error.rb

@@ -0,0 +1,31 @@
+module CSD
+  # In this module we will keep all types of errors in a readable hierarchy
+  #
+  module Error
+    
+    # All Exceptions raised by CSD must be children of this class. 
+    #
+    class CSDError < StandardError
+      def self.status_code(code = nil)
+        return @code unless code
+        @code = code
+      end
+    
+      def status_code
+        self.class.status_code
+      end
+    end
+    
+    # Errors in this module are related to command-line options
+    #
+    module Argument
+      class NoApplication < CSDError; status_code(11); end
+      class NoAction < CSDError; status_code(12); end
+    end
+    
+    module Application
+      class OptionsSyntax < CSDError; status_code(200); end
+    end
+  
+  end
+end

data/lib/csd/extensions.rb

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

data/lib/{extensions → csd/extensions}/core/array.rb

@@ -1,4 +1,4 @@
-module Csd
+module CSD
   module Extensions
     module Core
       module Array
@@ -9,5 +9,5 @@ module Csd
 end
 
 class Array #:nodoc:
-  include Csd::Extensions::Core::Array
+  include CSD::Extensions::Core::Array
 end

data/lib/csd/extensions/core/dir.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+
+module CSD
+  module Extensions
+    module Core
+      module Dir
+        
+        def directories(path, &block)
+          if block_given?
+            ::Pathname.new(path).children_directories { |pathname| yield pathname.basename.to_s }
+          else
+            ::Pathname.new(path).children_directories.map { |pathname| pathname.basename.to_s }
+          end
+        end
+        
+        # Returns all direct subdirectories of +path+ with their entire path
+        #
+        #def directories(path, &block)
+        #  result = []
+        #  glob(::File.join(path, '*')).each do |dir|
+        #    if (::File.directory?(dir) and dir != '.' and dir != '..')
+        #      block_given? ? yield(dir) : result << dir
+        #    end
+        #  end
+        #  result
+        #end
+        
+        #def directories(path, absolute=false, &block)
+        #  result = []
+        #  entries(path) do |entry|
+        #    if (::File.directory?(entry) and entry != '.' and entry != '..')
+        #      dir = absolute? ? File.join(path, entry) : entry
+        #      block_given? ? yield(dir) : result << dir
+        #    end
+        #  end
+        #  result
+        #end
+        
+      end
+    end
+  end
+end
+
+class Dir #:nodoc:
+  extend CSD::Extensions::Core::Dir
+end

data/lib/{extensions → csd/extensions}/core/file.rb

@@ -1,4 +1,4 @@
-module Csd
+module CSD
   module Extensions
     module Core
       module File
@@ -9,5 +9,5 @@ module Csd
 end
 
 class File #:nodoc:
-  extend Csd::Extensions::Core::File
+  extend CSD::Extensions::Core::File
 end

data/lib/{extensions → csd/extensions}/core/object.rb

@@ -1,4 +1,4 @@
-module Csd
+module CSD
   module Extensions
     module Core
       module Object
@@ -18,5 +18,5 @@ module Csd
 end
 
 class Object #:nodoc:
-  include Csd::Extensions::Core::Object
+  include CSD::Extensions::Core::Object
 end

data/lib/csd/extensions/core/option_parser.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'string')
+require 'optparse'
+
+module CSD
+  module Extensions
+    module Core
+      module OptionParser
+
+        def newline
+          separator ''
+        end
+          
+        def headline(text)
+          newline
+          separator(text)
+        end
+        
+        def subheadline(text)
+          separator(@summary_indent + text)
+        end
+        
+        def list_item(item='', description='', &block)
+          separator(summary_indent + item.ljust(summary_width + 1) + description)
+        end
+        
+      end
+    end
+  end
+end
+
+class OptionParser #:nodoc:
+  include CSD::Extensions::Core::OptionParser
+end

data/lib/{extensions → csd/extensions}/core/pathname.rb

@@ -1,10 +1,19 @@
 require File.join(File.dirname(__FILE__), 'string')
 
-module Csd
+module CSD
   module Extensions
     module Core
       module Pathname
-  
+        
+        def children_directories(&block)
+          result = []
+          children.map do |child|
+            next unless child.directory?
+            block_given? ? yield(child) : result << child
+          end
+          result
+        end
+        
         def enquote
           to_s.enquote
         end
@@ -19,5 +28,5 @@ module Csd
 end
 
 class Pathname #:nodoc:
-  include Csd::Extensions::Core::Pathname
+  include CSD::Extensions::Core::Pathname
 end

data/lib/{extensions → csd/extensions}/core/string.rb

@@ -1,6 +1,6 @@
 require 'term/ansicolor'
 
-module Csd
+module CSD
   module Extensions
     module Core
       module String
@@ -16,5 +16,5 @@ end
 
 class String #:nodoc:
   include Term::ANSIColor
-  include Csd::Extensions::Core::String
+  include CSD::Extensions::Core::String
 end

data/lib/{extensions → csd/extensions}/gem/platform.rb

@@ -1,4 +1,4 @@
-module Csd
+module CSD
   module Extensions
     module Gem
       module Platform
@@ -7,6 +7,10 @@ module Csd
           version_string = version ? ", version #{version}" : ''
           "#{os} (CPU: #{cpu}#{version_string})"
         end
+        
+        def kernel_version
+          Cmd.run('uname -v', :silent => true).chop if os == 'linux'
+        end
   
       end
     end
@@ -15,6 +19,6 @@ end
 
 module Gem
   class Platform #:nodoc:
-    include Csd::Extensions::Gem::Platform
+    include CSD::Extensions::Gem::Platform
   end
 end

data/lib/csd/global_open_struct.rb

@@ -0,0 +1,18 @@
+module CSD
+  class GlobalOpenStruct
+    
+    def self.method_missing(meth, *args, &block)
+      if meth.to_s.ends_with?('=')
+        class_variable_set("@@#{meth.to_s.chop}".to_sym, *args)
+      else
+        begin
+          class_variable_get("@@#{meth}".to_sym)
+        rescue NameError => e
+          #UI.debug "The option `#{meth}´ was accessed but not available."   # FIXME: This line causes a recursion error :)
+          nil
+        end
+      end
+    end
+    
+  end
+end

data/lib/csd/options.rb

@@ -1,120 +1,149 @@
+# Ruby standard library
 require 'optparse'
 require 'optparse/time'
 require 'ostruct'
+# Vendor
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/starts_ends_with'
+require 'active_support/core_ext/array'
+# CSD
+require 'csd/extensions'
+Dir.glob(File.join(File.dirname(__FILE__), '*.rb')) { |file| require file }
 
-module Csd
-  class Options
+module CSD
+  # A class that handles the command line option parsing and manipulation
+  #
+  class Options < GlobalOpenStruct
+    
+    def self.parse!
+      clear
+      parse_literals
+      define_actions_and_scopes
+      parse_options
+    end
+    
+    def self.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)
+    end
+    
+    def self.define_actions_and_scopes
+      if Applications.current
+        # Here we overwrite the default supported actions and scopes with the application specific ones
+        self.actions = Applications.current.actions
+        # At this point we know that the first argument is no option, but *some* action (may it be valid or not)
+        self.scopes  = Applications.current.scopes(self.action)
+      end
+    end
+    
+    def self.clear
+      # First we define all valid actions and scopes
+      self.actions = []
+      self.scopes  = []
+      # Then we define the default literals
+      self.help        = false
+      self.application = nil
+      self.action      = nil
+      # Now we define the default options
+      self.yes       = false
+      self.dry       = false
+      self.reveal    = false
+      self.verbose   = false
+      self.debug     = false
+      self.silent    = false
+      self.developer = false
+    end
 
+    # Here we check for literals, i.e. "help", ACTION and APPLICATION.
     #
-    # Returns a structure describing the options.
+    def self.parse_literals
+      # First let's see whether we are in help mode, i.e. whether the first argument is `help´.
+      # If so, we would like to remove it from the ARGV list.
+      if ARGV.first == 'help'
+        self.help = true
+        ARGV.shift
+      end
+      # The action and the application name are the other literals we're interested in at this point.
+      # Note: If there is no application specified, there is pretty much nothing we can do for the user.
+      if Applications.current and Applications.current.name == ARGV.first
+        # The application name is the first argument (i.e. there is no action specified at all)
+        # Let's store the application name and remove it from the argument line
+        self.application = ARGV.shift
+      elsif Applications.current and Applications.current.name == ARGV.second
+        # The second argument is the application name. This means that the first argument must be the
+        # action or happens to be some option. In case it's no option, lets take it as desired action.
+        unless ARGV.first.starts_with?('-')
+          self.action      = ARGV.shift
+          self.application = ARGV.shift # Removing the application name from the argument list
+        end
+      end
+    end
+    
+    # Parse all options that the user gave as command parameter. Note that this function strips the options
+    # from ARGV and leaves only literal (non-option) parameters (i.e. actions/applications/scopes; strings without -- and -).
     #
-    def self.parse
-      # Default options
-      options              = OpenStruct.new
-      options.temp         = false
-      options.silent       = false
-      options.dry          = false
-      options.bootstrap    = true
-      options.configure    = true
-      options.make         = true
-      options.make_install = true
-      options.owner        = nil
-      options.apt_get      = true
-      options.yes          = false
-
-      # Parse the command line options
+    def self.parse_options
       OptionParser.new do |opts|
-        opts.banner = "Usage: csd [action] [application] [options]"
-        opts.separator ""
-        opts.separator "Actions:"
-        opts.separator "    install"
-        opts.separator ""
-        opts.separator "Applications:"
-        opts.separator "    minisip"
-        opts.separator ""
-        opts.separator "Options:"
-        
-        opts.on("-t", "--temp",
-                "Use a subdirectory in the system's temporary directory",
-                "to download files and not the current directory") do |value|
-          options.temp = value
-        end
-        
-        opts.on("-d", "--dry","Don't execute any commands, just show them") do |value|
-          options.dry = value
-        end
+        self.banner = Applications.current ? "ADVANCED HELP FOR #{Applications.current.name}" : "Usage: ".bold + "ai [help] [TASK] APPLICATION [OPTIONS]"
+        opts.banner = self.banner.magenta.bold
 
-        opts.on("-y", "--yes","Answering all questions with 'yes'") do |value|
-          options.yes = value
-        end
-        
-        opts.on("-na", "--no-apt-get","Don't run any apt-get commands") do |value|
-          options.apt_get = value
-        end
-        
-        opts.on("-nb", "--no-bootstrap","Don't run any bootstrap commands") do |value|
-          options.bootstrap = value
-        end
-        
-        opts.on("-nc", "--no-configure","Don't run any configure commands") do |value|
-          options.configure = value
-        end
-        
-        opts.on("-nm", "--no-make","Don't run any make commands") do |value|
-          options.make = value
-        end
-        
-        opts.on("-nmi", "--no-make-install","Don't run any make install commands") do |value|
-          options.make_install = value
+        unless Applications.current
+          opts.headline "EXAMPLE COMMANDS".green.bold
+          opts.list_item 'ai', 'Lists all available applications'
+          opts.list_item 'ai minisip', 'Lists available tasks for the application MiniSIP'
+          opts.list_item 'ai minisip --developer', 'Lists advanced AI tasks for the application MiniSIP'
+          opts.list_item 'ai compile minisip', 'Downloads MiniSIP and compiles it'
+          opts.list_item 'ai help compile minisip', 'Shows more details about the different compiling options'
         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
+        begin
+          unless Applications.current.options(self.action).size.blank?
+            opts.headline "#{self.action.upcase} #{Applications.current.name.upcase} OPTIONS".green.bold
+            eval Applications.current.options(self.action)
+          else
+            UI.debug "There were no options to be loaded from #{Applications.current}" 
+          end
+        rescue SyntaxError => e
+          raise Error::Application::OptionsSyntax, "The individual options of #{Applications.current.inspect} could not be parsed (SyntaxError)."
+        end if Applications.current
         
-        opts.on("--only libmcrypto,libmnetuli,etc.", Array, "Include only these libraries") do |list|
-          options.only = list
+        # And here we load all general options
+        options_prepend = Applications.current ? 'GENERAL ' : nil
+        opts.headline "#{options_prepend}OPTIONS".green.bold
+        opts.on("-y", "--yes", "Answer all questions with `yes´ (batch mode)") do |value|
+          self.yes = value
         end
-
-        opts.on("-o", "--owner [OWNER]","Specify OWNER:GROUP for this operation") do |value|
-          options.owner = value
+        opts.on("-p", "--dry","Don't actually execute any commands (preview mode)") do |value|
+          self.dry = value
         end
-        
-        opts.on("-p", "--path [PATH]",
-                "Defines the working directory manually.",
-                "(This will override the --temp option)") do |value|
-          options.path = value
+        opts.on("-r", "--reveal","List all commands that normally would be executed in this operation") do |value|
+          self.reveal = value
         end
-        
-        
-        opts.on("-d", "--debug","Show debugging information") do |value|
-          options.quiet = value
+        opts.on("-e", "--verbose","Show more elaborate output") do |value|
+          self.verbose = value
         end
-        
-        opts.on("--verbose","Show elaborate output") do |value|
-          options.quiet = value
+        opts.on("-d", "--debug","Show more elaborate output and debugging information") do |value|
+          self.debug = value
         end
-                
         opts.on("-s", "--silent","Don't show any output") do |value|
-          options.silent = value
+          self.silent = value
         end
-
-        opts.on_tail("-h", "--help", "Show this message") do
-          puts opts
-          exit
+        opts.on_tail("-a", "--developer", "Activating advanced AI functionality (developers only)") do |value|
+          self.developer = value
+        end
+        opts.on_tail("-h", "--help", "Show detailed help (regarding the given ACTION and APPLICATION)") do |value|
+          self.help = value
         end
-
         opts.on_tail("-v", "--version", "Show version") do
-          puts "CSD Gem Version: #{File.read(File.join(PathContainer.new.gem_root, 'VERSION'))}"
+          print "CSD Gem Version: #{opts.version}".blue
           exit
         end
-      end
-      
-      #.parse!
-      
-      if options.owner
-        chmod = options.owner.split(':')
-        options.owner = chmod.first
-        options.group = chmod.last
-      end
-      
-      options
+        self.helptext = opts.help
+      end.parse!
     end
 
   end