linecook 1.2.1 → 2.0.0

data/lib/linecook/command.rb

@@ -0,0 +1,61 @@
+require 'configurable'
+
+module Linecook
+  class Command
+    class << self
+      def parse(argv=ARGV)
+        parser = configs.to_parser(:add_defaults => false)
+        yield(parser) if block_given?
+        parser.sort_opts!
+        parser.parse!(argv)
+
+        new(parser.config)
+      end
+
+      def signature
+        arguments = args.arguments.collect do |arg|
+          arg = arg.upcase
+          arg[0] == ?* ? "[#{arg[1..-1]}]" : arg
+        end
+        arguments.pop if arguments.last.to_s[0] == ?&
+        
+        "[options] #{arguments.join(' ')}"
+      end
+
+      # Returns a help string that formats the desc documentation.
+      def help
+        lines = desc.kind_of?(Lazydoc::Comment) ? desc.wrap(78, 2, nil) : []
+
+        unless lines.empty?
+          line = '-' * 80
+          lines.unshift(line)
+          lines.push(line)
+        end
+
+        lines.join("\n")
+      end
+    end
+
+    extend Lazydoc::Attributes
+    include Configurable
+
+    lazy_attr :desc
+    lazy_attr :args, :process
+    lazy_register :process, Lazydoc::Method
+
+    def initialize(config={})
+      initialize_config(config)
+    end
+
+    def call(argv=[])
+      process(*argv)
+    end
+
+    def process(*args)
+      raise NotImplementedError
+    end
+  end
+
+  class CommandError < RuntimeError
+  end
+end

data/lib/linecook/command_set.rb

@@ -0,0 +1,85 @@
+require 'linecook/command'
+
+module Linecook
+  class CommandSet < Command
+    class << self
+      def commands
+        # assume/require word names
+        @commands ||= {}
+      end
+
+      def parse(argv=ARGV)
+        command = super(argv) do |options|
+          options.option_break = /\A(?:--\z|[^-])/
+          options.preserve_option_break = true
+          yield(options) if block_given?
+        end
+
+        # The parser is configured to preserve the break, which is desired
+        # when it's a command, but you want to get rid of standard breaks.
+        if argv[0] == '--'
+          argv.shift
+        end
+
+        command
+      end
+      
+      def run(argv=ARGV, &block)
+        command = parse(argv) do |options|
+          if block_given?
+            yield([], self, options)
+          end
+        end
+        
+        command.call(argv, &block)
+      end
+
+      def command_list
+        commands.keys.sort.collect do |name|
+          [name, commands[name]]
+        end
+      end
+    end
+
+    def call(argv=[])
+      if argv.empty?
+        raise CommandError, "no command specified"
+      end
+
+      command_name  = argv.shift
+      command_class = self.class.commands[command_name]
+
+      unless command_class
+        raise CommandError, "unknown command: #{command_name.inspect}"
+      end
+
+      # Parse options for the command, but yield with the necessary debugging
+      # information - note that command_class is always the latest one to be
+      # parsed so start with the command name as the callpath.
+      command = command_class.parse(argv) do |options|
+        if block_given?
+          yield([command_name], command_class, options)
+        end
+      end
+
+      if command.kind_of?(CommandSet)
+        # The block causes nested CommandSets to roll back out to the main
+        # context with the callpath and latest command_class. Literally it
+        # wraps the block defined above.  Non-CommandSet commands will have
+        # nil, not a block passed to call - a NOP.
+        command.call(argv) do |callpath, cmdclass, options|
+          if block_given?
+            callpath.unshift(command_name)
+            yield(callpath, cmdclass, options)
+          end
+        end
+      else
+        process(command, *argv)
+      end
+    end
+
+    def process(command, *args)
+      command.call(args)
+    end
+  end
+end

data/lib/linecook/command_utils.rb

@@ -0,0 +1,20 @@
+require 'configurable'
+
+module Linecook
+  module CommandUtils
+    include Configurable
+
+    config :quiet, false  # -q, --quiet : silence output
+
+    def sh(cmd)
+      $stderr.puts "$ #{cmd}" unless quiet
+      system(cmd)
+    end
+
+    def sh!(cmd)
+      unless sh(cmd)
+        raise CommandError, "non-zero exit status: #{$?.exitstatus}"
+      end
+    end
+  end
+end

data/lib/linecook/commands/build.rb

@@ -1,72 +1,123 @@
-require 'linecook/commands/helper'
-require 'linecook/commands/package'
+require 'linecook/commands/compile'
 
 module Linecook
   module Commands
-    
-    # :startdoc::desc build a project
+    # ::desc build packages
     #
-    # Builds some or all packages and helpers in a project, as needed.
+    # Builds a list of 'package' recipes into packages.  Packages are exported
+    # to a directory named like the recipe. Build prints the package dir for
+    # each recipe to stdout.
     #
-    class Build < Command
-      config :project_dir, '.', :short => :d              # the project directory
-      config :load_path, [], :short => :I, &c.list        # set load paths
-      config :force, false, :short => :f, &c.flag         # force creation
-      config :quiet, false, &c.flag                       # silence output
-      
-      def glob_helpers(project_dir)
-        helpers_dir = File.expand_path('helpers', project_dir)
-        sources = {}
-        helpers = []
-        
-        Dir.glob("#{helpers_dir}/*/**/*").each do |source_file|
-          next if File.directory?(source_file)
-          (sources[File.dirname(source_file)] ||= []) << source_file
-        end
-        
-        sources.each_pair do |dir, source_files|
-          name = dir[(helpers_dir.length + 1)..-1]
-          helpers << [name, source_files]
+    # Recipes are added to the package as the 'run' executable and they are
+    # automatically configured with a package file corresponding to the
+    # recipe, if it exists.
+    #
+    # For example:
+    #
+    #   $ echo "write 'echo ' + attrs['msg']" > recipe.rb
+    #   $ echo "msg: hello world" > recipe.yml
+    #   $ linecook build recipe.rb
+    #   /path/to/pwd/recipe
+    #   $ /path/to/pwd/recipe/run
+    #   hello world
+    #
+    # The input directory containing the package files and the output
+    # directory for the packages may be specified with options.
+    #
+    # == Package Specs
+    #
+    # Package specs can be provided instead of recipes.  Specs are
+    # comma-separated strings like 'package_file,recipe_file,export_dir' that
+    # allow full control over the building of packages. Package files
+    #
+    # For example:
+    #
+    #   $ echo "write 'echo ' + attrs['msg']" > recipe.rb
+    #   $ echo "msg: hello world" > input.yml
+    #   $ linecook build input.yml,recipe.rb,output
+    #   /path/to/pwd/output
+    #   $ /path/to/pwd/output/run
+    #   hello world
+    #
+    # Providing '-' as an input will cause stdin to be read for additional
+    # inputs.  In that way a CSV file can serve as a manifest for the packages
+    # built by this command.
+    #
+    class Build < Compile
+      class << self
+        def set_common_options(options)
+          super(options)
+          options[:input_dir]  = 'packages'
+          options[:output_dir] = 'packages'
+          options
         end
-        
-        helpers.sort_by {|name, source_files| name }
       end
-      
-      def glob_package_files(package_names)
-        if package_names.empty?
-          pattern = File.expand_path('packages/*.yml', project_dir)
-          Dir.glob(pattern).select {|path| File.file?(path) }
-        else
-          package_names.collect do |package_name|
-            File.expand_path("packages/#{package_name}.yml", project_dir)
+      undef_config :package_file
+
+      def input_dir=(input)
+        @package_finder = nil
+        super(input)
+      end
+
+      def process(*recipes)
+        helper_dirs.each do |helpers_dir|
+          compile_helpers(helpers_dir)
+        end
+
+        each_spec(recipes) do |package_file, recipe_file, export_dir|
+          export_dir = File.expand_path(export_dir, output_dir)
+          if File.exists?(export_dir)
+            unless force
+              raise CommandError, "already exists: #{export_dir.inspect}"
+            end
+            FileUtils.rm_r(export_dir)
           end
+
+          package_file = File.expand_path(package_file, input_dir)
+          recipe_file = File.expand_path(recipe_file)
+
+          package  = Package.new(load_env(package_file))
+          cookbook = Cookbook.new(*cookbook_path)
+          recipe   = Recipe.new(package, cookbook)
+          recipe.register_as 'run', :mode => 0744
+          recipe.instance_eval File.read(recipe_file), recipe_file
+          recipe.register_to package
+
+          package.export(export_dir)
+          puts export_dir
         end
       end
-      
-      def process(*package_names)
-        load_path.each do |path|
-          $:.unshift(path)
+
+      def each_line(lines)
+        lines.each do |line|
+          if line == '-'
+            while line = gets
+              yield line
+            end
+          else
+            yield line
+          end
         end
-        
-        helper = Helper.new(
-          :project_dir => project_dir, 
-          :force => force,
-          :quiet => true
-        )
-        
-        helpers = glob_helpers(project_dir)
-        helpers.each do |(name, sources)|
-          helper.process(name, *sources)
+      end
+
+      def each_spec(lines)
+        each_line(lines) do |line|
+          yield *parse_spec(line)
         end
-        
-        package = Package.new(
-          :project_dir => project_dir,
-          :force => force,
-          :quiet => quiet
-        )
-        
-        glob_package_files(package_names).collect do |package_file|
-          package.process(package_file)
+      end
+
+      def parse_spec(spec)
+        fields = CSV.parse_line(spec)
+
+        case fields.length
+        when 1  # short form
+          recipe_path = fields.at(0)
+          base_name = File.basename(recipe_path).chomp('.rb')
+          ["#{base_name}.yml", recipe_path, base_name]
+        when 3  # long form
+          fields
+        else
+          raise "invalid spec: #{spec.inspect}"
         end
       end
     end

data/lib/linecook/commands/compile.rb

@@ -0,0 +1,181 @@
+require 'fileutils'
+require 'linecook/recipe'
+require 'linecook/commands/compile_helper'
+require 'yaml'
+require 'csv'
+
+module Linecook
+  module Commands
+    # ::desc compile recipes
+    #
+    # Compiles a list of recipes into a single package and exports the result
+    # to the working directory.  The recipes are added to the package at their
+    # relative path, minus their extname.
+    #
+    # For example:
+    #
+    #   $ echo "write 'echo hello world'" > recipe.rb 
+    #   $ linecook compile recipe.rb
+    #   $ sh recipe
+    #   hello world
+    #
+    # Providing '-' as a recipe will cause stdin to be compiled as a recipe to
+    # stdout.
+    class Compile < Command
+      class << self
+        def parse(argv=ARGV)
+          super(argv) do |options|
+            options.on('-I DIRECTORY', 'prepend to LOAD_PATH') do |path|
+              $LOAD_PATH.unshift File.expand_path(path)
+            end
+
+            options.on('-r LIBRARY', 'require the library') do |path|
+              require(path)
+            end
+
+            options.on('-G GEMNAME', 'add gem to cookbook path', :option_type => :list) do |name|
+              specs = Gem.source_index.find_name(name)
+              if specs.empty?
+                raise CommandError, "could not find gem: #{name.inspect}"
+              end
+              (options[:cookbook_path] ||= []) << specs.first.full_gem_path
+            end
+
+            options.on('-g', '--gems', 'add latest cookbook gems') do |name|
+              (options[:cookbook_path] ||= []).concat cookbook_gem_paths
+            end
+
+            options.on('-c', '--common', 'use common flags') do
+              set_common_options(options)
+            end
+
+            if block_given?
+              yield(options)
+            end
+          end
+        end
+
+        def set_common_options(options)
+          cookbook_path = (options[:cookbook_path] ||= [])
+          cookbook_path << '.'
+          cookbook_path.concat cookbook_gem_paths
+          (options[:helper_dirs] ||= []) << 'helpers'
+          options
+        end
+
+        def cookbook_gem_paths(latest=true)
+          Cookbook.gemspecs(latest).collect do |gemspec|
+            gemspec.full_gem_path
+          end
+        end
+
+        def gemspecs(latest=true)
+          return [] unless Object.const_defined?(:Gem)
+
+          index = Gem.source_index
+          specs = latest ? index.latest_specs : index.gems.values
+
+          specs.select do |spec|
+            cookbook_file = File.expand_path(default_file_name, spec.full_gem_path)
+            File.exists?(cookbook_file)
+          end
+        end
+      end
+
+      config :cookbook_path, [], :delimiter => ':'     # -C PATH : cookbook path
+      config :helper_dirs, []                          # -L DIRECTORY : compile helpers
+      config :package_file, nil                        # -p PATH : package config file
+      config :input_dir, '.', :writer => :input_dir=   # -i DIRECTORY : the input dir
+      config :output_dir, '.', :writer => :output_dir= # -o DIRECTORY : the output dir
+      config :force, false                             # -f, --force : overwrite existing
+
+      def input_dir=(input)
+        @input_dir = File.expand_path(input)
+      end
+
+      def output_dir=(input)
+        @output_dir = File.expand_path(input)
+      end
+
+      def process(*recipes)
+        helper_dirs.each do |helper_dir|
+          compile_helpers(helper_dir)
+        end
+
+        package  = Package.new(load_env(package_file))
+        cookbook = Cookbook.new(*cookbook_path)
+        stdout   = StringIO.new
+
+        recipes.each do |recipe_path|
+          recipe = Recipe.new(package, cookbook)
+
+          if recipe_path == '-'
+            recipe.instance_eval $stdin.read, 'stdin'
+            stdout.print recipe
+          else
+            recipe_path = File.expand_path(recipe_path)
+            recipe.register_as relative_path(input_dir, recipe_path).chomp('.rb')
+            recipe.instance_eval File.read(recipe_path), recipe_path
+            recipe.register_to package
+          end
+        end
+
+        package.export(output_dir) do |src, dest|
+          unless force
+            raise CommandError, "already exists: #{dest.inspect}"
+          end
+
+          FileUtils.rm_rf(dest)
+          true
+        end
+
+        # print to $stdout after export to ensure files will be available
+        $stdout << stdout.string
+      end
+
+      def relative_path(dir, path)
+        if path.index(dir) == 0 && path != dir
+          path[dir.length + 1, path.length - dir.length]
+        else
+          File.basename(path)
+        end
+      end
+
+      def load_env(package_file)
+        env = package_file && File.exists?(package_file) ? YAML.load_file(package_file) : nil
+        env.nil? ? {} : env
+      end
+
+      def glob_helpers(helper_dir)
+        sources = {}
+        helpers = []
+
+        Dir.glob("#{helper_dir}/*/**/*").each do |source_file|
+          next if File.directory?(source_file)
+          (sources[File.dirname(source_file)] ||= []) << source_file
+        end
+
+        sources.each_pair do |dir, source_files|
+          name = dir[(helper_dir.length + 1)..-1]
+          helpers << [name, source_files]
+        end
+
+        helpers.sort_by {|name, source_files| name }
+      end
+
+      def compile_helpers(helper_dir)
+        compiler = CompileHelper.new(
+          :force => force,
+          :quiet => true
+        )
+
+        helpers = glob_helpers(helper_dir)
+        helpers.each do |(name, sources)|
+          compiler.process(name, *sources)
+        end
+
+        $LOAD_PATH.unshift compiler.output_dir
+      end
+    end
+  end
+end