bones 2.1.1 → 2.2.0

data/lib/bones/app/create_command.rb

@@ -0,0 +1,87 @@
+
+module Bones
+class App
+
+class CreateCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || skeleton_dir,
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+    raise "Output directory already exists #{output_dir.inspect}" if test(?e, fm.destination)
+
+    begin
+      fm.copy
+      copy_tasks(File.join(output_dir, 'tasks')) if with_tasks?
+      fm.finalize name
+
+      pwd = File.expand_path(FileUtils.pwd)
+      msg = "Created '#{name}'"
+      msg << " in directory '#{output_dir}'" if name != output_dir
+      @out.puts msg
+
+      if test(?f, File.join(output_dir, 'Rakefile'))
+        begin
+          FileUtils.cd output_dir
+          system "rake manifest:create 2>&1 > #{::Bones::DEV_NULL}"
+          @out.puts "Now you need to fix these files"
+          system "rake notes"
+        ensure
+          FileUtils.cd pwd
+        end
+      end
+    rescue Exception => err
+      FileUtils.rm_rf output_dir
+      msg = "Could not create '#{name}'"
+      msg << " in directory '#{output_dir}'" if name != output_dir
+      raise msg
+    end
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones create [options] <project_name>'
+
+    opts.separator ''
+    opts.separator "  Create a new project from a Mr Bones project skeleton. The skeleton can"
+    opts.separator "  be the default project skeleton from the Mr Bones gem or one of the named"
+    opts.separator "  skeletons found in the '~/.mrbones/' folder. A git or svn repository can"
+    opts.separator "  be used as the skeleton if the '--repository' flag is given."
+
+    opts.separator ''
+    opts.on(*std_opts[:directory])
+    opts.on(*std_opts[:skeleton])
+    opts.on(*std_opts[:repository])
+    opts.on(*std_opts[:with_tasks])
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+    options[:name] = args.empty? ? nil : args.join('_')
+
+    if name.nil?
+      @out.puts opts
+      exit 1
+    end
+    options[:output_dir] = name if output_dir.nil?
+  end
+
+end  # class CreateCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/file_manager.rb

@@ -0,0 +1,176 @@
+
+require 'fileutils'
+
+module Bones
+class App
+
+class FileManager
+
+  attr_accessor :source, :destination, :archive, :verbose
+  alias :verbose? :verbose
+
+  #
+  #
+  def initialize( opts = {} )
+    self.source = opts[:source]
+    self.destination = opts[:destination]
+    self.verbose = opts[:verbose]
+
+    @out = opts[:stdout] || $stdout
+    @err = opts[:stderr] || $stderr
+  end
+
+  # Sets the destination where files will be copied to. At the same time an
+  # archive directory is configured. This is simply the destination
+  # directory with a '.archive' extension.
+  #
+  def destination=( str )
+    @destination = str
+    @archive = str + '.archive' if str
+  end
+
+  # If the source is a repository this method returns the type of
+  # repository. This will be :git for Git repositories and :svn for
+  # Subversion repositories. Otherwise, +nil+ is returned.
+  #
+  def repository
+    return :git if source =~ %r/\.git\/?$/i
+    return :svn if source =~ %r/^(svn(\+ssh)?|https?|file):\/\//i
+    nil
+  end
+  alias :repository? :repository
+
+  #
+  #
+  def archive_destination
+    return false unless test(?e, destination)
+
+    @out.puts "archiving #{destination}" if verbose?
+    FileUtils.rm_rf(archive)
+    FileUtils.mv(destination, archive)
+    true
+  end
+
+  #
+  #
+  def copy
+    if repository?
+      _checkout(repository)
+    else
+      _files_to_copy.each {|fn| _cp(fn)}
+    end
+  end
+
+  #
+  #
+  def finalize( name )
+    name = name.to_s
+    return if name.empty?
+
+    self.destination = _rename(destination, name)
+    _erb(name)
+
+    self
+  end
+
+  #
+  #
+  def _checkout( repotype )
+    case repotype
+    when :git
+      system('git-clone', source, destination)
+      FileUtils.rm_rf(File.join(destination, '.git'))
+    when :svn
+      system('svn', 'export', source, destination)
+    else
+      raise "unknown repository type '#{repotype}'"
+    end
+  end
+
+  #
+  #
+  def _rename( filename, name )
+    newname = filename.gsub(%r/NAME/, name)
+
+    if filename != newname
+      raise "cannot rename '#{filename}' to '#{newname}' - file already exists" if test(?e, newname)
+      FileUtils.mv(filename, newname)
+    end
+
+    if test(?d, newname)
+      Dir.glob(File.join(newname, '*')).each {|fn| _rename(fn, name)}
+    end
+    newname
+  end
+
+  #
+  #
+  def _erb( name )
+    binding = _erb_binding(name)
+
+    Dir.glob(File.join(destination, '**', '*')).each do |fn|
+      next unless test(?f, fn) and '.bns' == File.extname(fn)
+
+      txt = ERB.new(File.read(fn), nil, '-').result(binding)
+      File.open(fn.sub(%r/\.bns$/, ''), 'w') {|fd| fd.write(txt)}
+      FileUtils.rm_f(fn)
+    end
+    self
+  end
+
+  #
+  #
+  def _erb_binding( name )
+    obj = Object.new
+    class << obj
+      alias :__binding__ :binding
+      instance_methods.each do |m|
+        undef_method m unless m[%r/^__/]
+      end
+      attr_accessor :name, :classname
+    end
+    obj.name = name
+    obj.classname = name.tr('-','_').split('_').map {|x| x.capitalize}.join
+    obj.__send__(:__binding__)
+  end
+
+  # Returns a list of the files to copy from the source directory to
+  # the destination directory.
+  #
+  def _files_to_copy
+    rgxp = %r/\A#{source}\/?/
+    exclude = %r/tmp$|bak$|~$|CVS|\.svn/
+
+    ary = Dir.glob(File.join(source, '**', '*')).map do |filename|
+      next if exclude =~ filename
+      next if test(?d, filename)
+      filename.sub rgxp, ''
+    end
+
+    ary.compact!
+    ary.sort!
+    ary
+  end
+
+  # Copy a file from the Bones prototype project location to the user
+  # specified project location. A message will be displayed to the screen
+  # indicating that the file is being created.
+  #
+  def _cp( file )
+    dir = File.dirname(file)
+    dir = (dir == '.' ? destination : File.join(destination, dir))
+    dst = File.join(dir,  File.basename(file))
+    src = File.join(source, file)
+
+    @out.puts(test(?e, dst) ? "updating #{dst}" : "creating #{dst}") if verbose?
+    FileUtils.mkdir_p(dir)
+    FileUtils.cp src, dst
+
+    FileUtils.chmod(File.stat(src).mode, dst)
+  end
+
+end  # class FileManager
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/freeze_command.rb

@@ -0,0 +1,72 @@
+
+module Bones
+class App
+
+class FreezeCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || ::Bones.path('data'),
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+
+    fm.archive_destination
+    return freeze_to_repository if repository
+
+    fm.copy
+    copy_tasks(File.join(output_dir, 'tasks')) if with_tasks?
+
+    @out.puts "Project skeleton #{name.inspect} " <<
+              "has been frozen to Mr Bones #{::Bones::VERSION}"
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones freeze [options] [skeleton_name]'
+
+    opts.separator ''
+    opts.separator '  Freeze the project skeleton to the current Mr Bones project skeleton.'
+    opts.separator '  If a name is not given, then the default name "data" will be used.'
+    opts.separator '  Optionally a git or svn repository can be frozen as the project'
+    opts.separator '  skeleton.'
+
+    opts.separator ''
+    opts.on(*std_opts[:repository])
+    opts.on(*std_opts[:with_tasks])
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+    options[:name] = args.empty? ? 'data' : args.join('_')
+    options[: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
+    File.open(output_dir, 'w') {|fd| fd.puts repository}
+    @out.puts "Project skeleton #{name.inspect} " <<
+              "has been frozen to #{repository.inspect}"
+  end
+
+
+end  # class FreezeCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/info_command.rb

@@ -0,0 +1,58 @@
+
+module Bones
+class App
+
+class InfoCommand < Command
+
+  def run( args )
+    parse args
+
+    skeleton_dir = File.join(mrbones_dir, 'data')
+    skeleton_dir = ::Bones.path('data') unless test(?d, skeleton_dir)
+
+    msg  = "\n"
+    msg << "The default project skeleton will be copied from:\n"
+    msg << "    " << skeleton_dir << "\n\n"
+
+    fmt = "    %-12s => %s\n"
+    msg << "Available projects skeletons are:\n"
+    Dir.glob(File.join(mrbones_dir, '*')).sort.each do |fn|
+      next if fn =~ %r/\.archive$/
+      next if File.basename(fn) == 'data'
+
+      if test(?f, fn)
+        msg << fmt % [File.basename(fn), File.read(fn).strip]
+      else
+        msg << "    " << File.basename(fn) << "\n"
+      end
+    end
+
+    @out.puts msg
+    @out.puts
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones info'
+
+    opts.separator ''
+    opts.separator '  Shows information about available skeletons'
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+  end
+
+end  # class InfoCommand
+end  # class App
+end  # module Bones
+
+# EOF

data/lib/bones/app/unfreeze_command.rb

@@ -0,0 +1,53 @@
+
+module Bones
+class App
+
+class UnfreezeCommand < Command
+
+  def run( args )
+    parse args
+
+    fm = FileManager.new(
+      :source => repository || ::Bones.path('data'),
+      :destination => output_dir,
+      :stdout => @out,
+      :stderr => @err,
+      :verbose => verbose?
+    )
+
+    if fm.archive_destination
+      @out.puts "Project skeleton #{name.inspect} has been unfrozen"
+    else
+      @out.puts "Project skeleton #{name.inspect} is not frozen " <<
+                "(no action taken)"
+    end
+  end
+
+  def parse( args )
+    std_opts = standard_options
+
+    opts = OptionParser.new
+    opts.banner = 'Usage: bones unfreeze [skeleton_name]'
+
+    opts.separator ''
+    opts.separator "  Removes the named skeleton from the '~/.mrbones/' folder. If a name is"
+    opts.separator "  not given then the default skeleton is removed."
+
+    opts.separator ''
+    opts.separator '  Common Options:'
+    opts.on_tail( '-h', '--help', 'show this message' ) {
+      @out.puts opts
+      exit
+    }
+
+    # parse the command line arguments
+    opts.parse! args
+    options[:name] = args.empty? ? 'data' : args.join('_')
+    options[:output_dir] = File.join(mrbones_dir, name)
+  end
+
+end  # class UnfreezeCommand
+end  # class App
+end  # module Bones
+
+# EOF