linecook 1.2.1 → 2.0.0

data/lib/linecook/commands/package.rb

@@ -1,57 +0,0 @@
-require 'linecook/commands/command'
-require 'linecook/cookbook'
-require 'linecook/package'
-require 'fileutils'
-require 'yaml'
-
-module Linecook
-  module Commands
-    
-    # :startdoc::desc generates a package
-    #
-    # Generates the package specified at
-    # 'project_dir/packages/package_name.yml'.  The package file should be a
-    # YAML files that specifies a package env.  The full path to package file
-    # can be given instead of package name using the --file option.
-    #
-    # If a cookbook file is present in the project_dir then it will be used to
-    # resolve resources available to the package.  See the env command to
-    # interrogate a package env.
-    class Package < Command
-      config :project_dir, '.', :short => :d              # the project directory
-      config :force, false, :short => :f, &c.flag         # force creation
-      config :quiet, false, &c.flag                       # silence output
-      
-      def process(package_file, package_dir=nil)
-        package_dir ||= default_package_dir(package_file)
-        package_dir = File.expand_path(package_dir)
-        package = Linecook::Package.init(package_file, project_dir)
-        
-        dependencies = package_dependencies(package) + [package_file]
-        if force || !FileUtils.uptodate?(package_dir, dependencies)
-          package.build
-          package.export(package_dir)
-          $stdout.puts package_dir unless quiet
-        end
-        
-        package_dir
-      end
-      
-      def package_dependencies(package)
-        dependencies = []
-        package.manifest.values.collect do |resources|
-          dependencies.concat resources.values
-        end
-        
-        $LOAD_PATH.each do |path|
-          dependencies.concat Dir.glob("#{path}/**/*.rb")
-        end
-        dependencies
-      end
-      
-      def default_package_dir(package_file)
-        package_file.chomp(File.extname(package_file))
-      end
-    end
-  end
-end

data/lib/linecook/template.rb

@@ -1,17 +0,0 @@
-require 'erb'
-require 'ostruct'
-
-module Linecook
-  class Template
-    attr_reader :erb
-    
-    def initialize(filename)
-      @erb = ERB.new File.read(filename)
-      @erb.filename = filename
-    end
-    
-    def build(locals={})
-      erb.result OpenStruct.new(locals).instance_eval('binding')
-    end
-  end
-end

data/lib/linecook/test/command_parser.rb

@@ -1,75 +0,0 @@
-module Linecook
-  module Test
-    class CommandParser
-      attr_reader :ps1
-      attr_reader :ps2
-      attr_reader :prefix
-      attr_reader :suffix
-      
-      def initialize(options={})
-        options = {
-          :ps1 => '% ',
-          :ps2 => '> ',
-          :prefix => '0<&- 2>&1 ',
-          :suffix => ''
-        }.merge(options)
-        
-        @ps1 = options[:ps1]
-        @ps2 = options[:ps2]
-        @prefix = options[:prefix]
-        @suffix = options[:suffix]
-      end
-      
-      def parse_cmd(cmd)
-        cmd =~ /.*?#\s*(?:\[(\d+)\])?\s*(\.{3})?/
-        exit_status = $1 ? $1.to_i : 0
-        output = $2 ? nil : ""
-        
-        [cmd, output, exit_status]
-      end
-      
-      def parse(script)
-        commands = []
-        
-        command, output, exit_status = nil, "", 0
-        script.each_line do |line|
-          case
-          when line.index(ps1) == 0
-            if command
-              commands << ["#{prefix}#{command}#{suffix}", output, exit_status]
-            end
-            
-            command, output, exit_status = parse_cmd lchomp(ps1, line)
-            
-          when command.nil?
-            unless line.strip.empty?
-              command, output, exit_status = parse_cmd(line)
-            end
-            
-          when line.index(ps2) == 0
-            command << lchomp(ps2, line)
-          
-          when output.nil?
-            output = line
-          
-          else
-            output << line
-          end
-        end
-        
-        if command
-          commands << ["#{prefix}#{command}#{suffix}", output, exit_status]
-        end
-        
-        commands
-      end
-      
-      private
-      
-      def lchomp(prefix, line) # :nodoc:
-        length = prefix.length
-        line[length, line.length - length]
-      end
-    end
-  end
-end

data/lib/linecook/test/file_test.rb

@@ -1,197 +0,0 @@
-require 'linecook/test/shim'
-
-module Linecook
-  module Test
-    module FileTest
-      module ClassMethods
-        attr_accessor :class_dir
-        
-        attr_reader :cleanup_method_registry
-        
-        def cleanup_methods
-          @cleanup_methods ||= begin
-            cleanup_methods = {}
-
-            ancestors.reverse.each do |ancestor|
-              next unless ancestor.kind_of?(ClassMethods)
-              ancestor.cleanup_method_registry.each_pair do |key, value|
-                if value.nil?
-                  cleanup_methods.delete(key)
-                else
-                  cleanup_methods[key] = value
-                end
-              end
-            end
-            
-            cleanup_methods
-          end
-        end
-        
-        def reset_cleanup_methods
-          @cleanup_methods = nil
-        end
-        
-        protected
-        
-        def self.initialize(base)
-          # Infers the test directory from the calling file.
-          #   'some_class_test.rb' => 'some_class_test'
-          calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
-          base.class_dir = calling_file.chomp(File.extname(calling_file))
-          
-          base.reset_cleanup_methods
-          unless base.instance_variable_defined?(:@cleanup_method_registry)
-            base.instance_variable_set(:@cleanup_method_registry, {})
-          end
-          
-          unless base.instance_variable_defined?(:@cleanup_paths)
-            base.instance_variable_set(:@cleanup_paths, ['.'])
-          end
-          
-          unless base.instance_variable_defined?(:@cleanup)
-            base.instance_variable_set(:@cleanup, true)
-          end
-        end
-        
-        def inherited(base) # :nodoc:
-          ClassMethods.initialize(base)
-          super
-        end
-        
-        def define_method_cleanup(method_name, dirs)
-          reset_cleanup_methods
-          cleanup_method_registry[method_name.to_sym] = dirs
-        end
-        
-        def remove_method_cleanup(method_name)
-          reset_cleanup_methods
-          cleanup_method_registry.delete(method_name.to_sym)
-        end
-        
-        def undef_method_cleanup(method_name)
-          reset_cleanup_methods
-          cleanup_method_registry[method_name.to_sym] = nil
-        end
-        
-        def cleanup_paths(*dirs)
-          @cleanup_paths = dirs
-        end
-        
-        def cleanup(*method_names)
-          if method_names.empty?
-            @cleanup = true
-          else
-            method_names.each do |method_name|
-              define_method_cleanup method_name, @cleanup_paths
-            end
-          end
-        end
-        
-        def no_cleanup(*method_names)
-          if method_names.empty?
-            @cleanup = false
-          else
-            method_names.each do |method_name|
-              undef_method_cleanup method_name
-            end
-          end
-        end
-        
-        def method_added(sym)
-          if @cleanup && !cleanup_method_registry.has_key?(sym.to_sym) && sym.to_s[0, 5] == "test_"
-            cleanup sym
-          end
-        end
-      end
-    
-      module ModuleMethods
-        module_function
-      
-        def included(base)
-          base.extend ClassMethods
-          base.extend ModuleMethods unless base.kind_of?(Class)
-          
-          ClassMethods.initialize(base)
-          super
-        end
-      end
-      
-      extend ModuleMethods
-      
-      def setup
-        super
-        cleanup
-      end
-      
-      def teardown
-        Dir.chdir(user_dir)
-        
-        unless ENV["KEEP_OUTPUTS"] == "true"
-          cleanup
-          
-          dir = method_dir
-          while dir != class_dir
-            dir = File.dirname(dir)
-            Dir.rmdir(dir)
-          end rescue(SystemCallError)
-        end
-        
-        super
-      end
-      
-      def user_dir
-        @user_dir   ||= File.expand_path('.')
-      end
-      
-      def class_dir
-        @class_dir  ||= File.expand_path(self.class.class_dir, user_dir)
-      end
-      
-      def method_dir
-        @method_dir ||= File.expand_path(method_name.to_s, class_dir)
-      end
-      
-      def cleanup_methods
-        self.class.cleanup_methods
-      end
-      
-      def cleanup
-        if cleanup_paths = cleanup_methods[method_name.to_sym]
-          cleanup_paths.each {|relative_path| remove(relative_path) }
-        end
-      end
-      
-      def path(relative_path)
-        path = File.expand_path(relative_path, method_dir)
-        
-        unless path.index(method_dir) == 0
-          raise "does not make a path relative to method_dir: #{relative_path.inspect}"
-        end
-        
-        path
-      end
-      
-      def prepare(relative_path, content=nil, &block)
-        target = path(relative_path)
-        
-        if File.exists?(target)
-          FileUtils.rm(target)
-        else
-          target_dir = File.dirname(target)
-          FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
-        end
-        
-        FileUtils.touch(target)
-        File.open(target, 'w') {|io| io << content } if content
-        File.open(target, 'a', &block) if block
-        
-        target
-      end
-      
-      def remove(relative_path)
-        full_path = path(relative_path)
-        FileUtils.rm_r(full_path) if File.exists?(full_path)
-      end
-    end
-  end
-end

data/lib/linecook/test/regexp_escape.rb

@@ -1,86 +0,0 @@
-module Linecook
-  module Test
-    # RegexpEscape is a subclass of regexp that escapes all but the text in a
-    # special escape sequence.  This allows the creation of complex regexps
-    # to match, for instance, console output.
-    #
-    # The RegexpEscape.escape (or equivalently the quote) method does the
-    # work; all regexp-active characters are escaped except for characters
-    # enclosed by ':.' and '.:' delimiters.
-    #
-    #   RegexpEscape.escape('reg[exp]+ chars. are(quoted)')       # => 'reg\[exp\]\+\ chars\.\ are\(quoted\)'
-    #   RegexpEscape.escape('these are not: :.a(b*)c.:')          # => 'these\ are\ not:\ a(b*)c'
-    #
-    # In addition, all-period regexps are automatically upgraded to '.*?';
-    # use the '.{n}' notation to specify n arbitrary characters.
-    #
-    #   RegexpEscape.escape('_:..:_:...:_:....:')        # => '_.*?_.*?_.*?'
-    #   RegexpEscape.escape(':..{1}.:')                  # => '.{1}'
-    #
-    # RegexpEscape instances are initialized using the escaped input string
-    # and return the original string upon to_s.
-    #
-    #   str = %q{
-    #   a multiline
-    #   :...:
-    #   example}
-    #   r = RegexpEscape.new(str)
-    #
-    #   r =~ %q{
-    #   a multiline
-    #   matching
-    #   example}  # => true
-    #
-    #   r !~ %q{
-    #   a failing multiline
-    #   example}  # => true
-    #
-    #   r.to_s    # => str
-    #
-    class RegexpEscape < Regexp
-    
-      # matches the escape sequence
-      ESCAPE_SEQUENCE = /:\..*?\.:/
-    
-      class << self
-    
-        # Escapes regexp-active characters in str, except for character
-        # delimited by ':.' and '.:'.  See the class description for
-        # details.
-        def escape(str)
-          substituents = []
-          str.scan(ESCAPE_SEQUENCE) do
-            regexp_str = $&[2...-2]
-            regexp_str = ".*?" if regexp_str =~ /^\.*$/
-            substituents << regexp_str
-          end
-          substituents << ""
-
-          splits = str.split(ESCAPE_SEQUENCE).collect do |split|
-            super(split)
-          end
-          splits << "" if splits.empty?
-        
-          splits.zip(substituents).to_a.flatten.join
-        end
-      
-        # Same as escape.
-        def quote(str)
-          escape(str)
-        end
-      end
-    
-      # Generates a new RegexpEscape by escaping the str, using the same
-      # options as Regexp.
-      def initialize(str, *options)
-        super(RegexpEscape.escape(str), *options)
-        @original_str = str
-      end
-    
-      # Returns the original string for self
-      def to_s
-        @original_str
-      end
-    end
-  end
-end

data/lib/linecook/test/shell_test.rb

@@ -1,177 +0,0 @@
-require 'linecook/test/regexp_escape'
-require 'linecook/test/command_parser'
-require 'linecook/test/shim'
-
-module Linecook
-  module Test
-    module ShellTest
-      
-      def setup
-        super
-        @notify_method_name = true
-      end
-
-      # Returns true if the ENV variable 'VERBOSE' is true.  When verbose,
-      # ShellTest prints the expanded commands of sh_test to $stdout.
-      def verbose?
-        verbose = ENV['VERBOSE']
-        verbose && verbose =~ /^true$/i ? true : false
-      end
-      
-      # Sets the specified ENV variables and returns the *current* env.
-      # If replace is true, current ENV variables are replaced; otherwise
-      # the new env variables are simply added to the existing set.
-      def set_env(env={}, replace=false)
-        current_env = {}
-        ENV.each_pair do |key, value|
-          current_env[key] = value
-        end
-
-        ENV.clear if replace
-
-        env.each_pair do |key, value|
-          if value.nil?
-            ENV.delete(key)
-          else
-            ENV[key] = value
-          end
-        end if env
-
-        current_env
-      end
-
-      # Sets the specified ENV variables for the duration of the block.
-      # If replace is true, current ENV variables are replaced; otherwise
-      # the new env variables are simply added to the existing set.
-      #
-      # Returns the block return.
-      def with_env(env={}, replace=false)
-        current_env = nil
-        begin
-          current_env = set_env(env, replace)
-          yield
-        ensure
-          if current_env
-            set_env(current_env, true)
-          end
-        end
-      end
-      
-      def sh(cmd)
-        if @notify_method_name && verbose?
-          @notify_method_name = false
-          puts
-          puts method_name 
-        end
-        
-        start  = Time.now
-        result = `#{cmd}`
-        finish = Time.now
-        
-        if verbose?
-          elapsed = "%.3f" % [finish-start]
-          puts "  (#{elapsed}s) #{cmd}"
-        end
-        
-        result
-      end
-      
-      def assert_script(script, options={})
-        _assert_script outdent(script), options
-      end
-      
-      def _assert_script(script, options={})
-        commands = CommandParser.new(options).parse(script)
-        commands.each do |cmd, output, status|
-          result = sh(cmd)
-          
-          _assert_output_equal(output, result, cmd) if output
-          assert_equal(status, $?.exitstatus, cmd)  if status
-        end
-      end
-      
-      def assert_script_match(script, options={})
-        _assert_script_match outdent(script), options
-      end
-      
-      def _assert_script_match(script, options={})
-        commands = CommandParser.new(options).parse(script)
-        commands.each do |cmd, output, status|
-          result = sh(cmd)
-          
-          _assert_alike(output, result, cmd)       if output
-          assert_equal(status, $?.exitstatus, cmd) if status
-        end
-      end
-      
-      # Asserts whether or not the a and b strings are equal, with a more
-      # readable output than assert_equal for large strings (especially large
-      # strings with significant whitespace).
-      def assert_output_equal(a, b, msg=nil)
-        _assert_output_equal outdent(a), b, msg
-      end
-      
-      def _assert_output_equal(a, b, msg=nil)
-        if a == b
-          assert true
-        else
-          flunk %Q{
-#{msg}
-==================== expected output ====================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-        end
-      end
-
-      # Asserts whether or not b is like a (which should be a Regexp), and
-      # provides a more readable output in the case of a failure as compared
-      # with assert_match.
-      #
-      # If a is a string it is turned into a RegexpEscape.
-      def assert_alike(a, b, msg=nil)
-        a = outdent(a) if a.kind_of?(String)
-        _assert_alike a, b, msg
-      end
-      
-      def _assert_alike(a, b, msg=nil)
-        if a.kind_of?(String)
-          a = RegexpEscape.new(a)
-        end
-
-        if b =~ a
-          assert true
-        else
-          flunk %Q{
-#{msg}
-================= expected output like ==================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-        end
-      end
-      
-      # helper for stripping indentation off a string
-      def outdent(str)
-        str =~ /\A(?:\s*?\n)( *)(.*)\z/m ? $2.gsub!(/^ {0,#{$1.length}}/, '') : str
-      end
-      
-      # helper for formatting escaping whitespace into readable text
-      def whitespace_escape(str)
-        str.to_s.gsub(/\s/) do |match|
-          case match
-          when "\n" then "\\n\n"
-          when "\t" then "\\t"
-          when "\r" then "\\r"
-          when "\f" then "\\f"
-          else match
-          end
-        end
-      end
-    end
-  end
-end