detroit 0.3.0 → 0.4.0

data/lib/detroit/project.rb

@@ -0,0 +1,134 @@
+module Detroit
+
+  require 'indexer'
+
+  def self.project(root)
+    Project.factory(root)
+  end
+
+  ##
+  # Base class for more specific Project types.
+  #
+  class Project
+
+		# FIXME: Lookup root directory. How?
+		def self.root
+		  Dir.pwd 
+		end
+
+    #
+    def self.lookup
+      dir = Dir.pwd
+      while dir != '/' #&& dir != $HOME
+        return new(dir) if project?(dir)
+        dir = File.dirname(dir)
+      end
+      return nil
+    end
+
+    # Get a new project instance based on criteria of the project.
+    # For instance a project with a `*.gemspec` is recognized as a
+    # Ruby project and thus returns an instance of {RubyProject}.
+    #
+    # @return [Project]
+    def self.factory(root)
+      if RubyProject.project?(root)
+        RubyProject.new(root)
+      else
+        Project.new(root)
+      end
+    end
+
+    # Initialize new instance of Project.
+    #
+    # @param [String,Pathname] root
+    #   Root directory of project.
+    #
+    # @return [Pathname]
+    def initialize(root)
+      @root = Pathname.new(root)
+      @log  = @root + 'log'
+    end
+
+    # Root directory.
+    #
+    # @return [Pathname]
+    attr :root
+
+    # Log directory. By defaul this is `{root}/log/`.
+    attr :log
+
+    # Detroit configuration for project.
+    #
+    # @return [Config]
+    def config
+      @config ||= Config.new(root)
+    end
+
+    # TODO: Indexer's Loadable module is confusing!!!
+
+    # Access to project metadata. Metadata is handled by Indexer.
+    # If a specific project type has different needs then override
+    # this method. The return value should work akin to an OpenStruct
+    # instance, and if possible it should respond to `#to_h` method.
+    #
+    # @return [Indexer::Metadata]
+    def metadata
+      @metadata ||= Indexer::Metadata.open(root)
+    end
+
+    # If method is missing see if it is a piece of metadata.
+    def method_missing(s, *a, &b)
+      super(s, *a, &b) unless a.empty?
+      super(s, *a, &b) if block_given?
+      metadata.send(s)
+    end
+
+  end
+
+  ##
+  # Ruby Project class.
+  #
+  class RubyProject < Project
+
+		# Determine if a directory is a Ruby project by
+    # looking for a .gemspec file.
+    #
+    # @todo While this will work well in the vase majority of
+    #       cases, there may be a few outlays.
+    #
+		def self.project?(root)
+		  Dir[File.join(root, "{*,}.gemspec")].first
+		end
+
+    #
+    #def initialize(root)
+    #  super(root)
+    #end
+
+    #
+    def metadata
+      @metadata ||= (
+        if index_file
+          Indexer::Metadata.open(root)
+        elsif file = gemspec_file
+          Indexer::Metadata.from_gemspec(file)
+        else
+          super # TODO: what metadata?
+        end
+      )
+    end
+
+    #
+    def index_file
+		  Dir[File.join(root, ".index")].first
+    end
+
+    #
+    def gemspec_file
+		  Dir[File.join(root, "{*,}.gemspec")].first
+    end
+
+  end
+
+end

data/lib/detroit/ruby_utils.rb

@@ -0,0 +1,29 @@
+require_relative 'project'
+
+module Detroit
+
+  ##
+  # Methods for working with a Ruby projects.
+  #
+  module RubyUtils
+
+    # TODO: Rename to preinitialize.
+    def prerequisite
+      require 'facets/platform'
+    end
+
+    # Current platform.
+    def current_platform
+      Platform.local.to_s
+    end
+
+
+    ## Set project manually.
+    ##
+    #def project=(proj)
+    #  @project = proj
+    #end
+
+  end
+
+end

data/lib/detroit/{tool/shell_utils.rb → shell_utils.rb}

@@ -1,15 +1,20 @@
-require 'detroit/tool/core_ext/shell_extensions'
-require 'rbconfig'
-require 'ansi/core'
-
 module Detroit
 
+  ##
   # ShellUtils provides the whole slew of FileUtils,
   # FileTest and File class methods in a single module
   # and modifies methods according to noop? and verbose?
   # options.
+  #
   module ShellUtils
 
+    #
+    def prerequisite
+      require 'rbconfig'
+      require 'ansi/core'
+      #require 'detroit/core_ext/shell_extensions'
+    end
+
     #
     def initialize_extension_defaults
       @quiet = false
@@ -22,7 +27,7 @@ module Detroit
 
     #
     def initialize_extensions
-    #  extend(fileutils)
+      #extend(fileutils)
       super() if defined?(super)
     end
 

data/lib/detroit/toolchain.rb

@@ -0,0 +1,6 @@
+require_relative 'toolchain/worker'
+require_relative 'toolchain/script'
+#require_relative 'toolchain/config'
+require_relative 'toolchain/runner'
+require_relative 'toolchain/cli'
+

data/lib/detroit/toolchain/cli.rb

@@ -0,0 +1,320 @@
+module Detroit
+
+  module Toolchain
+
+    #
+    def self.cli(argv=ARGV)
+      CLI.execute(argv)
+    end
+
+    ##
+    # The CLI class.
+    class CLI
+
+      # Location of standard plugins.
+      #PLUGIN_DIRECTORY = File.dirname(__FILE__) + '/plugins'
+
+      # Returns Array of standard plugin file names.
+      #def standard_plugins
+      #  Dir[PLUGIN_DIRECTORY + '/*.rb']
+      #end
+
+      # Universal acccess to the current project.
+      #
+      # TODO: Is Control#project being used?
+      #def project
+      #  @project ||= POM::Project.find
+      #end
+
+      #
+      # argv - Command line arguments.
+      #
+      def self.execute(argv=ARGV)
+        new.execute(*argv)
+      end
+
+      # Run the command line interface.
+      def initialize
+        @options = {
+          :toolchains => [], 
+          :assembly   => nil,
+          :trace      => nil, 
+          :trial      => nil,
+          :debug      => nil,
+          :quiet      => nil,
+          :verbose    => nil,
+          :force      => nil,
+          :multitask  => nil,
+          :skip       => []
+        }
+      end
+
+      #
+      def execute(*argv)
+        #if /\.assembly$/ =~ argv[0]
+        #  job = argv[1]
+        #  begin
+        #    application(cli_options).runscript(argv[0], job)
+        #  rescue => error
+        #    $stderr.puts error.message
+        #    exit -1
+        #  end
+        #else
+
+        option_parser.parse!(argv)
+
+        if argv.empty?
+          # TODO: What about a defualt destination, e.g. test?
+          $stderr.puts "No assembly destination given."
+          exit -1
+        end
+
+        if $DEBUG
+          application(options).start(*argv)
+        else
+          begin
+            application(options).start(*argv)
+          rescue => error
+            $stderr.puts error.message
+            exit -1
+          end
+        end
+      end
+
+      # Returns Runner instance given options.
+      def application(options={})
+        Runner.new(options)
+      end
+
+      # Command line options.
+      def options
+        @options
+      end
+
+      #
+      def toolchains
+        @options[:toolchains]
+      end
+
+      #
+      def skip
+        @options[:skip]
+      end
+
+      #
+      def multitask
+        @options[:multitask]
+      end
+
+      #
+      def multitask=(boolean)
+        @options[:multitask] = !!boolean
+      end
+
+      #
+      def assembly
+        @options[:assembly]
+      end
+
+      #
+      def assembly=(name)
+        @options[:assembly] = name.to_sym
+      end
+
+      #
+      def force
+        @options[:force]
+      end
+
+      #
+      def force=(boolean)
+        @options[:force] = !!boolean
+      end
+
+      #
+      def trial
+        @options[:trial]
+      end
+
+      #
+      def trial=(boolean)
+        @options[:trial] = !!boolean
+      end
+
+      #
+      def trace
+        @options[:trace]
+      end
+
+      #
+      def trace=(boolean)
+        @options[:trace] = !!boolean
+      end
+
+      #
+      def quiet
+        @options[:quiet]
+      end
+
+      #
+      def quiet=(boolean)
+        @options[:quiet] = !!boolean
+      end
+
+      #
+      def verbose
+        @options[:quiet]
+      end
+
+      #
+      def verbose=(boolean)
+        @options[:verbose] = !!boolean
+      end
+
+      # Create command line option parser.
+      def option_parser
+        usage_banner
+        option_multitask
+        option_assembly
+        option_toolchain
+        option_skip
+        option_trial
+        option_trace
+        option_loadpath
+        option_force
+        option_verbose
+        option_quiet
+        option_config
+        option_debug
+        option_warn
+        option_help
+        usage
+      end
+
+      # Cached instance of OptionParser.
+      #
+      # @return [OptionParser]
+      def usage
+        @usage ||= OptionParser.new
+      end
+
+      # @return [String]
+      def usage_banner
+        usage.banner = "Usage: detroit [<track>:]<stop> [options]"
+      end
+
+      # @return [void]
+      def option_multitask
+        usage.on('-m', '--multitask', "Run work elements in parallel.") do
+          self.multitask = true
+        end
+      end
+
+      # @return [void]
+      def option_assembly
+        usage.on('-a', '--assembly=NAME', "Select assembly. Default is `standard'.") do |a|
+          self.assembly = a
+        end
+      end
+
+      # @return [void]
+      def option_toolchain
+        usage.on('-t', '--toolchain [FILE]', 'Use specific toolchain file(s).') do |file|
+          self.toolchains << file
+        end
+      end
+
+      # @return [void]
+      def option_skip
+        usage.on('-S', '--skip [NAME]', 'Skip a tool instance.') do |skip|
+          self.skip << skip
+        end
+      end
+
+      # @return [void]
+      def option_trial
+        usage.on('--trial', "Run in TRIAL mode (no disk writes).") do
+          #$TRIAL = true
+          self.trial =  true
+        end
+      end
+
+      # @return [void]
+      def option_trace
+        usage.on('--trace', "Run in TRACE mode.") do
+          #$TRACE = true
+          self.trace = true
+        end
+      end
+
+      # @todo Do we really need verbose?
+      #
+      # @return [void]
+      def option_verbose
+        usage.on('--verbose', "Provide extra output.") do
+          self.verbose = true
+        end
+      end
+
+      # @return [void]
+      def option_quiet
+        usage.on('-q', '--quiet', "Run silently.") do
+          self.quiet = true
+        end
+      end
+
+      # @return [void]
+      def option_force
+        usage.on('-F', '--force', "Force operations.") do
+          self.force = true
+        end
+      end
+
+      # @return [void]
+      def option_loadpath
+        usage.on('-I=PATH', "Add directory to $LOAD_PATH") do |dirs|
+          dirs.to_list.each do |dir|
+            $LOAD_PATH.unshift(dir)
+          end
+        end
+      end
+
+      # @return [void]
+      def option_debug
+        usage.on('--debug', "Run with $DEBUG set to true.") do
+          $DEBUG = true
+        end
+      end
+
+      # @return [void]
+      def option_warn
+        usage.on('--warn', "Run with $VERBOSE set to true.") do
+          $VERBOSE = true  # wish this were called $WARN
+        end
+      end
+
+      # @return [void]
+      def option_help
+        usage.on_tail('--help [TOOL]', "Display this help message.") do |tool|
+          if tool
+            application.display_help(tool)
+          else
+            puts usage
+          end
+          exit
+        end
+      end
+
+      #
+      def option_config
+        usage.on_tail('-c', '--config TOOL', "Produce a configuration template.") do |tool|
+          puts application.config_template(tool).to_yaml
+          exit
+        end
+      end
+
+    end
+
+  end
+
+end