mattock 0.0.1

data/lib/mattock.rb

@@ -0,0 +1,4 @@
+require 'mattock/tasklib'
+require 'mattock/command-line'
+require 'mattock/remote-command-task'
+require 'mattock/template-host'

data/lib/mattock/command-line.rb

@@ -0,0 +1,157 @@
+module Mattock
+  class CommandRunResult
+    def initialize(status, streams)
+      @process_status = status
+      @streams = streams
+    end
+    attr_reader :process_status, :streams
+
+    def stdout
+      @streams[1]
+    end
+
+    def stderr
+      @streams[2]
+    end
+
+    def exit_code
+      @process_status.exitstatus
+    end
+    alias exit_status exit_code
+
+    def succeeded?
+      must_succeed!
+      return true
+    rescue
+      return false
+    end
+
+    def must_succeed!
+      case exit_code
+      when 0
+        return exit_code
+      else
+        fail "Command '#{name}' failed with exit status #{$?.exitstatus}: \n"
+      end
+    end
+  end
+
+  class CommandLine
+    def initialize(executable, *options)
+      @executable = executable
+      @options = options
+      @redirections = []
+      yield self if block_given?
+    end
+
+    attr_accessor :name, :executable, :options
+
+    def name
+      @name || executable
+    end
+
+    def command
+      ([executable] + options + @redirections).join(" ")
+    end
+
+    def redirect_to(stream, path)
+      @redirections << "#{stream}>#{path}"
+    end
+
+    def redirect_from(path, stream)
+      @redirections << "#{stream}<#{path}"
+    end
+
+    def copy_stream_to(from, to)
+      @redirections << "#{from}>&#{to}"
+    end
+
+    def redirect_stdout(path)
+      redirect_to(1, path)
+    end
+
+    def redirect_stderr(path)
+      redirect_to(2, path)
+    end
+
+    def redirect_stdin(path)
+      redirect_from(path, 0)
+    end
+
+    def self.execute(command)
+      pipe = IO.popen(command)
+      pid = pipe.pid
+      pid, status = Process.wait2(pid)
+      result = CommandRunResult.new(status, {1 => pipe.read})
+      pipe.close
+      return result
+    end
+
+    def run
+      print command + " " if $verbose
+      result = self.class.execute(command)
+      print "=> #{result.exit_code}" if $verbose
+      return result
+    ensure
+      puts if $verbose
+    end
+
+    def succeeds?
+      run.succeeded?
+    end
+
+    def must_succeed!
+      run.must_succeed!
+    end
+  end
+
+  class ShellEscaped < CommandLine
+    def initialize(cmd)
+      @escaped = cmd
+    end
+
+    def command
+      "'" + @escaped.command.gsub(/'/,"\'") + "'"
+    end
+
+    def name
+      @name || @escaped.name
+    end
+  end
+
+  class CommandChain < CommandLine
+    def initialize
+      @commands = []
+      yield self if block_given?
+    end
+
+    attr_reader :commands
+
+    def add(cmd)
+      yield cmd if block_given?
+      @commands << cmd
+    end
+
+    def name
+      @name || @commands.last.name
+    end
+  end
+
+  class WrappingChain < CommandChain
+    def command
+      @commands.map{|cmd| cmd.command}.join(" -- ")
+    end
+  end
+
+  class PrereqChain < CommandChain
+    def command
+      @commands.map{|cmd| cmd.command}.join(" && ")
+    end
+  end
+
+  class PipelineChain < CommandChain
+    def command
+      @commands.map{|cmd| cmd.command}.join(" | ")
+    end
+  end
+end

data/lib/mattock/command-task.rb

@@ -0,0 +1,51 @@
+require 'mattock/tasklib'
+require 'mattock/command-line'
+
+module Mattock
+  module NeededPredicate
+    def needed_predicate(&block)
+      (class << self; self; end).instance_eval do
+        define_method(:needed?, &block)
+      end
+    end
+  end
+
+  class CommandTask < TaskLib
+    setting(:task_name, :run)
+    setting(:command)
+    setting(:verify_command, nil)
+
+    def verify_command
+      if @verify_command.respond_to?(:call)
+        @verify_command = @verify_command.call
+      end
+      @verify_command
+    end
+
+    def decorated(cmd)
+      cmd
+    end
+
+    def command_task
+      @command_task ||=
+        begin
+          task task_name do
+            decorated(command).must_succeed!
+          end
+        end
+    end
+
+    def define
+      in_namespace do
+        command_task
+        unless verify_command.nil?
+          needed = decorated(verify_command)
+          command_task.extend NeededPredicate
+          command_task.needed_predicate do
+            !needed.succeeds?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mattock/configurable.rb

@@ -0,0 +1,129 @@
+module Mattock
+  module Configurable
+    RequiredField = Object.new
+    class << RequiredField
+      def to_s
+        "<unset>"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+    RequiredField.freeze
+
+    module ClassMethods
+
+      def default_values
+        @default_values ||= {}
+      end
+
+      def set_defaults_on(instance)
+        if Configurable > superclass
+          superclass.set_defaults_on(instance)
+        end
+        default_values.each_pair do |name,value|
+          instance.__send__("#{name}=", value)
+          if Configurable === value
+            value.class.set_defaults_on(value)
+          end
+        end
+      end
+
+      def missing_required_fields_on(instance)
+        missing = []
+        if Configurable > superclass
+          missing = superclass.missing_required_fields_on(instance)
+        end
+        default_values.each_pair do |name,value|
+          set_value = instance.__send__(name)
+          if value == RequiredField and set_value == RequiredField
+            missing << name
+            next
+          end
+          if Configurable === set_value
+            missing += set_value.class.missing_required_fields_on(set_value).map do |field|
+              [name, field].join(".")
+            end
+          end
+        end
+        return missing
+      end
+
+      def nested(hash=nil)
+        obj = Class.new(Struct).new
+        obj.settings(hash || {})
+        return obj
+      end
+
+      def nil_fields(*names)
+        names.each do |name|
+          setting(name, nil)
+        end
+      end
+      alias nil_field nil_fields
+
+      def required_fields(*names)
+        names.each do |name|
+          setting(name)
+        end
+      end
+      alias required_field required_fields
+
+      def setting(name, default_value = RequiredField)
+        name = name.to_sym
+        attr_accessor(name)
+        if default_values.has_key?(name) and default_values[name] != default_value
+          warn "Changing default value of #{self.name}##{name} from #{default_values[name].inspect} to #{default_value.inspect}"
+        end
+        default_values[name] = default_value
+      end
+
+      def settings(hash)
+        hash.each_pair do |name, value|
+          setting(name, value)
+        end
+        return self
+      end
+    end
+
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+
+    def setup_defaults
+      self.class.set_defaults_on(self)
+      self
+    end
+
+    def check_required
+      missing = self.class.missing_required_fields_on(self)
+      unless missing.empty?
+        raise "Required field#{missing.length > 1 ? "s" : ""} #{missing.join(", ")} unset on #{self.inspect}"
+      end
+      self
+    end
+
+    def setting(name, default_value = nil)
+      self.class.setting(name, default_value)
+      instance_variable_set("@#{name}", default_value)
+    end
+
+    def settings(hash)
+      hash.each_pair do |name, value|
+        setting(name, value)
+      end
+      return self
+    end
+
+    def required_fields(*names)
+      self.class.required_fields(*names)
+      self
+    end
+    alias required_field required_fields
+
+    class Struct
+      include Configurable
+    end
+  end
+end

data/lib/mattock/remote-command-task.rb

@@ -0,0 +1,30 @@
+require 'mattock/command-task'
+module Mattock
+  class RemoteCommandTask < CommandTask
+    setting(:remote_server, nested(
+      :address => nil,
+      :user => nil
+    ))
+    setting(:ssh_options, [])
+    nil_fields(:id_file, :free_arguments)
+
+    def decorated(command_on_remote)
+      fail "Need remote server for #{self.class.name}" unless remote_server.address
+
+      raise "Empty remote command" if command_on_remote.nil?
+      Mattock::WrappingChain.new do |cmd|
+        cmd.add Mattock::CommandLine.new("ssh") do |cmd|
+          cmd.options << "-u #{remote_server.user}" if remote_server.user
+          cmd.options << "-i #{id_file}" if id_file
+          unless ssh_options.empty?
+            ssh_options.each do |opt|
+              cmd.options "-o #{opt}"
+            end
+          end
+          cmd.options << remote_server.address
+        end
+        cmd.add Mattock::ShellEscaped.new(command_on_remote)
+      end
+    end
+  end
+end

data/lib/mattock/tasklib.rb

@@ -0,0 +1,76 @@
+require 'ostruct'
+require 'rake/tasklib'
+require 'mattock/configurable'
+
+module Mattock
+  class TaskLib < Rake::TaskLib
+    include Configurable
+
+    attr_writer :namespace_name
+    def self.default_namespace(name)
+      setting(:namespace_name, name)
+    end
+
+    def initialize(*tasklibs)
+      @tasks = []
+
+      default_configuration(*tasklibs)
+
+      yield self if block_given?
+
+      resolve_configuration
+
+      define
+    end
+
+    attr_reader :tasks
+
+    def task(*args)
+      a_task = super
+      @tasks << a_task
+      return a_task
+    end
+
+    def default_configuration(*tasklibs)
+      setup_defaults
+    end
+
+    def resolve_configuration
+      check_required
+    end
+
+    def define
+    end
+
+    def in_namespace(*tasknames)
+      if tasknames.empty?
+        if block_given?
+          if @namespace_name.nil?
+            yield
+          else
+            namespace @namespace_name do
+              yield
+            end
+          end
+        end
+      else
+        tasknames.map do |taskname|
+          [@namespace_name, taskname].compact.join(":")
+        end
+      end
+    end
+
+    def root_task
+      @namespace_name || :default
+    end
+
+    def default_namespace
+      nil
+    end
+
+    def [](taskname)
+      in_namespace(taskname).first
+    end
+  end
+  Tasklib = TaskLib #Because I can never remember
+end