detroit 0.3.0 → 0.4.0

data/lib/detroit/basic_tool.rb

@@ -0,0 +1,200 @@
+module Detroit
+
+  ##
+  # This base class can be used for tools that do not need
+  # all of the utility methods provided by the regular Tool
+  # class.
+  #
+  class BasicTool
+    include BasicUtils
+
+    # Call this method to register a tool with an assembly.
+    # A tool can only belong to one assembly, but migration
+    # adapters can be defined to allow tools from one assembly
+    # to work with another (COMING SOON).
+    #
+    # @param [Assembly] a (optional)
+    #   Assembly for which this tool is designed.
+    #
+    # @example
+    #   class SomeTool < Tool
+    #     assembly Standard
+    #
+    # @return [Assembly] Assembly module.
+    def self.assembly(a=nil)
+      #include(@assembly = a) if a
+      include(a) if a
+      @assembly
+    end
+
+    #
+    def self.assembly=(a)
+      @assembly = a
+    end
+
+    ## Specify a supported station. This is used by the `chain?` method to
+    ## determine if station is supporte by a tool. This is more convenient
+    ## then overridding `chain?` method.
+    #def self.station(name, alt=nil)
+    #  define_method("station_#{name}") do |options={}|
+		#    meth = method(alt || name)
+		#    case meth.arity
+		#    when 0
+		#      meth.call()
+		#    else
+		#      meth.call(options)
+		#    end
+    #  end
+    #end
+
+    # Returns a Class which is a new subclass of the current class.
+    #def self.factory(&block)
+    #  Class.new(self, &block)
+    #end
+
+    # Override the usual new method in order to apply prerequisites.
+    #
+    # @return [BasicTool]
+    def self.new(options={})
+      tool = allocate
+      # TODO: I don't exactly like this, but how else to get project
+      #        into the tool befire running `#prerequiste`?
+      tool.project = options['project']
+      ancestors.reverse_each do |anc|
+        next if (anc == BasicObject || anc == Object || anc == Kernel)
+        if anc.instance_methods.include?(:prerequisite)
+          pre = anc.instance_method(:prerequisite)
+          pre.bind(tool).call
+        end
+      end
+      tool.send(:initialize, options)
+      tool
+    end
+
+    # Returns list of writer method names. This is used for reference.
+    #
+    # @return [Array<String>]
+    def self.options(tool_class=self)
+      i = tool_class.ancestors.index(Tool)
+      m = []
+      tool_class.ancestors[0..i].each do |sc|
+        sc.public_instance_methods(false).each do |pm|
+          next if pm !~ /\w+=$/
+          next if %w{taguri=}.include?(m.to_s)
+          m << pm.to_s.chomp('=')
+        end
+      end
+      m
+    end
+
+    # Override this method if the tool's availability is conditional.
+    #
+    # @return [Boolean]
+    def self.available?
+      true
+    end
+
+    # This pre-initialization procedure is run before #initialize and
+    # for all ancestors, so `#super` should never be called within it.
+    # The method is intended to be used to require dependencies for a tool,
+    # so that tool's dependencies are only required when needed. But it can
+    # also be used to set pre-option attribute defaults.
+    #
+    # @example
+    #   def prerequisite
+    #     require 'ostruct'
+    #     @gravy = true
+    #   end
+    #
+    # @return [void]
+    def prerequisite
+    end
+
+    # Create a new tool object.
+    #
+    # This sets up utility extensions and assigns options to setter attributes
+    # if they exist and values are not nil. That last point is important.
+    # You must use 'false' to purposely negate an option, as +nil+ will instead
+    # allow any default setting to be used.
+    #
+    # @return [void]
+    def initialize(options={})
+      initialize_options(@options = options)
+    end
+
+    # Called by `#initialize` to call writers from given options.
+    #
+    # @return [void]
+    def initialize_options(options)
+      options.each do |k, v|
+        #send("#{k}=", v) unless v.nil? #if respond_to?("#{k}=") && !v.nil?
+        if respond_to?("#{k}=")
+          send("#{k}=", v) unless v.nil? #if respond_to?("#{k}=") && !v.nil?
+        else
+          warn "#{self.class.name} does not respond to `#{k}=`."
+        end
+      end
+    end
+
+    # Access to all options passed into `#initialize`.
+    #
+    # @return [Hash]
+    attr :options
+
+    #
+    # @todo Is this needed?
+    #
+    def title
+      self.class.name
+    end
+
+    # Does this tool attach to the specified station?
+    #
+    # By default this checks for the definition of a public method in the tool
+    # class with the same name as the station. Note, it does not use `respond_to?`
+    # to do this, which would find any such method in the class hierarchy. Instead
+    # it specifically checks for a definition in the tool class itself. This
+    # helps prevent potential accidental name clashes between support methods
+    # and station names.
+    #
+    def assemble?(station, options={})
+      self.class.public_methods(false).include?(station.to_sym)
+    end
+
+    #
+    def assemble(station, options={})
+      meth = method(station)
+
+      case meth.arity
+      when 0
+        meth.call()
+      else
+        meth.call(options)
+      end
+    end
+
+    # Project instance.
+    def project=(project)
+      @project = project
+    end
+
+    # Project instance.
+    def project
+      @project #||= Project.factory(root)
+    end
+
+    # Shortcut to project metadata.
+    def metadata
+      project.metadata
+    end
+
+    # Project root directory.
+    #
+    # @return [Pathname]
+    def root
+      @project.root
+    end
+
+  end
+
+end

data/lib/detroit/basic_utils.rb

@@ -0,0 +1,66 @@
+module Detroit
+
+  ##
+  # Common utility methods included in all tools.
+  #
+  module BasicUtils
+
+    # Glob for finding root of a project.
+    def root_pattern
+      "{.index,.git,.hg,.svn,_darcs}"
+    end
+ 
+    # Project root directory.
+    def root
+      @root ||= (
+        path = nil
+        home = File.expand_path('~')
+
+        while dir != home && dir != '/'
+          if Dir[root_pattern].first
+            path = dir
+            break
+          end
+          dir = File.dirname(dir)
+        end
+
+        Pathname.new(path || Dir.pwd)
+      )
+    end
+
+    # Configuration.
+    def config
+      @config ||= Config.new(root)
+    end
+
+    #
+    def naming_policy
+      @naming_policy ||= (
+        if config.naming_policy
+          Array(config.naming_policy)
+        else
+          ['down', 'ext']
+        end
+      )
+    end
+
+    #
+    def apply_naming_policy(name, ext)
+      naming_policy.each do |policy|
+        case policy.to_s
+        when /^low/, /^down/
+          name = name.downcase
+        when /^up/
+          name = name.upcase
+        when /^cap/
+          name = name.capitalize
+        when /^ext/
+          name = name + ".#{ext}"
+        end
+      end
+      name
+    end
+
+  end
+
+end

data/lib/detroit/core_ext.rb

@@ -1,137 +1,3 @@
-#__DIR__ = File.dirname(__FILE__)
-
-#Dir[File.join(__DIR__, 'core_ext', '*.rb')].each do |file|
-#  require file
-#end
-
-#require 'facets'
-require 'facets/to_hash'
-require 'facets/module/basename'
-require 'facets/module/alias_accessor'
-require 'facets/pathname'
-#require 'facets/boolean'
-
-class Array
-
-  def to_list
-    self
-  end
-
+Dir[File.dirname(__FILE__) + '/core_ext/**/*.rb'].each do |file|
+  require file
 end
-
-class NilClass
-
-  def to_list
-    []
-  end
-
-end
-
-class String
-
-  # Helper method for cleaning list options.
-  # This will split the option on ':' or ';'
-  # if it is a string, rather than an array.
-  # And it will make sure there are no nil elements.
-
-  def to_list
-    split(/[:;,\n]/).map{ |s| s.strip }
-  end
-
-end
-
-# TODO: Replace these with facets/shellwords !!!
-
-#
-class Array #:nodoc:
-
-  # Convert an array into commandline parameters.
-  # The array is accepted in the format of Ruby
-  # method arguments --ie. [arg1, arg2, ..., hash]
-
-  def to_console
-    #flags = (Hash===last ? pop : {})
-    #flags = flags.to_console
-    #flags + ' ' + join(" ")
-    to_argv.join(' ')
-  end
-
-  # TODO: DEPRECATE
-  alias_method :to_params, :to_console
-
-  #
-  def to_argv
-    flags = (Hash===last ? pop : {})
-    flags = flags.to_argv
-    flags + self
-  end
-
-#   def to_console
-#     flags = (Hash===last ? pop : {})
-#     flags = flags.collect do |f,v|
-#       m = f.to_s.size == 1 ? '-' : '--'
-#       case v
-#       when Array
-#         v.collect{ |e| "#{m}#{f} '#{e}'" }.join(' ')
-#       when true
-#         "#{m}#{f}"
-#       when false, nil
-#         ''
-#       else
-#         "#{m}#{f} '#{v}'"
-#       end
-#     end
-#     return (flags + self).join(" ")
-#   end
-
-end
-
-class Hash
-
-  # Convert a Hash into command line arguments.
-  # The array is accepted in the format of Ruby
-  # method arguments --ie. [arg1, arg2, ..., hash]
-  def to_console
-    to_argv.join(' ')
-  end
-
-  # Convert a Hash into command line parameters.
-  # The array is accepted in the format of Ruby
-  # method arguments --ie. [arg1, arg2, ..., hash]
-  def to_argv
-    flags = map do |f,v|
-      m = f.to_s.size == 1 ? '-' : '--'
-      case v
-      when Array
-        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
-      when true
-        "#{m}#{f}"
-      when false, nil
-        ''
-      else
-        "#{m}#{f}='#{v}'"
-      end
-    end
-  end
-
-  # Turn a hash into arguments.
-  #
-  #   h = { :list => [1,2], :base => "HI" }
-  #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
-  #   h.argumentize(:list) #=> [ [1,2], { :base => "HI" } ]
-  #
-  def argumentize(args_field=nil)
-    config = dup
-    if args_field
-      args = [config.delete(args_field)].flatten.compact
-    else
-      args = []
-    end
-    args << config
-    return args
-  end
-
-  alias_method :command_vector, :argumentize
-
-end
-

data/lib/detroit/{tool/core_ext → core_ext}/facets.rb

@@ -2,6 +2,9 @@
 # see it as a "heavy" dependency. But really that is far from true, consider
 # the facet that the following libs are all that it used.
 
+require 'facets/pathname'
+#require 'facets/boolean'
+
 require 'facets/array/not_empty'
 require 'facets/module/basename'
 require 'facets/module/alias_accessor'

data/lib/detroit/{tool/core_ext → core_ext}/to_console.rb

@@ -1,4 +1,5 @@
 # TODO: Improve the naming scheme of these methods.
+# TODO: Replace these with facets/shellwords ?
 
 #
 class Array #:nodoc:

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

@@ -1,6 +1,8 @@
 module Detroit
 
-  # The Mail utility module provides an easy to use +email+ method.
+  ##
+  # The Mail utility module provides an easy to use `email` method.
+  #
   module EmailUtils
 
     # Email function to easily send out an email.

data/lib/detroit/exec.rb

@@ -0,0 +1,55 @@
+module Detroit
+
+  # Execute a sepcific detroit tool.
+  #
+  # Note this uses the executable gem to automatically
+  # "cli-ify" a tool class.
+  #
+  def self.tool_exec(*argv)
+    require 'executable'
+
+    tool, stop = argv.shift.split(':')     
+
+    raise "No tool specified." unless tool
+    raise "No tool stop specified." unless stop
+
+    begin
+      require "detroit-#{tool}"
+    rescue LoadError
+      raise "Unknown tool. Perhaps try `gem install detroit-#{tool}`."
+    end
+
+    tool_class = Detroit.tools[tool]
+
+    exec_class = Class.new(tool_class) do
+      include Executable
+
+      # TODO: Fix executable, to at least super if defined super.
+      define_method(:initialize) do
+        tool_class.instance_method(:initialize).bind(self).call
+      end
+
+      # Show this message.
+      def help!
+        cli.show_help
+        exit
+      end
+      alias :h! :help!
+
+      define_method(:call) do |*args|
+        if assemble?(stop.to_sym)
+          assemble(stop.to_sym)
+        else
+          raise "#{tool} does not know how to #{stop}."
+        end
+      end
+    end
+
+    #exec_class.send(:define_method, :command_name) do
+    #  tool
+    #end
+
+    exec_class.run(argv)
+  end
+
+end