linecook 0.6.2

data/lib/linecook/test/regexp_escape.rb

@@ -0,0 +1,86 @@
+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.rb

@@ -0,0 +1,172 @@
+require 'linecook/cookbook'
+require 'linecook/recipe'
+require 'linecook/test/file_test'
+require 'linecook/test/regexp_escape'
+require 'linecook/utils'
+
+module Linecook
+  module Test
+    include FileTest
+    
+    attr_writer :cookbook
+    attr_writer :script
+    attr_writer :recipe
+    
+    def cookbook
+      @cookbook ||= Cookbook.init(user_dir)
+    end
+    
+    def manifest
+      cookbook.manifest
+    end
+    
+    def default_env
+      {Package::CONFIG_KEY => {Package::MANIFEST_KEY => manifest}}
+    end
+    
+    def recipe
+      @recipe ||= Recipe.new('recipe', default_env)
+    end
+    
+    def build(env={})
+      env = Utils.deep_merge(default_env, env)
+      Recipe.build(env).export File.join(method_dir, 'scripts')
+    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).
+    #
+    # One gotcha is that assert_output_equal lstrips indentation off of 'a',
+    # so that these all pass:
+    #
+    #   assert_output_equal %q{
+    #   line one
+    #   line two
+    #   }, "line one\nline two\n"
+    #
+    #   assert_output_equal %q{
+    #     line one
+    #     line two
+    #   }, "line one\nline two\n
+    #
+    #     assert_output_equal %q{
+    #     line one
+    #     line two
+    #     }, "line one\nline two\n"
+    #
+    # Use the assert_output_equal! method to prevent indentation stripping.
+    def assert_output_equal(a, b, msg=nil)
+      a = strip_indent(a)
+      assert_output_equal!(a, b, msg)
+    end
+
+    # Same as assert_output_equal but without indentation stripping.
+    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, then indentation is stripped off and it is turned
+    # into a RegexpEscape. Using that syntax, all these pass:
+    #
+    #   assert_alike %q{
+    #   the time is: :...:
+    #   now!
+    #   }, "the time is: #{Time.now}\nnow!\n"
+    #
+    #   assert_alike %q{
+    #     the time is: :...:
+    #     now!
+    #   }, "the time is: #{Time.now}\nnow!\n"
+    #
+    #     assert_alike %q{
+    #     the time is: :...:
+    #     now!
+    #     }, "the time is: #{Time.now}\nnow!\n"
+    #
+    # Use assert_alike! to prevent indentation stripping (conversion to a
+    # RegexpEscape is still in effect).
+    def assert_alike(a, b, msg=nil)
+      a = strip_indent(a) if a.kind_of?(String)
+      assert_alike!(a, b, msg)
+    end
+
+    # Same as assert_alike but without indentation stripping.
+    def assert_alike!(a, b, msg=nil)
+      a = RegexpEscape.new(a) if a.kind_of?(String)
+
+      if b =~ a
+        assert true
+      else
+        flunk %Q{
+#{msg}
+================= expected output like ==================
+#{whitespace_escape(a)}
+======================== but was ========================
+#{whitespace_escape(b)}
+=========================================================
+}
+      end
+    end
+
+    def assert_recipe(expected, &block)
+      recipe.instance_eval(&block)
+      assert_output_equal expected, recipe.result
+    end
+    
+    def assert_recipe_match(expected, &block)
+      recipe.instance_eval(&block)
+      assert_alike expected, recipe.result
+    end
+
+    def assert_content(expected, build_path)
+      registry = recipe.close
+
+      assert_equal true, registry.has_key?(build_path), "not in registry: #{build_path}"
+      assert_output_equal expected, File.read(registry[build_path]), build_path
+    end
+    
+    private
+
+    # helper for stripping indentation off a string
+    def strip_indent(str) # :nodoc:
+      if str =~ /\A\s*?\n( *)(.*)\z/m
+        indent, str = $1, $2, $3
+
+        if indent.length > 0
+          str.gsub!(/^ {0,#{indent.length}}/, '')
+        end
+      end
+
+      str
+    end
+
+    # helper for formatting escaping whitespace into readable text
+    def whitespace_escape(str) # :nodoc:
+      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

data/lib/linecook/utils.rb

@@ -0,0 +1,53 @@
+module Linecook
+  module Utils
+    module_function
+    
+    def nest_hash
+      Hash.new {|hash, key| hash[key] = nest_hash }
+    end
+    
+    def serial_merge(*hashes)
+      attrs = {}
+      while overrides = hashes.shift
+        attrs = deep_merge(attrs, overrides)
+      end
+      attrs
+    end
+    
+    def deep_merge(a, b)
+      b.each_pair do |key, current|
+        previous = a[key]
+        a[key] = deep_merge?(previous, current) ? deep_merge(previous, current) : current
+      end
+      
+      a
+    end
+    
+    def deep_merge?(previous, current)
+      current.kind_of?(Hash) && previous.kind_of?(Hash)
+    end
+    
+    def camelize(str)
+      str.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    
+    def underscore(str)
+      str.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+    
+    def constantize(const_name)
+      constants = camelize(const_name).split(/::/)
+      
+      const = Object
+      while name = constants.shift
+        const = const.const_get(name)
+      end
+      
+      const
+    end
+  end
+end

data/lib/linecook/version.rb

@@ -0,0 +1,8 @@
+module Linecook
+  MAJOR = 0
+  MINOR = 6
+  TINY  = 2
+
+  VERSION = "#{MAJOR}.#{MINOR}.#{TINY}"
+  WEBSITE = "http://github.com/pinnacol/linecook"
+end

data/lib/linecook.rb

@@ -0,0 +1,6 @@
+require 'linecook/helper'
+require 'linecook/script'
+require 'linecook/cookbook'
+
+module Linecook
+end

data/templates/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/templates/README

@@ -0,0 +1,90 @@
+= README
+
+Linecook provides support to develop scripts using VirtualBox, an open-source
+product to setup and manage virtual machines. Nothing says you have to use
+VirtualBox during development and obviously you can take the shell scripts
+produced by Linecook and run them wherever.
+
+These are instructions for setting up a generic Ubuntu VM for development.
+
+1. Download and Install VirtualBox (http://www.virtualbox.org)
+2. Download a Ubuntu ISO (http://www.ubuntu.com/server/get-ubuntu/download)
+3. Build the Box
+
+Use the VirtualBox wizard to get started.
+
+- name: vbox
+- Linux/Ubuntu
+- 512 MB memory
+- 8 GB dynamically resizing drive
+
+Under Settings:
+
+- add the ubuntu iso to the cd/dvd device (under storage)
+- disable audio
+- network set to NAT
+- disable usb (only the inner box would stay unchecked)
+- shared folder: map the 'vbox' directory in project root
+
+Start the server and install (default unless specified):
+
+- hostname: vbox-ubuntu
+- user/password: vbox
+- no packages
+- power off, remove ubuntu iso from the cd/dvd device 
+
+Setup Permissions (allows vbox to run sudo without password):
+
+  vm: sudo visudo
+
+  # insert line:
+  #
+  #   %vbox ALL=NOPASSWD: ALL
+  #
+  # then exit (write out changes as prompted)
+
+Setup guest additions (note they are in the application package on
+osx http://forums.virtualbox.org/viewtopic.php?f=8&t=10286) See also:
+http://forums.virtualbox.org/viewtopic.php?t=15868.
+
+  (cd/dvd device): add the VBoxGuestAdditions.iso
+  vm: sudo apt-get install linux-headers-$(uname -r) build-essential ssh openssh-server
+  vm: sudo mkdir /media/dvd
+  vm: sudo mount /dev/dvd /media/dvd/
+  vm: sudo sh /media/dvd/VBoxLinuxAdditions-x86.run
+  # there may be a warning about 'Window System drivers fail', ignore
+
+Add an init script to mount the share on boot:
+
+  vm: sudo mkdir /vbox
+  vm: sudo mount -t vboxsf -o uid=1000,gid=100 vbox /vbox
+  vm: sudo cp /vbox/setup/virtual_box /etc/init.d
+  vm: sudo chmod 0755 /etc/init.d/virtual_box
+  vm: sudo update-rc.d virtual_box defaults 80
+  
+Setup SSH:
+
+  vm: mkdir ~/.ssh
+  vm: chmod 0700 ~/.ssh
+  vm: cat /vbox/ssh/id_rsa.pub >> ~/.ssh/authorized_keys
+  vm: chmod 0600 ~/.ssh/authorized_keys
+
+Now take a snapshot and setup port forwarding:
+
+  vm: exit
+  ht: VBoxManage snapshot vbox take BASE
+  ht: VBoxManage controlvm vbox poweroff
+  ht: VBoxManage modifyvm vbox --natpf1 'guestssh,tcp,,2222,,22'
+  ht: VBoxManage modifyvm vbox --natpf1 'http,tcp,,8888,,80'
+  ht: VBoxManage -q snapshot vbox restore BASE
+  ht: VBoxManage startvm vbox --type headless
+
+You can now ssh to the box (from the project dir):
+
+  ht: chmod 0600 vbox/ssh/id_rsa
+  ht: ssh -p 2222 -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o IdentitiesOnly=yes -i vbox/ssh/id_rsa vbox@localhost
+
+To cleanup the port forwarding (run later):
+
+  ht: VBoxManage modifyvm vbox --natpf1 delete 'guestssh'
+  ht: VBoxManage modifyvm vbox --natpf1 delete 'http'

data/templates/Rakefile

@@ -0,0 +1,149 @@
+require 'rake'
+
+#
+# Gem tasks
+#
+
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+def gemspec
+  @gemspec ||= eval(File.read('<%= project_name %>.gemspec'), TOPLEVEL_BINDING)
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Prints the gemspec manifest.'
+task :print_manifest do
+  files = gemspec.files.inject({}) do |files, file|
+    files[File.expand_path(file)] = [File.exists?(file), file]
+    files
+  end
+  
+  cookbook_files = Dir.glob('{attributes,files,lib,recipes,templates}/**/*')
+  cookbook_file  = Dir.glob('*')
+  
+  (cookbook_files + cookbook_file).each do |file|
+    next unless File.file?(file)
+    path = File.expand_path(file)
+    files[path] = ['', file] unless files.has_key?(path)
+  end
+  
+  # sort and output the results
+  files.values.sort_by {|exists, file| file }.each do |entry| 
+    puts '%-5s %s' % entry
+  end
+end
+
+#
+# Documentation tasks
+#
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  spec = gemspec
+  
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options.concat(spec.rdoc_options)
+  rdoc.rdoc_files.include(spec.extra_rdoc_files)
+  
+  files = spec.files.select {|file| file =~ /^lib.*\.rb$/}
+  rdoc.rdoc_files.include( files )
+end
+
+#
+# Dependency tasks
+#
+
+desc 'Bundle dependencies'
+task :bundle do
+  output = `bundle check 2>&1`
+  
+  unless $?.to_i == 0
+    puts output
+    sh "bundle install 2>&1"
+    puts
+  end
+end
+
+#
+# Linecook Helpers
+#
+
+lib_dir     = File.expand_path("../lib", __FILE__)
+helpers_dir = File.expand_path("../helpers", __FILE__)
+
+sources = {}
+helpers = []
+
+Dir.glob("#{helpers_dir}/**/*").each do |source|
+  next if File.directory?(source)
+  (sources[File.dirname(source)] ||= []) << source
+end
+
+sources.each_pair do |dir, sources|
+  name = dir[(helpers_dir.length + 1)..-1]
+  target = File.join(lib_dir, 'linebook', "#{name}.rb")
+  
+  file target => sources + [dir] do
+    system "bundle exec linecook helper '#{name}' --force"
+  end
+  
+  helpers << target
+end
+
+desc "generate helpers"
+task :helpers => helpers + [:bundle]
+
+#
+# Linecook Scripts
+#
+
+scripts      = Dir.glob("scripts/*.yml")
+dependencies = Dir.glob('{attributes,files,recipes,templates}/**/*')
+
+scripts.each do |source|
+  target = source.chomp('.yml')
+  name   = File.basename(target)
+  
+  namespace :scripts do
+    file target => dependencies + [source] + helpers do
+      sh "bundle exec linecook package '#{source}' '#{target}' --force"
+    end
+    
+    desc "generate the script: #{name}"
+    task name => target
+  end
+  
+  task :scripts => target
+end
+
+desc "generate scripts"
+task :scripts
+
+#
+# Test tasks
+#
+
+desc 'Default: Run tests.'
+task :default => :test
+
+desc 'Run the tests'
+task :test => :helpers do
+  tests = Dir.glob('test/**/*_test.rb')
+  
+  if ENV['RCOV'] == 'true'
+    FileUtils.rm_rf File.expand_path('../coverage', __FILE__)
+    sh('rcov', '-w', '--text-report', '--exclude', '^/', *tests)
+  else
+    sh('ruby', '-w', '-e', 'ARGV.dup.each {|test| load test}', *tests)
+  end
+end
+
+desc 'Run rcov'
+task :rcov do
+  ENV['RCOV'] = 'true'
+  Rake::Task["test"].invoke
+end

data/templates/_gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.bundle
+*.gem
+/rdoc
+vbox/log

data/templates/attributes/project_name.rb

@@ -0,0 +1,4 @@
+# Define default recipe attributes here and include in a recipe using
+# 'attributes "filename"'. Script attributes override these values.
+attrs['<%= project_name %>']['letters'] = ['a', 'b', 'c']
+attrs['<%= project_name %>']['numbers'] = [1, 2, 3]

data/templates/cookbook

@@ -0,0 +1,9 @@
+# Configure the cookbook here.
+# Adding this file to a gem marks it as a cookbook gem
+# (note that in a gem the contents of this file are ignored)
+
+# Define directories searched for attributes/recipes/etc.
+# paths: ['.']
+
+# Name the gems added to path - defaults to all marked gems.
+# gems: []

data/templates/files/file.txt

@@ -0,0 +1 @@
+Contents of an example file.

data/templates/helpers/project_name/echo.erb

@@ -0,0 +1,5 @@
+An example of a helper definition. This is the documentation, followed by the
+method signature and then the ERB template.
+(*args)
+--
+echo '<%= "<" + "%= args.join(' ') %"+ ">" %>'

data/templates/project_name.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "<%= project_name %>"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = "TODO: Write your name"
+  s.email       = "TODO: Write your email address"
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+  s.rubyforge_project = ''
+  
+  s.has_rdoc = true
+  s.rdoc_options.concat %W{--main README -S -N --title <%= project_name.capitalize %>}
+  
+  # add dependencies
+  s.add_dependency('linecook', '~> <%= Linecook::VERSION %>')
+  
+  # list extra rdoc files here.
+  s.extra_rdoc_files = %W{
+    cookbook
+  }
+  
+  # list the files you want to include here.
+  s.files = %W{
+  }
+  
+  s.require_path = 'lib'
+end

data/templates/recipes/project_name.rb

@@ -0,0 +1,20 @@
+#############################################################################
+helpers 'linecook/shell'
+helpers 'linebook/<%= project_name %>'
+attributes '<%= project_name %>'
+#############################################################################
+
+shebang '/bin/bash'
+
+# Write to the script target using 'script'
+target.puts '# An example script.'
+
+# Helpers are now available, as are attributes.
+echo *attrs['<%= project_name %>']['letters']
+echo *attrs['<%= project_name %>']['numbers']
+
+# Use files like this:
+cat file_path('file.txt')
+
+# Use templates like this:
+cat template_path('template.txt', :n => 10)

data/templates/scripts/project_name.yml

@@ -0,0 +1,7 @@
+# Configure Linecook
+linecook:
+  recipes: [<%= project_name %>]
+
+# Set attributes for the script
+<%= project_name %>:
+  numbers: [7, 8, 9]

data/templates/templates/template.txt.erb

@@ -0,0 +1,3 @@
+<%= '<' %>% n.times do %<%= '>' %>
+Contents of a template file.
+<%= '<' %>% end %<%= '>' %>