automate-it 0.9.0

data/lib/automateit/tag_manager/yaml.rb

@@ -0,0 +1,29 @@
+# == TagManager::YAML
+#
+# A TagManager driver that reads tags from a YAML file.
+class AutomateIt::TagManager::YAML < AutomateIt::TagManager::Struct
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    return 5
+  end
+
+  # Options:
+  # * :file -- File to read tags from. The file is preprocessed with ERB and
+  #   must produce YAML content.
+  def setup(opts={})
+    if filename = opts.delete(:file)
+      contents = _read(filename)
+      output = HelpfulERB.new(contents, filename).result
+
+      text = AutomateIt::TagManager::TagParser.normalize(output)
+      opts[:struct] = ::YAML::load(text)
+    end
+    super(opts)
+  end
+
+  def _read(filename)
+    return File.read(filename)
+  end
+  private :_read
+end

data/lib/automateit/template_manager.rb

@@ -0,0 +1,56 @@
+# == TemplateManager
+#
+# TemplateManager renders templates to files.
+#
+# See the #render method for details.
+class AutomateIt::TemplateManager < AutomateIt::Plugin::Manager
+  alias_methods :render
+
+  # Render a template.
+  #
+  # You may specify the +source+ and +target+ as arguments or options. For
+  # example, <tt>render(:file => "input", :to => "output")</tt> is the same as
+  # <tt>render("input", "output")</tt>.
+  #
+  # Options:
+  # * :file -- Read the template from this file.
+  # * :text -- Read the template from this string.
+  # * :to -- Render to a file, otherwise returns the rendered string.
+  # * :locals -- Hash of variables passed to template as local variables.
+  # * :dependencies -- Array of filenames to check timestamps on, only used
+  #   when :check is :timestamp.
+  # * :backup -- Make a backup? Default is true.
+  # * :force -- Render without making a check. Default is false.
+  # * :check -- Determines when to render, otherwise uses value of
+  #   +default_check+, possible values:
+  #   * :compare -- Only render if rendered template is different than the
+  #     target's contents or if the target doesn't exist.
+  #   * :timestamp -- Only render if the target is older than the template and
+  #     dependencies.
+  #   * :exists -- Only render if the target doesn't exist.
+  #
+  # For example, if the file +my_template_file+ contains:
+  #
+  #   Hello <%=entity%>!
+  #
+  # You could then execute:
+  #
+  #   render("my_template_file", "/tmp/out", :check => :compare,
+  #          :locals => {:entity => "world"})
+  #
+  # And this will create a <tt>/tmp/out</tt> file with:
+  #
+  #   Hello world!
+  def render(*options) dispatch(*options) end
+
+  # Get name of default algorithm for performing checks.
+  def default_check() dispatch() end
+
+  # Set name of default algorithms to perform checks, e.g., :compare. See the
+  # #render :check option for list of check algorithms.
+  def default_check=(value) dispatch(value) end
+end # class TemplateManager
+
+# Drivers
+require 'automateit/template_manager/base.rb'
+require 'automateit/template_manager/erb.rb'

data/lib/automateit/template_manager/base.rb

@@ -0,0 +1,181 @@
+# == TemplateManager::BaseDriver
+#
+# Base class for all TemplateManager drivers.
+class AutomateIt::TemplateManager::BaseDriver < AutomateIt::Plugin::Driver
+  # Name of default algorithm for performing checks, e.g., :compare
+  attr_accessor :default_check
+
+  # Options:
+  # * :default_check - Set the #default_check, e.g., :compare
+  def setup(opts={})
+    super(opts)
+    if opts[:default_check]
+      @default_check = opts[:default_check]
+    else
+      @default_check ||= :compare
+    end
+  end
+
+  #.......................................................................
+
+protected
+
+  # Return Array of +dependencies+ newer than +filename+. Will be empty if
+  # +filename+ is newer than all of the +dependencies+.
+  def _newer(filename, *dependencies)
+    updated = []
+    timestamp = _mtime(filename)
+    for dependency in dependencies
+      updated << dependency if _mtime(dependency) > timestamp
+    end
+    return updated
+  end
+
+  # Does +filename+ exist?
+  def _exists?(filename)
+    return File.exists?(filename)
+  end
+
+  # Return the contents of +filename+.
+  def _read(filename)
+    begin
+      result = File.read(filename)
+      return result
+    rescue Errno::ENOENT => e
+      if writing?
+        raise e
+      else
+        return ""
+      end
+    end
+  end
+
+  # Write +contents+ to +filename+.
+  def _write(filename, contents)
+    File.open(filename, "w+"){|writer| writer.write(contents)} if writing?
+    return true
+  end
+
+  # Backup +filename+.
+  def _backup(filename)
+    interpreter.backup(filename)
+  end
+
+  # Return the modification date for +filename+.
+  def _mtime(filename)
+    return _exists? ? File.mtime(filename) : nil
+  end
+
+  # Render a template specified in the block. It takes the same arguments and
+  # returns the same results as the #render call.
+  #
+  # This method is used by the #render methods for different template drivers
+  # and provides all the logic for parsing arguments, figuring out if a
+  # template should be rendered, what to do with the rendering, etc.
+  #
+  # This method calls the supplied +block+ with a hash containing:
+  # * :text -- Template's text.
+  # * :filename -- Template's filename, or nil if none. The template
+  # * :binder -- Binding containing the locals as variables.
+  # * :locals -- Hash of locals.
+  # * :opts -- Hash of options passed to the #_render_helper.
+  #
+  # The supplied block must return the text of the rendered template.
+  #
+  # See the TemplateManager::ERB#render method for a usage example.
+  def _render_helper(*options, &block) # :yields: block_opts
+    args, opts = args_and_opts(*options)
+    source_filename = args[0] || opts[:file]
+    target_filename = args[1] || opts[:to]
+    source_text = opts[:text]
+    opts[:backup] = true if opts[:backup].nil?
+
+    raise ArgumentError.new("No source specified with :file or :text") if not source_filename and not source_text
+    raise Errno::ENOENT.new(source_filename) if writing? and source_filename and not _exists?(source_filename)
+
+    begin
+      # source_filename, target_filename, opts={}
+      opts[:check] ||= @default_check
+      target_exists = target_filename && _exists?(target_filename)
+      updates = []
+
+      if target_filename
+        unless opts[:force]
+          case opts[:check]
+          when :exists
+            if target_exists
+              log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because it already exists")
+              return false
+            else
+              log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
+            end
+          when :timestamp
+            if target_exists
+              updates = _newer(target_filename, \
+                  *[source_filename, opts[:dependencies]].reject{|t| t.nil?}.flatten)
+              if updates.empty?
+                log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because dependencies haven't been updated")
+                return false
+              end
+            end
+          end
+        end
+      end
+
+      target_contents = target_exists ? _read(target_filename) : ""
+      source_text ||= _read(source_filename)
+
+      if source_text.blank? and preview?
+        return true
+      end
+
+      binder = nil
+      if opts[:locals]
+        # Create a binding that the template can get variables from without
+        # polluting the Driver's namespace.
+        callback = lambda{
+          code = ""
+          for key in opts[:locals].keys
+            code << "#{key} = opts[:locals][:#{key}]\n"
+          end
+          eval code
+          binding
+        }
+        binder = callback.call
+      end
+
+      block_opts = {
+        :binder => binder,
+        :filename => source_filename,
+        :text => source_text,
+        :locals => opts[:locals],
+        :opts => opts,
+      }
+      output = block.call(block_opts)
+
+      if target_filename
+        case opts[:check]
+        when :compare
+          if not target_exists
+            log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
+          elsif output == target_contents
+            log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because contents are the same")
+            return false
+          else
+            log.info(PNOTE+"Rendering '#{target_filename}' because its contents changed")
+          end
+        when :timestamp
+          log.info(PNOTE+"Rendering '#{target_filename}' because of updated: #{updates.join(' ')}")
+        end
+      end
+
+      _backup(target_filename) if target_exists and opts[:backup]
+
+      return(target_filename ? _write(target_filename, output) : output)
+    ensure
+      if opts[:mode] or opts[:user] or opts[:group]
+        interpreter.chperm(target_filename, :mode => opts[:mode], :user => opts[:user], :group => opts[:group])
+      end
+    end
+  end
+end

data/lib/automateit/template_manager/erb.rb

@@ -0,0 +1,17 @@
+# == TemplateManager::ERB
+#
+# Renders ERB templates for TemplateManager.
+class AutomateIt::TemplateManager::ERB < AutomateIt::TemplateManager::BaseDriver
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+
+  # See documentation for TemplateManager#render
+  def render(*options)
+    return _render_helper(*options) do |o|
+      HelpfulERB.new(o[:text], o[:filename]).result(o[:binder])
+    end
+  end
+end

data/lib/ext/metaclass.rb

@@ -0,0 +1,17 @@
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval(&blk); metaclass.instance_eval(&blk); end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/ext/object.rb

@@ -0,0 +1,18 @@
+class Object
+  # Lists methods unique to an instance.
+  def unique_methods
+    (public_methods - Object.methods).sort.map(&:to_sym)
+  end
+
+  # Lists methods unique to a class.
+  def self.unique_methods
+    (public_methods - Object.methods).sort.map(&:to_sym)
+  end
+
+  # Returns a list of arguments and an options hash. Source taken from RSpec.
+  def args_and_opts(*args)
+    options = Hash === args.last ? args.pop : {}
+    return args, options
+  end
+end
+

data/lib/ext/shell_escape.rb

@@ -0,0 +1,7 @@
+# Suraj Kurapati -- http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/261459
+class String
+  # Transforms this string into an escaped POSIX shell argument.
+  def shell_escape
+    inspect.gsub(/\\(\d{3})/) {$1.to_i(8).chr}
+  end
+end

data/lib/hashcache.rb

@@ -0,0 +1,22 @@
+# A very simple cache. Works just like a Hash, but can optionally store values
+# during the fetch process.
+#
+# Example:
+#   hc = HashCache.new
+#   hc.fetch("foo")
+#   => nil
+#   hc.fetch("foo"){:bar} # Block gets called because 'foo' is nil
+#   => :bar
+#   hc.fetch("foo"){raise "Block won't be called because 'foo' is cached"}
+#   => :bar
+class HashCache < Hash
+  def fetch(key, &block)
+    if has_key?(key) 
+      self[key] 
+    elsif block
+      self[key] = block.call
+    else
+      nil
+    end
+  end
+end

data/lib/helpful_erb.rb

@@ -0,0 +1,63 @@
+require 'erb'
+require 'nested_error'
+
+class HelpfulERB
+  class Error < ::NestedError; end
+
+  # ERB object
+  attr_accessor :erb
+
+  attr_accessor :lines_before
+
+  attr_accessor :lines_after
+
+  # Template filename
+  attr_accessor :filename
+
+  def initialize(text, filename=nil, opts={})
+    @text = text
+    @filename = filename
+    @lines_before = opts[:before] || 5
+    @lines_after = opts[:before] || 1
+
+    @erb = ::ERB.new(@text, nil, '-')
+    @erb.filename = @filename if @filename
+  end
+
+  def result(binder=nil)
+    begin
+      return @erb.result(binder)
+    rescue Exception => e
+      stack = caller 0
+      for i in 0..e.backtrace.size
+        l = e.backtrace[i]
+        #puts "%s %s" % [i, l];
+        break if l =~ /^([^:]+):(\d+):in `(render|result)'$/
+      end
+      template = $1
+      line_number = $2.to_i
+      raise Exception.new("Caught ERB error but couldn't find line number in backtrace:\n#{e.backtrace.join("\n")}") unless line_number
+
+      lines = @text.split(/\n/)
+
+      min = line_number - @lines_before
+      min = 0 if min < 0
+
+      max = line_number + @lines_after
+      max = lines.size if max > lines.size
+
+      width = max.to_s.size
+
+      msg = "Problem with template '#{template}' at line #{line_number}:\n"
+      for i in min..max
+        n = i+1
+        marker = n == line_number ? "*" : ""
+        msg << "\n%2s %#{width}i %s" % [marker, n, lines[i]]
+      end
+      msg << "\n\n(#{e.exception.class}) #{e.message}"
+
+
+      raise NestedError.new(msg, e)
+    end
+  end
+end

data/lib/inactive_support.rb

@@ -0,0 +1,53 @@
+# == InactiveSupport
+#
+# InactiveSupport is a subset of features copied from the Rails ActiveSupport
+# 2.0.2 library, and retain the same ownership and licensing as the originals.
+#
+# Using this subset of ActiveSupport makes AutomateIt:
+# * More reliable: InactiveSupport is guaranteed correctly to work because it's
+#   part of AutomateIt. This is in contrast to ActiveSupport, which is
+#   versioned separately and regularly introduces new bugs and breaks backwards
+#   compatibility, which makes it unsuitable as a library.
+# * Easier and faster install: Installing AutomateIt is easier and faster
+#   because it no longer needs the ActiveSupport and Builder gems..
+# * Quicker startup: InactiveSupport loads in a fraction of the time that
+#   ActiveSupport takes.
+
+require 'inactive_support/core_ext/array/extract_options' # [].extract_options
+class Array
+  include InactiveSupport::CoreExtensions::Array::ExtractOptions
+end
+
+require 'inactive_support/core_ext/blank' # foo.blank?
+require 'inactive_support/core_ext/symbol' # [:foo, :bar].map(&:to_s)
+require 'inactive_support/core_ext/module/aliasing' # alias_method_chain
+require 'inactive_support/core_ext/class/attribute_accessors' # cattr_accessor
+require 'inactive_support/core_ext/class/inheritable_attributes' # inheritable_cattr_accessor
+require 'inactive_support/core_ext/enumerable' # sum
+
+require 'inactive_support/core_ext/numeric/time' # 1.day
+class Numeric
+  include InactiveSupport::CoreExtensions::Numeric::Time
+end
+
+require 'inactive_support/core_ext/string/inflections' # "asdf".demodulize.underscore
+class String
+  include InactiveSupport::CoreExtensions::String::Inflections
+end
+
+require 'inactive_support/core_ext/hash/keys' # {:foo => :bar}.stringify_keys
+class Hash
+  include InactiveSupport::CoreExtensions::Hash::Keys
+end
+
+# since used with rails, this is conflict
+#require 'inactive_support/basic_object' # Ruby 1.9 compatibility
+require 'inactive_support/duration' # adds dates
+
+require 'inactive_support/core_ext/time/conversions' # to_formatted_s
+class Time
+  include InactiveSupport::CoreExtensions::Time::Conversions
+end
+
+
+#require 'inactive_support/clean_logger' # cleans up Logger output