doozer 0.2.0

data/lib/doozer/watcher.rb

@@ -0,0 +1,369 @@
+## taken from: http://paulhorman.com/filesystemwatcher/
+require "md5"
+require "thread"
+
+# The Runnable module is a generic mixin for including state and
+# status information in a class
+module ServiceState
+  # state constants
+  NOT_STARTED = 0
+  STARTED = 1
+  STOPPED = 2
+  CONFIGURED = 3
+  
+  attr_reader :startTime, :endTime
+  
+  # Initialize the state information
+  def initializeState()
+    @configured = false
+    @startTime = 0
+    @stopTime = 0
+    
+    @stateMutex = Mutex.new()
+    @stopWhen = nil
+    setState(NOT_STARTED)
+  end
+  
+  # Set the callback for when someone calls setState. You
+  # will be passed the state CONSTANT being set
+  def onStateChange(&callbackBlock)
+    @stateCallback = callbackBlock
+  end
+  
+  # All methods, inside this class or not, should use this
+  # method to change the state of the JobRunner
+  # @param newState The new state value
+  def setState(newState)
+    @stateMutex.synchronize {
+      if newState == CONFIGURED then
+	      @configured = true
+      else
+	      @state = newState
+      	if isStarted? then
+      	  @startTime = Time.now()
+      	elsif isStopped?
+      	  @stopTime = Time.now()
+      	end
+      end
+    }
+    if defined?(@stateCallback) then
+      @stateCallback.call(newState)
+    end
+  end
+  
+  def isConfigured?
+    return @configured
+  end
+
+  def isStarted?
+    return @state == STARTED
+  end
+
+  def isStopped?
+    if @state == STOPPED then
+      return true
+    elsif @stopWhen && @stopWhen.call() then
+      setState(STOPPED)
+      return true
+    else
+      return false
+    end
+  end   
+
+  def stopWhen(&block)
+    @stopWhen = block
+  end
+end
+
+
+# This class will watch a directory or a set of directories and alert you of
+# new files, modified files, deleted files. You can optionally only be alerted
+# when a files md5 hash has been changed so you only are alerted to real changes.
+# this of course means slower performance and higher cpu/io usage.
+class FileSystemWatcher
+  include ServiceState
+
+  CREATED = 0
+  MODIFIED = 1
+  DELETED = 2
+
+  # the time to wait before checking the directories again
+  attr_accessor :sleepTime, :priority, :mongrel
+
+  # you can optionally use the file contents md5 to detect if a file has changed
+  attr_accessor :useMD5
+
+  attr_accessor :foundFiles, :files, :directories
+
+  def initialize(dir=nil, expression="**/*")
+    @sleepTime = 5
+    @useMD5 = false
+    @priority = 0
+    @stopWhen = nil
+
+    @directories = Array.new()
+    @files = Array.new()
+
+    @foundFiles = nil
+    @firstLoad = true
+    @watchThread = nil
+    
+    initializeState()
+
+    if dir then
+      addDirectory(dir, expression)
+    end
+  end
+
+  # add a directory to be watched
+  # @param dir the directory to watch
+  # @param expression the glob pattern to search under the watched directory
+  def addDirectory(dir, expression="**/*")
+    if FileTest.exists?(dir) && FileTest.readable?(dir) then
+      @directories << FSWatcher::Directory.new(dir, expression)
+    else
+      raise FSWatcher::InvalidDirectoryError, "Dir '#{dir}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeDirectory(dir)
+    @directories.delete(dir)
+  end
+
+  # add a specific file to the watch list
+  # @param file the file to watch
+  def addFile(file)
+    if FileTest.exists?(file) && FileTest.readable?(file) then
+      @files << file
+    else
+      raise FSWatcher::InvalidFileError, "File '#{file}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeFile(file)
+    @files.delete(file)
+  end
+
+  # start watching the specified files/directories
+  def start(&block)
+    if isStarted? then
+      raise RuntimeError, "already started"
+    end
+
+    setState(STARTED)
+
+    @firstLoad = true
+    @foundFiles = Hash.new()
+
+    # we watch in a new thread
+    @watchThread = Thread.new {
+      # we will be stopped if someone calls stop or if someone set a stopWhen that becomes true
+      while !isStopped? do
+	      if (!@directories.empty?) or (!@files.empty?) then	
+      	  # this will hold the list of the files we looked at this iteration
+      	  # allows us to not look at the same file again and also to compare
+      	  # with the foundFile list to see if something was deleted
+      	  alreadyExamined = Hash.new()
+	  
+      	  # check the files in each watched directory
+      	  if not @directories.empty? then
+      	    @directories.each { | dirObj |
+      	      examineFileList(dirObj.getFiles(), alreadyExamined, &block)
+      	    }
+      	  end
+	  
+      	  # now examine any files the user wants to specifically watch
+      	  examineFileList(@files, alreadyExamined, &block) if not @files.empty?
+	  
+      	  # see if we have to delete files from our found list
+      	  if not @firstLoad then
+      	    if not @foundFiles.empty? then
+      	      # now diff the found files and the examined files to see if
+      	      # something has been deleted
+      	      allFoundFiles = @foundFiles.keys()
+      	      allExaminedFiles = alreadyExamined.keys()
+      	      intersection = allFoundFiles - allExaminedFiles
+      	      intersection.each { |fileName|
+                  # callback
+                  block.call(DELETED, fileName)
+                  # remove deleted file from the foundFiles list
+                  @foundFiles.delete(fileName)
+                }	  
+              end
+            else
+              @firstLoad = false
+            end
+          end
+
+          # go to sleep
+          sleep(@sleepTime)
+        end
+      }
+    
+    # set the watch thread priority
+    @watchThread.priority = @priority
+
+  end
+
+  # kill the filewatcher thread
+  def stop()
+    setState(STOPPED)
+    @watchThread.wakeup()
+  end
+
+  # wait for the filewatcher to finish
+  def join()
+    @watchThread.join() if @watchThread
+  end
+
+
+  private
+
+  # loops over the file list check for new or modified files
+  def examineFileList(fileList, alreadyExamined, &block)
+    fileList.each { |fileName|
+      # expand the file name to the fully qual path
+      fullFileName = File.expand_path(fileName)
+
+      # dont examine the same file 2 times
+      if not alreadyExamined.has_key?(fullFileName) then
+    	# we cant do much if the file isnt readable anyway
+    	  if File.readable?(fullFileName) then
+      	  # set that we have seen this file
+      	  alreadyExamined[fullFileName] = true
+	  
+      	  # get the file info
+      	  modTime, size = File.mtime(fullFileName), File.size(fullFileName)
+	  
+      	  # on the first iteration just load all of the files into the foundList
+      	  if @firstLoad then
+      	    @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size, false, @useMD5)
+      	  else
+      	    # see if we have found this file already
+      	    foundFile = @foundFiles[fullFileName]
+
+      	    if foundFile then
+        	    # if a file is marked as new, we still need to make sure it isnt still
+        	    # being written to. we do this by checking the file sizes.
+      	    
+        	    if foundFile.isNew? then
+              		# if the file size is the same then it is probably done being written to
+              		# unless the writer is really slow
+              		if size == foundFile.size then		  
+              		  # callback
+              		  block.call(CREATED, fullFileName)
+		  
+              		  # mark this file as a changed file now
+              		  foundFile.updateModTime(modTime)
+		  
+              		  # generate the md5 for the file since we know it is done
+              		  # being written to
+              		  foundFile.genMD5() if @useMD5
+              		else
+              		  # just update the size so we can check again at the next iteration
+              		  foundFile.updateSize(size)
+              		end
+		
+        	    elsif modTime > foundFile.modTime then
+
+          	      # if the mod times are different on files we already have
+                  # found this is an update		
+                  willYield = true
+
+                  # if we are using md5's then compare them
+                  if @useMD5 then
+                    filesMD5 = FSWatcher.genFileMD5(fullFileName)
+                    if filesMD5 && foundFile.md5 then
+                      if filesMD5.to_s == foundFile.md5.to_s then
+                        willYield = false
+                      end
+                    end
+                    # if we are yielding then the md5s are dif so
+                    # update the cached md5 value
+                    foundFile.setMD5(filesMD5) if willYield
+                  end
+                  block.call(MODIFIED, fullFileName) if willYield		
+                  foundFile.updateModTime(modTime)
+      	      end
+
+      	    else
+      	      # this is a new file for our list. dont update the md5 here since
+      	      # the file might not yet be done being written to
+      	      @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size)
+      	    end
+      	  end
+      	end
+      end
+    }
+  end
+end
+
+# Util classes for the FileSystemWatcher
+module FSWatcher
+  # The directory to watch
+  class Directory
+    attr_reader :dir, :expression
+
+    def initialize(dir, expression)
+      @dir, @expression = dir, expression
+      @dir.chop! if @dir =~ %r{/$}
+    end
+
+    def getFiles()
+      return Dir[@dir + "/" + @expression]
+    end
+  end
+
+  # A FoundFile entry for the FileSystemWatcher
+  class FoundFile
+    attr_reader :status, :fileName, :modTime, :size, :md5
+
+    def initialize(fileName, modTime, size, isNewFile=true, useMD5=false)
+      @fileName, @modTime, @size, @isNewFile  = fileName, modTime, size, isNewFile      
+      @md5 = nil
+      if useMD5 then
+        genMD5()
+      end
+    end
+
+    def updateModTime(modTime)
+      @modTime = modTime
+      @isNewFile = false
+    end
+
+    def updateSize(size)
+      @size = size
+    end
+
+    def isNew?
+      return @isNewFile
+    end
+
+    def setMD5(newMD5)
+      @md5 = newMD5
+    end
+
+    # generate my files md5 value
+    def genMD5()
+      @md5 = FSWatcher.genFileMD5(@fileName)
+    end
+  end
+
+  # utility function for generating md5s from a files contents
+  def FSWatcher.genFileMD5(fileName)
+    if FileTest.file?(fileName) then      
+      f = File.open(fileName)
+      contents = f.read()
+      f.close()
+      return MD5.new(contents) if contents
+    end
+    return nil
+  end
+
+  # if the directory you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidDirectoryError < StandardError; end
+
+  # if the file you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidFileError < StandardError; end
+end
+  

data/lib/generator/generator.rb

@@ -0,0 +1,548 @@
+module Doozer
+  
+  #= Generate Project Skeletons and Files
+  class Generator
+    APP_PATH = Dir.pwd
+    PATH = File.expand_path( File.join(File.dirname(__FILE__), '..', '..', 'templates') )
+    
+    def self.run(*args)
+      return help_all if args.empty?
+      
+      action = args[0].downcase
+      if not ['generate', '-h', '--help', '-v', '--version'].include?(action)
+        skeleton(action)
+      else
+        if action == 'generate'
+          
+          action = args[1]
+          case action.to_sym
+            when :model, :"-M"
+              if args.length == 3
+                name = args[2]
+                Doozer::Configs.load(:development)
+                model(Doozer::Configs.orm, name.downcase)
+              else
+                help?(:help, :model)
+              end
+            when :view, :"-V"
+              args.push('html') if args.length == 3
+              if args.length == 4
+                name = args[2]
+                formats = args[3].split(',')
+                view(name.downcase, formats)
+              else
+                help?(:help, :view)
+              end
+            when :controller, :"-C"
+              if args.length == 3
+                name = args[2]
+                controller(name.downcase)
+              else
+                help?(:help, :controller)
+              end
+            when :helper, :"-H"
+              if args.length == 3
+                name = args[2]
+                helper(name.downcase)
+              else
+                help?(:help, :helper)
+              end            
+            when :db, :migrate, :migration, :"-D"
+              if args.length == 3
+                name = args[2]
+                Doozer::Configs.load(:development)
+                migrate(Doozer::Configs.orm, name.downcase)
+              else
+                help?(:help, :migrate)
+              end
+            when :task, :"-T"
+              if args.length == 3
+                name = args[2]
+                task(name.downcase)
+              else
+                help?(:help, :task)
+              end            
+            else
+            help_all
+          end
+        elsif ['-v', '--version'].include?(action)
+          p "Doozer #{Doozer::Version::STRING}"
+        else
+          help_all
+        end
+      end
+    end
+    
+    def self.help_all
+      printf "Doozer Version: #{Doozer::Version::STRING}\n"
+      printf "Doozer commands:\n"
+      help(:project)
+      help(:model)
+      help(:view)
+      help(:controller)
+      help(:helper)
+      help(:migrate)
+      help(:task)
+    end
+    
+    def self.controller(name)
+      return if help?(name, :controller) 
+      printf "Generating File(s)..."
+      path = "#{APP_PATH}/app/controllers/#{name.downcase}_controller.rb"
+      if not File.exist?(path)
+        p "-- Generating Controller: #{path}"
+        file = File.new(path, "w+")
+        if file
+            template = "class #{Doozer::Lib.classify(name)}Controller < ApplicationController\nend"
+            file.syswrite(template)
+            #make the view directory for this controller
+            path = "#{APP_PATH}/app/views/#{name.downcase}"
+            if not File.exist?(path)
+                p "-- Generating View Folder: #{path}"
+                FileUtils.mkdir path
+            end
+        else
+           p "Unable to open file!"
+        end
+      else
+        p "-- Skipping: #{path} (already exists)"
+      end      
+    end
+
+    def self.model(orm, name)
+      return if help?(name, :model)       
+      raise "No ORM is defined. Please set this in database.yml" if orm.nil?
+      p "Loaded ORM: #{orm}"        
+      path = "#{APP_PATH}/app/models/#{name}.rb"
+      if not File.exist?(path)
+        p "-- Generating Model: #{path}"
+        file = File.new(path, "w+")
+        if file
+           template = eval("model_#{orm}('#{name}')")
+           file.syswrite(template)
+        else
+           p "Unable to open file!"
+        end
+      else
+        p "-- Skipping: #{path} (already exists)"
+      end
+    end
+    def self.model_active_record(name)
+      klass=Doozer::Lib.classify(name)
+      return """#= #{klass}
+class #{klass} < ActiveRecord::Base
+end 
+"""
+    end      
+    def self.model_data_mapper(name)
+      klass = Doozer::Lib.classify(name)
+      return """#= #{klass}
+class #{klass}
+  include DataMapper::Resource
+  property :id,         Serial
+end
+            """
+    end
+    def self.model_sequel(name)
+      klass = Doozer::Lib.classify(name)
+      return """ #see http://sequel.rubyforge.org/rdoc/index.html
+#= #{klass}
+class #{klass} < Sequel::Model
+end 
+"""
+    end
+
+    def self.view(view, formats)
+      return if help?(view, :view) 
+      printf "Generating View File(s)..."
+      raise "Not sure which controller to associate this view with. Needs to be controller_name/action_name. Example: index/login" if not view.index('/')
+      formats.each{|f|
+        file="#{APP_PATH}/app/views/#{view}.#{f.strip}.erb"
+        if not File.exist?(file)
+          p "-- Generating: #{file}"
+          FileUtils.touch file
+        else
+          p "-- Skipping: #{file} (already exists)"
+        end
+      }
+    end
+    
+    def self.migrate(orm, name)
+      return if help?(name, :migrate)
+    
+      raise "No ORM is defined. Please set this in database.yml" if orm.nil?      
+      version = migrate_next
+      p "Loaded ORM: #{orm}"
+      path = "#{APP_PATH}/db/#{version}_#{name.downcase}.rb"
+      if not File.exist?(path)
+        p "-- Generating Migration: #{path}"
+        file = File.new(path, "w+")
+        if file
+           template = eval("migrate_#{orm}('#{name}')")
+           file.syswrite(template)
+        else
+           p "Unable to open file!"
+        end
+      else
+        p "-- Skipping: #{path} (already exists)"
+      end
+    end
+    def self.migrate_next
+      migrations = Dir.glob(File.join(APP_PATH,'db/*_*.rb')).reverse
+      for m in migrations
+        file = m.split('/').last
+        if file.index('_')
+          num = file.split('_').first
+          return "%03d" % (num.to_i + 1) if num.index('0')
+        end
+      end
+      return "%03d" % 1
+    end
+    def self.migrate_active_record(name)
+      klass = Doozer::Lib.classify(name)
+      return """
+class #{klass} < ActiveRecord::Migration
+  def self.up
+    ActiveRecord::Base.transaction do
+    end
+  end
+  def self.down
+    ActiveRecord::Base.transaction do
+    end
+  end
+end
+"""
+    end
+    def self.migrate_data_mapper(name)
+      klass = Doozer::Lib.classify(name)
+      return """
+# See for more details
+# http://datamapper.rubyforge.org/dm-core/
+# http://datamapper.rubyforge.org/dm-more/
+# http://github.com/datamapper/dm-more/tree/master/dm-migrations
+require 'dm-more'
+class #{klass}
+  def self.up
+  end
+  def self.down
+  end
+end
+"""
+    end
+    def self.migrate_sequel(name)
+      klass = Doozer::Lib.classify(name)
+      return """
+class #{klass}
+  def self.db
+    Doozer::Configs.db
+  end
+  def self.up
+    # db.create_table :name do
+    # end
+  end
+  def self.down
+    # db.drop_table :name
+  end
+end
+"""
+    end
+    
+    def self.task(name)
+      return if help?(name, :task)
+      p "Generating file..."        
+      path = "#{APP_PATH}/tasks/#{name}.rb"
+      if not File.exist?(path)
+        p "-- Generating Task: #{path}"
+        file = File.new(path, "w+")
+        if file
+           klass = Doozer::Lib.classify(name)
+           template = """
+#= Task #{klass}
+class #{klass}
+  def self.run
+      #place your task here
+  end
+end
+"""
+           file.syswrite(template)
+        else
+           p "Unable to open file!"
+        end
+      else
+        p "-- Skipping: #{path} (already exists)"
+      end
+    end
+
+    def self.helper(name)
+      return if help?(name, :helper)
+      p "Generating file..."        
+      path = "#{APP_PATH}/app/helpers/#{name}_helper.rb"
+      if not File.exist?(path)
+        p "-- Generating Helper: #{path}"
+        file = File.new(path, "w+")
+        if file
+           klass = Doozer::Lib.classify(name)
+           template = """
+#= #{klass}Helper
+module #{klass}Helper
+end
+"""
+           file.syswrite(template)
+        else
+           p "Unable to open file!"
+        end
+      else
+        p "-- Skipping: #{path} (already exists)"
+      end
+    end
+    
+    def self.help?(name, action=nil)
+      if name.to_sym == :"-h" or name == :help
+        printf "doozer commands:\n"
+        help(action)
+        return true
+      end
+      return false
+    end
+    def self.help(action=nil)
+      h = ""
+      case action
+
+        when :project
+          h += """
+Project - Create a new Doozer skeleton.
+  Command: doozer project_name 
+  Example: doozer hello_world\n"""
+        when :model, :"-M"
+          h += """
+Model - Create a new model file in project/app/models with a class name of ModelName for the configured ORM.
+  Command: doozer generate (model or -M) model_name
+  Example: doozer generate model user\n"""
+        when :view, :"-V"
+          h += """
+View - Create a view erb file in project/app/views for each of the provided formats. If format not specified an html format is automatically created.
+  Command: doozer generate (view or -V) controller_name/action_name format_csv
+  Example: doozer generate view admin/login html,xml,json,etc\n"""
+        when :controller, :"-C"
+          h += """
+Controller - Create a controller file in project/app/controllers (and view folder) with a class name ControllerName.
+    Command: doozer generate (controller or -C) controller_name 
+    Example: doozer generate controller admin\n"""
+        when :helper, :"-H"
+          h += """
+Helper - Create a helper file in project/app/helpers with the module name of HelperName. '_helper' is automatically appended to the helper_name.
+    Command: doozer generate (helper or -H) helper_name 
+    Example: doozer generate helper helper_name\n"""    
+        when :db, :migrate, :migration, :"-D"
+          h += """
+Migration - Create a migration file in project/db with the next available version number and with a class name of MigrationName for the specified ORM.
+    Command: doozer generate (db, migrate, migration or -D) migration_name 
+    Example: doozer generate migrate create_user\n"""
+        when :task, :"-T"
+          h += """
+Task - Create a task file in project/tasks with the class name of TaskName.
+    Command: doozer generate (task or -T) task_name 
+    Example: doozer generate task task_name\n"""
+      end
+      printf h
+    end
+
+    # TODO: Dry this up...
+    def self.skeleton(name)
+      
+      # create application skeleton
+      if not File.exist?(name)
+        p "Creating #{name}/"
+        system("mkdir #{name}")
+      else
+        p "Skipping application directory (already exists)"
+      end
+
+      #create app folder
+      if not File.exist?("#{name}/app")
+        p "Creating app directory"
+        system("mkdir #{name}/app")
+      else
+        p "Skipping #{name}/app directory (already exists)"
+      end
+      
+      #copy controllers
+      if not File.exist?("#{name}/app/controllers")
+        p "Creating #{name}/app/controllers directory and files"
+        system("mkdir #{name}/app/controllers")
+        system("cp #{skeleton_path 'app/controllers/*.rb'} #{name}/app/controllers")
+      else
+        p "Skipping #{name}/app/controllers directory (already exists)"
+      end
+
+      #copy models
+      if not File.exist?("#{name}/app/models")
+        p "Creating #{name}/app/models directory and files"
+        system("mkdir #{name}/app/models")
+      else
+        p "Skipping #{name}/app/models directory (already exists)"
+      end
+
+      #copy views
+      if not File.exist?("#{name}/app/views")
+        p "Creating #{name}/app/views directory and files"
+        system("mkdir #{name}/app/views")
+      else
+        p "Skipping #{name}/app/views directory (already exists)"
+      end
+
+      #copy views/layouts
+      if not File.exist?("#{name}/app/views/layouts")
+        p "Creating #{name}/app/views/layouts directory and files"
+        system("mkdir #{name}/app/views/layouts")
+        system("cp #{skeleton_path 'app/views/layouts/*.erb'} #{name}/app/views/layouts")
+      else
+        p "Skipping #{name}/app/views/layouts directory (already exists)"
+      end
+
+      #copy views/index
+      if not File.exist?("#{name}/app/views/index")
+        p "Creating #{name}/app/views/index directory and files"
+        system("mkdir #{name}/app/views/index")
+        system("cp #{skeleton_path 'app/views/index/*.erb'} #{name}/app/views/index")
+      else
+        p "Skipping #{name}/app/views/index directory (already exists)"
+      end
+
+      #copy views/global
+      if not File.exist?("#{name}/app/views/global")
+        p "Creating #{name}/app/views/global directory and files"
+        system("mkdir #{name}/app/views/global")
+        system("cp #{skeleton_path 'app/views/global/*.erb'} #{name}/app/views/global")
+      else
+        p "Skipping #{name}/app/views/global directory (already exists)"
+      end
+
+      #copy helpers
+      if not File.exist?("#{name}/app/helpers")
+        p "Creating #{name}/app/helpers directory and files"
+        system("mkdir #{name}/app/helpers")
+        system("cp #{skeleton_path 'app/helpers/*.rb'} #{name}/app/helpers")  
+      else
+        p "Skipping #{name}/app/helpers directory (already exists)"
+      end
+
+      #copy configs
+      if not File.exist?("#{name}/config")
+        p "Creating #{name}/config directory and files"
+        system("mkdir #{name}/config")
+        system("cp #{skeleton_path 'config/*.yml'} #{name}/config")
+        system("cp #{skeleton_path 'config/*.rb'} #{name}/config")
+        
+        ## load boot.erb replace version number and save as boot.rb
+        
+      else
+        p "Skipping #{name}/config directory (already exists)"
+      end
+
+      # create log folder
+      if not File.exist?("#{name}/log")
+        p "Creating #{name}/log directory"
+        system("mkdir #{name}/log")
+      else
+        p "Skipping #{name}/log directory (already exists)"
+      end
+
+      #copy db
+      if not File.exist?("#{name}/db")
+        p "Creating #{name}/db directory and files"
+        system("mkdir #{name}/db")
+      else
+        p "Skipping #{name}/db directory (already exists)"
+      end
+
+      #copy lib
+      if not File.exist?("#{name}/lib")
+        p "Creating #{name}/lib directory and files"
+        system("mkdir #{name}/lib")
+      else
+        p "Skipping #{name}/lib directory (already exists)"
+      end
+
+      #copy script
+      if not File.exist?("#{name}/script")
+        p "Creating #{name}/script directory and files"
+        system("mkdir #{name}/script")
+        system("cp #{skeleton_path 'script/*'} #{name}/script")
+      else
+        p "Skipping #{name}/script directory (already exists)"
+      end
+
+      #copy static
+      if not File.exist?("#{name}/static")
+        p "Creating #{name}/static directory and files"
+        system("mkdir #{name}/static")
+        system("cp #{skeleton_path 'static/*.*'} #{name}/static/")
+      else
+        p "Skipping #{name}/static directory (already exists)"
+      end
+
+      #copy static/images
+      if not File.exist?("#{name}/static/images")
+        p "Creating #{name}/script/images directory and files"
+        system("mkdir #{name}/static/images")
+      else
+        p "Skipping #{name}/static/images directory (already exists)"
+      end
+
+      #copy static/css
+      if not File.exist?("#{name}/static/css")
+        p "Creating #{name}/script/css directory and files"
+        system("mkdir #{name}/static/css")
+        system("cp #{skeleton_path 'static/css/*.css'} #{name}/static/css")
+      else
+        p "Skipping #{name}/static/css directory (already exists)"
+      end
+
+      #copy static/images
+      if not File.exist?("#{name}/static/html")
+        p "Creating #{name}/script/html directory and files"
+        system("mkdir #{name}/static/html")
+      else
+        p "Skipping #{name}/static/html directory (already exists)"
+      end
+
+      #copy static/images
+      if not File.exist?("#{name}/static/js")
+        p "Creating #{name}/script/js directory and files"
+        system("mkdir #{name}/static/js")
+        system("cp #{skeleton_path 'static/js/*.js'} #{name}/static/js")
+      else
+        p "Skipping #{name}/static/js directory (already exists)"
+      end
+
+      #copy test
+      if not File.exist?("#{name}/test")
+        p "Creating #{name}/test directory and files"
+        system("mkdir #{name}/test")
+        system("cp #{skeleton_path 'test/*.rb'} #{name}/test")
+        system("mkdir #{name}/test/fixtures")
+        system("cp #{skeleton_path 'test/fixtures/*.rb'} #{name}/test/fixtures")
+      else
+        p "Skipping test directory (already exists)"
+      end
+
+      #copy test
+      if not File.exist?("#{name}/tasks")
+        p "Creating #{name}/tasks directory and files"
+        system("mkdir #{name}/tasks")
+      else
+        p "Skipping #{name}/test directory (already exists)"
+      end
+
+      #copy rakefile
+      system("cp #{skeleton_path 'Rakefile'} #{name}")
+
+    end
+    
+    def self.skeleton_path(file)
+      "#{PATH}/skeleton/#{file}"
+    end
+  
+  end
+end