groundwork 0.0.3 → 0.0.4

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/bin/groundwork

@@ -5,86 +5,11 @@ require File.join(File.dirname(__FILE__),"..","lib","groundwork.rb")
 begin
   options = Groundwork::parse_options
 
-  case options[:command]
+  raise RuntimeError.new("No command given; use \"groundwork -h\" for help") unless options[:command]
 
-    ##################################################
-    ### Generate #####################################
-    ##################################################
-  when "generate"
+  load File.join(File.dirname(__FILE__),"..","commands",options[:command]+".rb")
 
-    generate_opts = Trollop::options(options[:remainder]) do
-      banner <<-STR
-Usage:
-      groundwork generate [options] filename
-
-Generates a basic .recipe.rb file, which you can modify, from the current directory
-
-Options are:
-STR
-      opt :force, "Overwrite .recipe.rb file if exists", :default=>false
-      opt :ignore, "Ignore files matching these filename patterns", :type=>:strings
-      opt :print, "Instead of storing in a file, print the recipe to stdout", :default=>false
-      opt :chdir, "Before running, cd to the given directory", :default=>FileUtils.pwd
-    end
-
-    recipe = ""
-    FileUtils.cd(generate_opts[:chdir]) do
-      recipe = Groundwork::Recipe.generate FileUtils.pwd, :ignore => generate_opts[:ignore]
-    end
-
-    if generate_opts[:print]
-      puts recipe
-    else
-      name = options[:remainder].shift || "Recipe"
-
-      if File.exists?(name+".recipe.rb") && !generate_opts[:force]
-        raise RuntimeError.new("File already exists: #{name}.recipe.rb\nUse -f to overwrite")
-      end
-
-      File.open(name+".recipe.rb","w"){|f| f.print recipe}
-    end
-
-    ##################################################
-    ### Compile ######################################
-    ##################################################
-  when "compile"
-
-    compile_opts = Trollop::options(options[:remainder]) do
-      banner <<-STR
-Usage:
-      groundwork compile [options] filename.recipe.rb
-
-Compiles a .recipe.rb, including all referenced files into it.
-
-Options are:
-STR
-      opt :force, "Overwrite .recipe file if exists", :default=>false
-      opt :print, "Instead of storing in a file, print the recipe to stdout", :default=>false
-      opt :chdir, "Before running, cd to the given directory", :default=>FileUtils.pwd
-    end
-
-    input = options[:remainder].shift
-    raise RuntimeError.new("No input file given") unless input
-    raise RuntimeError.new("Cannot open #{input}") unless File.exists?(input)
-
-    compiled = ""
-    FileUtils.cd(compile_opts[:chdir]) do
-      compiled = Groundwork::Recipe.compile input
-    end
-
-    if compile_opts[:print]
-      puts compiled
-    else
-      name = options[:remainder].shift || File.basename(input,".recipe.rb")
-
-      if File.exists?(name+".recipe") && !compile_opts[:force]
-        raise RuntimeError.new("File already exists: #{name}.recipe\nUse -f to overwrite")
-      end
-
-      File.open(name+".recipe","w"){|f| f.print compiled}
-    end
-  else
-  end
+  Groundwork::Commands.send options[:command], options[:remainder]
 rescue
   puts $!.to_s
 end

data/commands/compile.rb

@@ -0,0 +1,47 @@
+module Groundwork
+  module Commands
+    def self.compile args
+      cmd_opts = Trollop::options(args) do
+        banner <<-STR
+Usage:
+      groundwork compile [options] filename.recipe.rb
+
+Compiles a .recipe.rb, including all referenced files into it.
+
+Options are:
+STR
+        opt :force, "Overwrite .recipe file if exists", :default=>false
+        opt :print, "Instead of storing in a file, print the recipe to stdout", :default=>false
+        opt :chdir, "Before running, cd to the given directory", :default=>FileUtils.pwd
+      end
+
+      input = args.shift
+      raise RuntimeError.new("Cannot open #{input}") if input && !File.exists?(input)
+
+      compiled = ""
+      FileUtils.cd(cmd_opts[:chdir]) do
+        compiled = if input
+                     Groundwork::Recipe.compile_file input
+                   else
+                     Groundwork::Recipe.compile STDIN.read, FileUtils.pwd
+                   end
+      end
+
+      if cmd_opts[:print]
+        puts compiled
+      else
+        name = args.shift || if input
+                               File.basename(input,".recipe.rb")
+                             else
+                               File.basename(FileUtils.pwd)
+                             end
+
+        if File.exists?(name+".recipe") && !cmd_opts[:force]
+          raise RuntimeError.new("File already exists: #{name}.recipe\nUse -f to overwrite")
+        end
+
+        File.open(name+".recipe","w"){|f| f.print compiled}
+      end
+    end
+  end
+end

data/commands/generate.rb

@@ -0,0 +1,38 @@
+module Groundwork
+  module Commands
+    def self.generate args
+
+      cmd_opts = Trollop::options(args) do
+        banner <<-STR
+Usage:
+      groundwork generate [options] filename
+
+Generates a basic .recipe.rb file, which you can modify, from the current directory
+
+Options are:
+STR
+        opt :force, "Overwrite .recipe.rb file if exists", :default=>false
+        opt :ignore, "Ignore files matching these filename patterns", :type=>:strings
+        opt :print, "Instead of storing in a file, print the recipe to stdout", :default=>false
+        opt :chdir, "Before running, cd to the given directory", :default=>FileUtils.pwd
+      end
+
+      recipe = ""
+      FileUtils.cd(cmd_opts[:chdir]) do
+        recipe = Groundwork::Recipe.generate FileUtils.pwd, :ignore => cmd_opts[:ignore]
+      end
+
+      if cmd_opts[:print]
+        puts recipe
+      else
+        name = args.shift || File.basename(FileUtils.pwd)
+
+        if File.exists?(name+".recipe.rb") && !cmd_opts[:force]
+          raise RuntimeError.new("File already exists: #{name}.recipe.rb\nUse -f to overwrite")
+        end
+
+        File.open(name+".recipe.rb","w"){|f| f.print recipe}
+      end
+    end
+  end
+end

data/commands/install.rb

@@ -0,0 +1,31 @@
+module Groundwork
+  module Commands
+    def self.install args
+      cmd_opts = Trollop::options(args) do
+        banner <<-STR
+Usage:
+      groundwork install [options] filename.recipe
+
+Installs a recipe into ~/.groundwork
+
+Options are:
+STR
+        opt :force, "Overwrite recipe if it already exists", :default=>false
+        opt :name, "Specify a name for the recipe other than the filename", :default=>false
+      end
+
+      file = args.shift
+      raise RuntimeError.new("No input file given") unless file
+      raise RuntimeError.new("Cannot open #{file}") unless File.exists?(file)
+
+      dot_groundwork = File.expand_path("~/.groundwork")
+      FileUtils.mkdir(dot_groundwork) unless File.directory?(dot_groundwork)
+
+      if File.exists?(File.join(dot_groundwork,File.basename(file))) && !cmd_opts[:force]
+        raise RuntimeError.new("Recipe already exists: #{File.basename(file,'.recipe')}\nUse -f to replace")
+      end
+
+      FileUtils.cp file, dot_groundwork
+    end
+  end
+end

data/commands/list.rb

@@ -0,0 +1,16 @@
+module Groundwork
+  module Commands
+    def self.list args
+      cmd_opts = Trollop::options(args) do
+        banner <<-STR
+Usage:
+      groundwork list
+
+Lists all installed recipes
+STR
+      end
+
+      puts Groundwork.known_recipes.keys.join("\n")
+    end
+  end
+end

data/lib/groundwork.rb

@@ -4,175 +4,26 @@ require "erb"
 require "pathname"
 require File.join(File.dirname(__FILE__), "options.rb")
 require File.join(File.dirname(__FILE__), "tar_wrapper.rb")
+require File.join(File.dirname(__FILE__), "recipe.rb")
+require File.join(File.dirname(__FILE__), "recipe_class.rb")
 
 module Groundwork
-  class Recipe
-    def initialize &block
-      if block_given?
-        instance_eval &block
-      end
-    end
-
-    def tar= data
-      @tar = TarWrapper.new(data)
-    end
-
-    # Creates a directory. If a block is passed,
-    # the block will be run inside that directory
-    def directory *name, &block
-      FileUtils.mkdir_p File.join(name)
-      if block_given?
-        FileUtils.cd File.join(name), &block
-      end
-    end
-
-    # If opts is a string, it's the contents of the file, verbatim
-    # If opts is a hash, it must contain either:
-    # * :from, copies the text of the given filename verbatim
-    # * :from_erb, uses the text of the filename as an erb template
-    # * :erb, uses the given string as an erb template
-    def file name, opts = nil
-      name = File.join(name)
-      File.open(File.join(name),"w") do |file|
-        if opts.is_a? String
-          file.print opts
-        elsif opts.is_a? Hash
-          file.print( if opts[:from]
-                        read_file opts[:from]
-                      elsif opts[:from_erb]
-                        ERB.new(read_file(opts[:from_erb])).result(binding)
-                      elsif opts[:erb]
-                        ERB.new(opts[:erb]).result(binding)
-                      end )
-        elsif opts.nil?
-          # write nothing
-        else
-          raise ArgumentError.new
-        end
-      end
-    end
-
-    # When you compile a recipe, it runs it to determine which files to bake in.
-    # If you have a file that might not be generated by running your script with
-    # no options, you can call possible on it to ensure it gets baked into
-    # the script. This function only has an effect during compilation, it does
-    # nothing when the script is actually run.
-    def possible name ; end
-
-    # Takes a block and lists the files that that block will require as templates.
-    # See Groundwork::Recipe#possible
-    def self.required_files &block
-      dummy = Object.new
-      files = []
-
-      class << dummy
-        attr_reader :files
-
-        def directory *args
-          yield if block_given?
-        end
-
-        def file name, opts=nil
-          @files << opts[:from] if opts[:from]
-          @files << opts[:from_erb] if opts[:from_erb]
-        end
-
-        def possible name
-          @files << name
-        end
-
-        def method_missing *args ; end
-      end
 
-      dummy.instance_variable_set "@files", []
-      dummy.instance_eval &block
-
-      dummy.files
-    end
-
-    # Takes a script file, finds the files it requires (paths relative to the script file),
-    # reads/tars them and returns a string containing the script and the TAR blob, ready
-    # to write to a file
-    def self.compile script_file
-      script = File.read(script_file)
-      out = StringIO.new
-      data = nil
-
-      FileUtils.cd(File.dirname(script_file)) do
-        files = required_files do
-          eval script
-        end
-
-        data = TarWrapper.compress files
-      end
-
-      out.puts "if $0==__FILE__"
-      out.puts "  require 'rubygems'"
-      out.puts "  require 'groundwork'"
-      out.puts "end"
-      out.puts ""
-      out.puts script
-      out.puts ""
-      out.puts "__END__"
-      out.puts data
-
-      out.string
-    end
-
-    # Takes a filename and runs the script contained in it. The file should be
-    # the results of Groundwork::Recipe#compile
-    def self.run script_file
-      (script, data) = File.read(script_file).split("\n__END__\n")
-
-      Groundwork::Recipe.new do
-        self.tar = data
-        eval script
-      end
+  # Return a hash of all known recipes, the included ones and the ones in .groundwork
+  def self.known_recipes
+    recipes = {}
+    Dir[File.join(File.dirname(__FILE__),"..","recipes","*.recipe")].each do |recipe|
+      recipes[File.basename(recipe,".recipe")] = recipe
     end
 
-    # Generate a tree of file and directory calls that would create the given
-    # directory
-    def self.generate dir = FileUtils.pwd, options = {}
-      base = Pathname.new dir
-
-      handle_dir = lambda do |d, output, indent|
-        FileUtils.cd d do
-          Dir["*"].each do |file|
-            rel = Pathname.new(File.join(FileUtils.pwd,file))
-            relpath = rel.relative_path_from(base).to_s
-
-            next if options[:ignore] && options[:ignore].any?{|p| File.fnmatch(p,relpath) }
+    dot_groundwork = File.expand_path("~/.groundwork")
 
-            if File.directory? file
-              if Dir[File.join(file,"*")].empty?
-                output.puts((" "*indent)+"directory \"#{file}\"")
-              else
-                output.puts("")
-                output.puts((" "*indent)+"directory \"#{file}\" do")
-                handle_dir[file, output, indent+2]
-                output.puts((" "*indent)+"end")
-                output.puts("")
-              end
-            else
-              output.puts((" "*indent)+"file \"#{file}\", :from => \"#{relpath}\"")
-            end
-          end
-        end
+    if File.directory?(dot_groundwork)
+      Dir[File.join(dot_groundwork,"*.recipe")].each do |recipe|
+        recipes[File.basename(recipe,".recipe")] = recipe
       end
-
-      str = StringIO.new
-      handle_dir[dir, str, 0]
-      str.string.gsub(/\n\n+/,"\n\n") # Collapse adjacent blank lines
     end
 
-    private
-
-    def read_file name
-      if @tar
-        @tar[name]
-      else
-        File.read(name)
-      end
-    end
+    recipes
   end
 end

data/lib/options.rb

@@ -1,17 +1,26 @@
 require "abbrev"
 
 module Groundwork
+  GROUNDWORK_VERSION = File.read(File.join(File.dirname(__FILE__), "..", "VERSION"))
+  COMMANDS = Dir[File.join(File.dirname(__FILE__),"..","commands","*.rb")].map{|file| File.basename(file,".rb") }
+
   def self.parse_options opts=ARGV
     global_opts = Trollop::options(opts) do
       banner <<-STR
 Usage:
-       groundwork [global_options] command [command_options]
+      groundwork [global_options] <command> [command_options]
+
+Commands:
+      generate - Generate a recipe for the current directory
+      compile  - Compile a .recipe.rb file into a .recipe
+      install  - Install a compiled .recipe file into ~/.groundwork
+      list     - List all recipes
 
-Currently, the only implemented commands are "generate", which generates a recipe for the current directory, and "compile", which compiles a recipe with all the files it references.
+      Use "groundwork <command> -h" for command-specific help
 
-Options are:
+Global options are:
 STR
-      version "0.0.3"
+      version GROUNDWORK_VERSION
       stop_on_unknown
     end
 
@@ -23,7 +32,7 @@ STR
            })
   end
 
-  def self.short_for cmd_start, all_commands=["generate", "compile"]
+  def self.short_for cmd_start, all_commands=(COMMANDS | known_recipes.keys)
     return cmd_start unless cmd_start
     return cmd_start if all_commands.index(cmd_start)
 

data/lib/recipe.rb

@@ -0,0 +1,65 @@
+module Groundwork
+  class Recipe
+    def initialize &block
+      if block_given?
+        instance_eval &block
+      end
+    end
+
+    def tar= data
+      @tar = TarWrapper.new(data)
+    end
+
+    # Creates a directory. If a block is passed,
+    # the block will be run inside that directory
+    def directory *name, &block
+      FileUtils.mkdir_p File.join(name)
+      if block_given?
+        FileUtils.cd File.join(name), &block
+      end
+    end
+
+    # If opts is a string, it's the contents of the file, verbatim
+    # If opts is a hash, it must contain either:
+    # * :from, copies the text of the given filename verbatim
+    # * :from_erb, uses the text of the filename as an erb template
+    # * :erb, uses the given string as an erb template
+    def file name, opts = nil
+      name = File.join(name)
+      File.open(File.join(name),"w") do |file|
+        if opts.is_a? String
+          file.print opts
+        elsif opts.is_a? Hash
+          file.print( if opts[:from]
+                        read_file opts[:from]
+                      elsif opts[:from_erb]
+                        ERB.new(read_file(opts[:from_erb])).result(binding)
+                      elsif opts[:erb]
+                        ERB.new(opts[:erb]).result(binding)
+                      end )
+        elsif opts.nil?
+          # write nothing
+        else
+          raise ArgumentError.new
+        end
+      end
+    end
+
+    # When you compile a recipe, it runs it to determine which files to bake in.
+    # If you have a file that might not be generated by running your script with
+    # no options, you can call possible on it to ensure it gets baked into
+    # the script. This function only has an effect during compilation, it does
+    # nothing when the script is actually run.
+    def possible name ; end
+
+    private
+
+    def read_file name
+      if @tar
+        @tar[name]
+      else
+        File.read(name)
+      end
+    end
+  end
+end

data/lib/recipe_class.rb

@@ -0,0 +1,111 @@
+module Groundwork
+  class Recipe
+    class << self
+
+      # Takes a block and lists the files that that block will require as templates.
+      # See Groundwork::Recipe#possible
+      def required_files &block
+        dummy = Object.new
+        files = []
+
+        class << dummy
+          attr_reader :files
+
+          def directory *args
+            yield if block_given?
+          end
+
+          def file name, opts=nil
+            @files << opts[:from] if opts[:from]
+            @files << opts[:from_erb] if opts[:from_erb]
+          end
+
+          def possible name
+            @files << name
+          end
+
+          def method_missing *args ; end
+        end
+
+        dummy.instance_variable_set "@files", []
+        dummy.instance_eval &block
+
+        dummy.files
+      end
+
+      def compile_file filename
+        compile File.read(filename), File.dirname(filename)
+      end
+
+      # Takes a script file, finds the files it requires (paths relative to the script file),
+      # reads/tars them and returns a string containing the script and the TAR blob, ready
+      # to write to a file
+      def compile script, in_directory
+        out = StringIO.new
+        data = nil
+
+        FileUtils.cd(in_directory) do
+          files = required_files do
+            eval script
+          end
+
+          data = TarWrapper.compress files
+        end
+
+        out.puts script
+        out.puts ""
+        out.puts "__END__"
+        out.puts data
+
+        out.string
+      end
+
+      # Takes a filename and runs the script contained in it. The file should be
+      # the results of Groundwork::Recipe#compile
+      def run script_file
+        (script, data) = File.read(script_file).split("\n__END__\n")
+
+        Groundwork::Recipe.new do
+          self.tar = data
+          eval script
+        end
+      end
+
+      # Generate a tree of file and directory calls that would create the given
+      # directory
+      def generate dir = FileUtils.pwd, options = {}
+        base = Pathname.new dir
+
+        handle_dir = lambda do |d, output, indent|
+          FileUtils.cd d do
+            Dir["*"].each do |file|
+              rel = Pathname.new(File.join(FileUtils.pwd,file))
+              relpath = rel.relative_path_from(base).to_s
+
+              next if options[:ignore] && options[:ignore].any?{|p| File.fnmatch(p,relpath) }
+
+              if File.directory? file
+                if Dir[File.join(file,"*")].empty?
+                  output.puts((" "*indent)+"directory \"#{file}\"")
+                else
+                  output.puts("")
+                  output.puts((" "*indent)+"directory \"#{file}\" do")
+                  handle_dir[file, output, indent+2]
+                  output.puts((" "*indent)+"end")
+                  output.puts("")
+                end
+              else
+                output.puts((" "*indent)+"file \"#{file}\", :from => \"#{relpath}\"")
+              end
+            end
+          end
+        end
+
+        str = StringIO.new
+        handle_dir[dir, str, 0]
+        str.string.gsub(/\n\n+/,"\n\n") # Collapse adjacent blank lines
+      end
+
+    end
+  end
+end

data/recipes/hello.recipe

@@ -0,0 +1,3 @@
+file "hello.rb", <<-STR
+puts "Hello, world!"
+STR

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Andrews, Ross
@@ -54,9 +54,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- VERSION
 - lib/groundwork.rb
-- lib/tar_wrapper.rb
 - lib/options.rb
+- lib/recipe.rb
+- lib/recipe_class.rb
+- lib/tar_wrapper.rb
+- commands/compile.rb
+- commands/generate.rb
+- commands/install.rb
+- commands/list.rb
+- recipes/hello.recipe
 has_rdoc: true
 homepage: https://github.com/randrews/groundwork
 licenses: []