bones 2.5.1 → 3.0.0

data/lib/bones/app/command.rb

@@ -1,22 +1,25 @@
 
-module Bones
-class App
+class Bones::App::Command
 
-class Command
+  # :stopdoc:
+  DEFAULT_SKELETON = 'default'
+  # :startdoc:
 
-  attr_reader :options
+  attr_reader :stdout
+  attr_reader :stderr
+  attr_reader :config
 
-  def initialize( out = STDOUT, err = STDERR )
-    @out = out
-    @err = err
-    @options = {
-      :skeleton_dir => File.join(mrbones_dir, 'data'),
-      :with_tasks => false,
+  def initialize( opts = {} )
+    @stdout = opts[:stdout] || $stdout
+    @stderr = opts[:stderr] || $stderr
+
+    @config = {
+      :skeleton_dir => File.join(mrbones_dir, DEFAULT_SKELETON),
       :verbose => false,
       :name => nil,
       :output_dir => nil
     }
-    @options[:skeleton_dir] = ::Bones.path('data') unless test(?d, skeleton_dir)
+    @config[:skeleton_dir] = ::Bones.path(DEFAULT_SKELETON) unless test(?d, skeleton_dir)
   end
 
   def run( args )
@@ -26,57 +29,36 @@ class Command
   # The output directory where files will be written.
   #
   def output_dir
-    options[:output_dir]
+    @config[:output_dir]
   end
 
   # The directory where the project skeleton is located.
   #
   def skeleton_dir
-    options[:skeleton_dir]
+    @config[:skeleton_dir]
   end
 
   # The project name from the command line.
   #
   def name
-    options[:name]
+    @config[:name]
   end
 
   # A git or svn repository URL from the command line.
   #
   def repository
-    return options[:repository] if options.has_key? :repository
+    return @config[:repository] if @config.has_key? :repository
     return IO.read(skeleton_dir).strip if skeleton_dir and test(?f, skeleton_dir)
     nil
   end
 
-  # Returns +true+ if we are going to copy the Mr Bones tasks into the
-  # destination directory. Normally this will return +false+.
-  #
-  def with_tasks?
-    options[:with_tasks]
-  end
-
-  #
-  #
-  def copy_tasks( to )
-    fm = FileManager.new(
-      :source => ::Bones.path(%w[lib bones tasks]),
-      :destination => to,
-      :stdout => @out,
-      :stderr => @err,
-      :verbose => verbose?
-    )
-    fm.archive_destination
-    fm.copy
-  end
-
   # Returns +true+ if the user has requested verbose messages.
   #
   def verbose?
-    options[:verbose]
+    @config[:verbose]
   end
 
-  # Returns the .bones resource directory in the user's home directory.
+  # Returns the '.mrbones' resource directory in the user's home directory.
   #
   def mrbones_dir
     return @mrbones_dir if defined? @mrbones_dir
@@ -85,45 +67,142 @@ class Command
     @mrbones_dir = File.expand_path(path)
   end
 
+  # Run a block of code in the given directory.
+  #
+  def in_directory( dir )
+    pwd = File.expand_path(FileUtils.pwd)
+    FileUtils.cd dir
+    yield
+  ensure
+    FileUtils.cd pwd
+  end
+
   #
   #
   def standard_options
-    {
-      :verbose => ['-v', '--verbose', 'enable verbose output',
-          lambda {
-            options[:verbose] = true
-          }],
+    Command.standard_options
+  end
+
+  #
+  #
+  def parse( args )
+    opts = OptionParser.new
+
+    opts.banner = 'NAME'
+    opts.separator "  bones v#{::Bones::VERSION}"
+    opts.separator ''
+
+    if self.class.synopsis
+      opts.separator 'SYNOPSIS'
+      self.class.synopsis.split("\n").each { |line| opts.separator "  #{line.strip}" }
+      opts.separator ''
+    end
+
+    if self.class.description
+      opts.separator 'DESCRIPTION'
+      self.class.description.split("\n").each { |line| opts.separator "  #{line.strip}" }
+      opts.separator ''
+    end
+
+    if self.class.options and not self.class.options.empty?
+      opts.separator 'PARAMETERS'
+      self.class.options.each { |option|
+        case option
+        when Array
+          option << method(option.pop) if option.last =~ %r/^__/
+          opts.on(*option)
+        when String
+          opts.separator("  #{option.strip}")
+        else opts.separator('') end
+      }
+      opts.separator ''
+    end
+
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      stdout.puts opts
+      exit
+    }
+    opts.on_tail ''
+
+    opts.parse! args
+    return opts
+  end
+
+  #
+  #
+  def self.standard_options
+    @standard_options ||= {
+      :verbose => ['-v', '--verbose', 'Enable verbose output.',
+          lambda { config[:verbose] = true }],
+
       :directory => ['-d', '--directory DIRECTORY', String,
-          'project directory to create', '(defaults to project_name)',
-          lambda { |value|
-            options[:output_dir] = value
-          }],
+          'Project directory to create.',  '(defaults to project_name)',
+          lambda { |value| config[:output_dir] = value }],
+
       :skeleton => ['-s', '--skeleton NAME', String,
-          'project skeleton to use',
+          'Project skeleton to use.',
           lambda { |value|
             path = File.join(mrbones_dir, value)
-            if test(?e, path)
-              options[:skeleton_dir] = path 
-            elsif test(?e, value)
-              options[:skeleton_dir] = value
+            if test(?e, value)
+              config[:skeleton_dir] = value
+            elsif test(?e, path)
+              config[:skeleton_dir] = path
             else
-              raise ArgumentError, "Unknown skeleton '#{value}'"
+              raise ArgumentError, "Unknown skeleton '#{value}'."
             end
           }],
-      :with_tasks => ['--with-tasks', 'copy rake tasks to the project folder',
-          lambda {
-            options[:with_tasks] = true
-          }],
+
       :repository => ['-r', '--repository URL', String,
-          'svn or git repository path', 
-          lambda { |value|
-            options[:repository] = value
-          }]
+          'svn or git repository path.',
+          lambda { |value| config[:repository] = value }]
     }
   end
 
-end  # class Command
-end  # class App
-end  # module Bones
+  module ClassMethods
+    def synopsis( *args )
+      @synopsis = args.join("\n") unless args.empty?
+      @synopsis
+    end
+
+    def description( *args )
+      @description = args.join("\n") unless args.empty?
+      @description
+    end
+
+    def summary( *args )
+      @summary = args.join("\n") unless args.empty?
+      @summary
+    end
+
+    def option( *args, &block )
+      args.flatten!
+      block = args.pop if block.nil? and Proc === args.last
+
+      if block
+        args.each { |val|
+          next unless val.instance_of? String
+          next unless val =~ %r/^--(\w+)/
+
+          args << "__#$1"
+          define_method(args.last.to_sym, &block)
+          options << args
+          break
+        }
+      else
+        options << (args.length > 1 ? args : args.first )
+      end
+    end
+
+    def options
+      @options ||= []
+    end
+  end
+
+  def self.inherited( other )
+    other.extend ClassMethods
+  end
+
+end  # class Bones::App::Command
 
 # EOF

data/lib/bones/app/create.rb

@@ -0,0 +1,93 @@
+
+module Bones::App
+class Create < Command
+
+  def self.initialize_create
+    synopsis 'bones create [options] <project_name>'
+
+    summary 'create a new project from a skeleton'
+
+    description <<-__
+Create a new project from a Mr Bones project skeleton. The skeleton can
+be the default project skeleton from the Mr Bones gem or one of the named
+skeletons found in the '~/.mrbones/' folder. A git or svn repository can
+be used as the skeleton if the '--repository' flag is given.
+    __
+
+    option(standard_options[:directory])
+    option(standard_options[:skeleton])
+    option(standard_options[:repository])
+    option(standard_options[:verbose])
+  end
+
+  def self.in_output_directory( *args )
+    @in_output_directory ||= []
+    @in_output_directory.concat(args.map {|str| str.to_sym})
+    @in_output_directory
+  end
+
+  def run
+    raise Error, "Output directory #{output_dir.inspect} already exists." if test ?e, output_dir
+
+    copy_files
+    announce
+
+    in_directory(output_dir) {
+      self.class.in_output_directory.each {|cmd| self.send cmd}
+      fixme
+    }
+  end
+
+  def parse( args )
+    opts = super args
+
+    config[:name] = args.empty? ? nil : args.join('_')
+    config[:output_dir] = name if output_dir.nil?
+
+    if name.nil?
+      stdout.puts opts
+      exit 1
+    end
+  end
+
+  def copy_files
+    fm = FileManager.new(
+      :source => repository || skeleton_dir,
+      :destination => output_dir,
+      :stdout => stdout,
+      :stderr => stderr,
+      :verbose => verbose?
+    )
+
+    fm.copy
+    fm.finalize name
+  rescue Bones::App::FileManager::Error => err
+    FileUtils.rm_rf output_dir
+    msg = "Could not create '#{name}'"
+    msg << " in directory '#{output_dir}'" if name != output_dir
+    msg << "\n\t#{err.message}"
+    raise Error, msg
+  rescue Exception => err
+    FileUtils.rm_rf output_dir
+    msg = "Could not create '#{name}'"
+    msg << " in directory '#{output_dir}'" if name != output_dir
+    msg << "\n\t#{err.inspect}"
+    raise Error, msg
+  end
+
+  def announce
+    msg = "Created '#{name}'"
+    msg << " in directory '#{output_dir}'" if name != output_dir
+    stdout.puts msg
+  end
+
+  def fixme
+    return unless test ?f, 'Rakefile'
+    stdout.puts 'Now you need to fix these files'
+    system "#{::Bones::RUBY} -S rake notes"
+  end
+
+end  # class Create
+end  # module Bones::App
+
+# EOF

data/lib/bones/app/file_manager.rb

@@ -1,11 +1,11 @@
 
-require 'fileutils'
-
-module Bones
-class App
+require 'erb'
 
+module Bones::App
 class FileManager
 
+  Error = Class.new(StandardError)
+
   attr_accessor :source, :destination, :archive, :verbose
   alias :verbose? :verbose
 
@@ -78,12 +78,12 @@ class FileManager
   def _checkout( repotype )
     case repotype
     when :git
-      system('git-clone', source, destination)
+      Git.clone source, destination
       FileUtils.rm_rf(File.join(destination, '.git'))
     when :svn
       system('svn', 'export', source, destination)
     else
-      raise "unknown repository type '#{repotype}'"
+      raise Error, "Unknown repository type '#{repotype}'."
     end
   end
 
@@ -169,7 +169,6 @@ class FileManager
   end
 
 end  # class FileManager
-end  # class App
-end  # module Bones
+end  # module Bones::App
 
 # EOF

data/lib/bones/app/freeze.rb

@@ -0,0 +1,59 @@
+
+module Bones::App
+class Freeze < Command
+
+  def self.initialize_freeze
+    synopsis 'bones freeze [options] [skeleton_name]'
+
+    summary 'create a new skeleton in ~/.mrbones/'
+
+    description <<-__
+Freeze the project skeleton to the current Mr Bones project skeleton.
+If a name is not given, then the default name "default" will be used.
+Optionally a git or svn repository can be frozen as the project
+skeleton.
+    __
+
+    option(standard_options[:repository])
+    option(standard_options[:verbose])
+  end
+
+  def run
+    fm = FileManager.new(
+      :source => repository || ::Bones.path(DEFAULT_SKELETON),
+      :destination => output_dir,
+      :stdout => stdout,
+      :stderr => stderr,
+      :verbose => verbose?
+    )
+
+    fm.archive_destination
+    return freeze_to_repository if repository
+
+    fm.copy
+
+    stdout.puts "Project skeleton #{name.inspect} " <<
+                "has been frozen to Mr Bones #{::Bones::VERSION}"
+  end
+
+  def parse( args )
+    opts = super args
+    config[:name] = args.empty? ? DEFAULT_SKELETON : args.join('_')
+    config[:output_dir] = File.join(mrbones_dir, name)
+  end
+
+  # Freeze the project skeleton to the git or svn repository that the user
+  # passed in on the command line. This essentially creates an alias to the
+  # reposiory using the name passed in on the command line.
+  #
+  def freeze_to_repository
+    FileUtils.mkdir_p(File.dirname(output_dir))
+    File.open(output_dir, 'w') {|fd| fd.puts repository}
+    stdout.puts "Project skeleton #{name.inspect} " <<
+                "has been frozen to #{repository.inspect}"
+  end
+
+end  # class Freeze
+end  # module Bones::App
+
+# EOF