mattock 0.3.4 → 0.4.0

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

@@ -1,7 +1,7 @@
 require 'mattock/command-task'
 
 module Mattock
-  class BundleCommandTask < CommandTask
+  class BundleCommandTask < Rake::CommandTask
     def cleaned_env
       env = {}
       if defined? Bundler

data/lib/mattock/cascading-definition.rb

@@ -23,12 +23,12 @@ module Mattock
   module CascadingDefinition
     include Configurable
 
-    def initialize(*tasklibs)
+    def setup_cascade(*other_definitions)
       @runtime = false
       setup_defaults
 
       confirm_steps(:default_configuration, :resolve_configuration, :confirm_configuration) do
-        default_configuration(*tasklibs)
+        default_configuration(*other_definitions)
 
         yield self if block_given?
 
@@ -93,10 +93,9 @@ module Mattock
       mod.setting(:configuration_block, proc{})
     end
 
-    def initialize(*args, &block)
+    def setup_deferred
       @runtime = false
       @finalized = false
-      super
     end
 
     def runtime_definition(&block)

data/lib/mattock/command-line.rb

@@ -77,7 +77,7 @@ module Mattock
     alias_method :command_environment, :env
 
     def verbose
-      Rake.verbose && Rake.verbose != Rake::FileUtilsExt::DEFAULT
+      ::Rake.verbose && ::Rake.verbose != ::Rake::FileUtilsExt::DEFAULT
     end
 
     def name
@@ -136,8 +136,8 @@ module Mattock
     def collect_result(pid, host_stdout, host_stderr)
       pid, status = Process.wait2(pid)
 
-      stdout = host_stdout.read
-      stderr = host_stderr.read
+      stdout = consume_buffer(host_stdout)
+      stderr = consume_buffer(host_stderr)
       result = CommandRunResult.new(command, status, {1 => stdout, 2 => stderr})
       host_stdout.close
       host_stderr.close
@@ -145,6 +145,24 @@ module Mattock
       return result
     end
 
+    #Gets all the data out of buffer, even if somehow it doesn't have an EOF
+    #Escpecially useful for programs (e.g. ssh) that sometime set their stderr
+    #to O_NONBLOCK
+    def consume_buffer(io)
+      accumulate = []
+      waits = 3
+      begin
+        while chunk = io.read_nonblock(4096)
+          accumulate << chunk
+        end
+      rescue IO::WaitReadable => ex
+        retry if (waits -= 1) > 0
+      end
+      return accumulate.join
+    rescue EOFError
+      return accumulate.join
+    end
+
     #If I wasn't worried about writing my own limited shell, I'd say e.g.
     #Pipeline would be an explicit chain of pipes... which is probably as
     #originally intended :/
@@ -152,11 +170,20 @@ module Mattock
       collect_result(*spawn_process)
     end
 
+    #Run a command in the background.  The command can survive the caller
+    def spin_off
+      pid, out, err = spawn_process
+      Process.detach(pid)
+      return pid, out, err
+    end
+
+    #Run a command in parallel with the parent process - will kill it if it
+    #outlasts us
     def background
       pid, out, err = spawn_process
+      Process.detach(pid)
       at_exit do
         kill_process(pid)
-        Process.detach(pid)
       end
       return pid, out, err
     end

data/lib/mattock/command-task.rb

@@ -2,13 +2,14 @@ require 'mattock/task'
 require 'mattock/command-line'
 
 module Mattock
-  class CommandTask < Task
+  module CommandTaskMixin
     include CommandLineDSL
-    extend CommandLineDSL
 
-    setting(:task_name, :run)
-    runtime_setting(:verify_command, nil)
-    runtime_setting(:command)
+    def self.included(sub)
+      sub.extend CommandLineDSL
+      sub.runtime_setting(:verify_command, nil)
+      sub.runtime_setting(:command)
+    end
 
     def resolve_runtime_configuration
       super
@@ -38,17 +39,41 @@ module Mattock
       command
     end
 
-    def action
+    def action(args)
       decorated(command).must_succeed!
     end
 
     def needed?
       finalize_configuration
-      unless verify_command.nil?
-        !decorated(verify_command).succeeds?
-      else
+      if verify_command.nil?
         super
+      else
+        !decorated(verify_command).succeeds?
       end
     end
   end
+
+  class Rake::CommandTask < Rake::Task
+    include CommandTaskMixin
+    setting :task_name, :run
+  end
+
+  class Rake::FileCommandTask < Rake::FileTask
+    include CommandTaskMixin
+
+    setting :target_path
+
+    def resolve_configuration
+      super
+      self.target_path ||= task_name
+    end
+  end
+
+  class CommandTask < DeprecatedTaskAPI
+    def target_class; Rake::CommandTask; end
+  end
+
+  class FileCommandTask < DeprecatedTaskAPI
+    def target_class; Rake::FileCommandTask; end
+  end
 end

data/lib/mattock/configurable.rb

@@ -10,6 +10,15 @@ module Mattock
   #
   #@example (see ClassMethods)
   module Configurable
+    class Exception < ::StandardError
+    end
+
+    class NoDefaultValue < Exception
+      def initialize(field_name, klass)
+        super("No default value for field #{field_name} on class #{klass.name}")
+      end
+    end
+
     class FieldMetadata
       attr_accessor :name, :default_value
 
@@ -132,7 +141,7 @@ module Mattock
       attr_reader :source, :field
 
       def inspect
-        "#{self.class.name.split(':').last}: #{value}"
+        "#{self.class.name.split(':').last}: #{source.class.name}.#{field.inspect}"
       end
     end
 
@@ -222,6 +231,13 @@ module Mattock
     #    ce.hoo = "hallo"
     #    ce.check_required #=> raises error because :must and :foo aren't set
     module ClassMethods
+      def inspect_instance(instance, indent="")
+        field_names.map do |name|
+          meta = field_metadata(name)
+          "#{indent}#{meta.inspect} => #{meta.immediate_value_on(instance).inspect}(#{meta.value_on(instance).inspect})"
+        end.join("\n")
+      end
+
       def default_values
         @default_values ||= []
       end
@@ -244,6 +260,13 @@ module Mattock
         end
       end
 
+      #@raises NoDefaultValue
+      def default_value_for(name)
+        field = field_metadata(name)
+        raise NoDefaultValue.new(name,self) unless field.is?(:defaulting)
+        return field.default_value
+      end
+
       #Creates an anonymous Configurable - useful in complex setups for nested
       #settings
       #@example SSH options
@@ -297,8 +320,8 @@ module Mattock
 
         if existing = default_values.find{|field| field.name == name} and existing.default_value != default_value
           source_line = caller.drop_while{|line| /#{__FILE__}/ =~ line}.first
-          warn "Changing default value of #{self.name}##{name} from #{existing.default_value.inspect} to #{default_value.inspect}"
-            "  (at: #{source_line})"
+            warn "Changing default value of #{self.name}##{name} from #{existing.default_value.inspect} to #{default_value.inspect}"
+          "  (at: #{source_line})"
         end
         default_values << metadata
         metadata
@@ -413,6 +436,64 @@ module Mattock
 
     extend ClassMethods
 
+    module DirectoryStructure
+      module ClassMethods
+        RequiredField = ::Mattock::Configurable::ClassMethods::RequiredField
+
+        attr_accessor :path_heirarchy
+        attr_accessor :path_fields
+
+        def dir(field_name, *args)
+          rel_path = RequiredField
+          if String === args.first
+            rel_path = args.shift
+          end
+          parent_field = path(field_name, rel_path)
+          self.path_heirarchy += args.map do |child_field|
+            [parent_field, child_field]
+          end
+          return parent_field
+        end
+
+        def path(field_name, rel_path=RequiredField)
+          field = setting(field_name, nested{
+            required_field :absolute_path
+            setting :relative_path, rel_path
+          })
+          path_fields << field
+          return field
+        end
+      end
+
+      def self.included(sub)
+        sub.extend ClassMethods
+        sub.path_heirarchy = []
+        sub.path_fields = []
+      end
+
+      def resolve_paths
+        missing_relatives = []
+        self.class.path_heirarchy.reverse.each do |parent_field, child_field|
+          child = child_field.value_on(self)
+          next unless child.field_unset?(:absolute_path)
+          if child.field_unset?(:relative_path)
+            missing_relatives << child_field
+            next
+          end
+          parent = parent_field.value_on(self)
+          child.absolute_path = File::join(parent.absolute_path, child.relative_path)
+        end
+        unless missing_relatives.empty?
+          raise "Required field#{missing_relatives.length == 1 ? "" : "s"} #{missing_relatives.map{|field| "#{field.name}.relative_path".inspect}.join(", ")} unset on #{self.inspect}"
+        end
+        self.class.path_fields.each do |field|
+          value = field.value_on(self)
+          next unless value.field_unset?(:relative_path)
+          value.relative_path = value.absolute_path
+        end
+      end
+    end
+
     def copy_settings
       SettingsCopier.new(self)
     end

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

@@ -1,39 +1,45 @@
 require 'mattock/command-task'
 module Mattock
-  class RemoteCommandTask < CommandTask
-    runtime_setting(:remote_server, nested(
-      :address => nil,
-      :user => nil
-    ))
-    setting(:ssh_options, [])
-    nil_fields(:id_file, :free_arguments)
-    runtime_setting(:remote_target)
+  module Rake
+    class RemoteCommandTask < CommandTask
+      runtime_setting(:remote_server, nested(
+        :address => nil,
+        :user => nil
+      ))
+      setting(:ssh_options, [])
+      nil_fields(:id_file, :free_arguments)
+      runtime_setting(:remote_target)
 
-    def resolve_runtime_configuration
-      super
-      self.remote_target ||= [remote_server.user, remote_server.address].compact.join('@') unless remote_server.address.nil?
-    end
+      def resolve_runtime_configuration
+        super
+        self.remote_target ||= [remote_server.user, remote_server.address].compact.join('@') unless remote_server.address.nil?
+      end
 
-    def ssh_option(name, value)
-      ssh_options << "\"#{name}=#{value}\""
-    end
+      def ssh_option(name, value)
+        ssh_options << "\"#{name}=#{value}\""
+      end
 
-    def decorated(command_on_remote)
-      fail "Need remote server for #{self.class.name}" unless remote_server.address
+      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 << "-i #{id_file}" if id_file
-          unless ssh_options.empty?
-            ssh_options.each do |opt|
-              cmd.options << "-o #{opt}"
+        raise "Empty remote command" if command_on_remote.nil?
+        Mattock::WrappingChain.new do |cmd|
+          cmd.add Mattock::CommandLine.new("ssh") do |cmd|
+            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_target
           end
-          cmd.options << remote_target
+          cmd.add Mattock::ShellEscaped.new(command_on_remote)
         end
-        cmd.add Mattock::ShellEscaped.new(command_on_remote)
       end
     end
   end
+
+  class RemoteCommandTask < DeprecatedTaskAPI
+    def target_class; Rake::RemoteCommandTask; end
+  end
 end

data/lib/mattock/task.rb

@@ -9,114 +9,107 @@ module Mattock
   # A configurable subclass of Rake::Task, such that you can use a
   # configuration block to change how a common task behaves, while still
   # overriding Rake API methods like Task#needed? and Task#timestamp
-
-  module TaskMixin
+  module ConfigurableTask
+    include Configurable
     include CascadingDefinition
     include DeferredDefinition
 
-    setting :task_name
-    setting :task_args
-
     module ClassMethods
       def default_taskname(name)
         setting(:task_name, name)
       end
-    end
 
-    def self.included(mod)
-      super
-      mod.class_eval do
-        extend ClassMethods
-        DeferredDefinition.add_settings(self)
+      def define_task(*args)
+        configs = args.take_while{|arg| Configurable === arg}
+        extracted_task_args = args[configs.length..-1]
+        if extracted_task_args.any?{|arg| Configurable === arg}
+          raise "Mattock::Task classes should be created with parent configs, then Rake task args"
+        end
+
+        if extracted_task_args.empty?
+          extracted_task_args = [default_value_for(:task_name)]
+        end
+
+        task = ::Rake.application.define_task(self, *extracted_task_args) do |task, args|
+          task.finalize_configuration
+          task.action(args)
+        end
+
+        unless self === task
+          raise "Task already defined for #{task.name} - attempted to redefine with #{self.name}"
+        end
+
+        task.setup_deferred
+        task.setup_cascade(*configs) do |t|
+          t.task_name = task.name
+          t.task_args = extracted_task_args
+
+          yield(t) if block_given?
+        end
       end
     end
 
-    def initialize(*args)
-      configs = args.take_while{|arg| Configurable === arg}
-      @extracted_task_args = args[configs.length..-1]
-      if @extracted_task_args.any?{|arg| Configurable === arg}
-        raise "Mattock::Task classes should be created with parent configs, then Rake task args"
-      end
-      super(*configs)
+    def self.included(sub)
+      sub.extend ClassMethods
+      Configurable.included(sub)
+      DeferredDefinition.add_settings(sub)
     end
 
+    setting :task_name
+    setting :task_args
+
+    attr_accessor :base_task
+
     def resolve_configuration
       super
-      if @extracted_task_args.empty?
-        self.task_args = [task_name]
-      else
-        self.task_args = @extracted_task_args
-      end
     end
 
-    def action
+    def action(*task_args)
     end
 
+    def inspect
+      "#{self.class.name}: #{self.task_args.inspect}\nConfiguration:\n#{self.class.inspect_instance(self, "  ")}"
+    end
+  end
 
-    module ChildTask
-      attr_accessor :source_task
-
-      def unset_defaults_guard
-        source_task.unset_defaults_guard
-      end
-
-      def inspect
-        "From: " + source_task.inspect
+  class DeprecatedTaskAPI
+    def self.deprecated(message)
+      @deprecations ||= {}
+      unless @deprecations.has_key?(message)
+        warn message
+        @deprecations[message] = :delivered
       end
     end
 
-=begin
-    # I continue to look for an alternative here.
-    # The trouble is that deep inside of define_task, Rake actually
-    # instantiates the Task - so in wanting to be able to override members of
-    # Task, it's hard to get the virtues of CascadingDefinition as well (maybe
-    # the virtues could be had without the actual mixin?)
-    #
-    # So, what we're doing is to dynamically create a child class and then
-    # carry forward the Rake::Task#initialize
-=end
-    def task_class
-      return @task_class if @task_class
-      @task_class = Class.new(self.class) do
-        define_method :initialize, Rake::Task.instance_method(:initialize)
-        include ChildTask
-      end
+    def initialize(*args, &block)
+      self.class.deprecated "#{self.class.name}.new(...) is deprecated - instead use #{target_class.name}.define_task(...)\n  (from #{caller[0]})"
+      target_class.define_task(*args, &block)
     end
+  end
 
-    def inspect
-      "#{self.class.name}: #{self.task_args.inspect}"
+  module Rake
+    class Task < ::Rake::Task
+      include ConfigurableTask
     end
 
-    attr_accessor :rake_task
-    def define
-      self.rake_task = task_class.define_task(*task_args) do
-        finalize_configuration
-        copy_settings_to(rake_task)
-        rake_task.action
-      end
-      copy_settings_to(rake_task)
-      rake_task.source_task = self
+    class FileTask < ::Rake::FileTask
+      include ConfigurableTask
     end
-  end
 
-  #I'm having misgivings about this design choice.  Rightly, this is probably a
-  #"Task Definer" that knows what class to ::define_task and then mixin a
-  #module to handle the original purpose of being able to override e.g.
-  ##needed?  There's a lot of client code that relies on this pattern now,
-  #though.
-  class Task < Rake::Task
-    include TaskMixin
-  end
+    class FileCreationTask < ::Rake::FileCreationTask
+      include ConfigurableTask
+    end
 
-  class FileTask < Rake::FileTask
-    include TaskMixin
+    class MultiTask < ::Rake::MultiTask
+      include ConfigurableTask
+    end
   end
 
-  class FileCreationTask < Rake::FileCreationTask
-    include TaskMixin
+  class Task < DeprecatedTaskAPI
+    def target_class; Rake::Task; end
   end
 
-  class MultiTask < Rake::MultiTask
-    include TaskMixin
+  class FileTask < DeprecatedTaskAPI
+    def target_class; Rake::FileTask; end
   end
 end

data/lib/mattock/tasklib.rb

@@ -37,7 +37,7 @@ module Mattock
   #
   #The configuration handling is provided by {CascadingDefinition}, and
   #configuration options are built using {Configurable}
-  class TaskLib < Rake::TaskLib
+  class TaskLib < ::Rake::TaskLib
     include CascadingDefinition
 
     attr_writer :namespace_name
@@ -50,9 +50,9 @@ module Mattock
 
     attr_reader :tasks
 
-    def initialize(*toolkits)
+    def initialize(*toolkits, &block)
       @tasks = []
-      super
+      setup_cascade(*toolkits, &block)
     end
 
     #Records tasks as they are created
@@ -62,11 +62,18 @@ module Mattock
       return a_task
     end
 
+    #Shorthand for
+    #  task name => before
+    #  task after => name
+    #Which ensures that if "after" is ever invoked,
+    #the execution will be before, name, then after
     def bracket_task(before, name, after)
       task self[name] => before
       task after => self[name]
     end
 
+    #Builds a series of tasks in a sequence - the idea is that
+    #dependant tasklibs can depend on stages of a larger process
     def task_spine(*list)
       task list.first
       list.each_cons(2) do |first, second|

data/lib/mattock/template-host.rb

@@ -4,49 +4,29 @@ require 'valise'
 module Mattock
   module ValiseManager
     def default_valise(*dirs)
-      Valise::Set.define do
-        dirs.each do |dir|
-          ro dir
-        end
-      end
+      Valise::read_only(*dirs)
     end
 
     def rel_dir(base_path = nil, up_to = nil)
-      base_path ||= /(.*):\d+/.match(caller[0])[1]
-      up_to ||= "lib"
-
-      abs_path = File::expand_path(base_path)
-      base_path = abs_path.split(File::Separator)
-      until base_path.empty?
-        unless base_path.last == up_to
-          base_path.pop
-        else
-          break
-        end
-      end
-
-      if base_path.empty?
-        raise "Relative root #{up_to.inspect} not found in #{abs_path.inspect}"
-      end
-
-      return base_path
+      Valise::Unpath.up_to(up_to, base_path)
     end
     module_function :rel_dir, :default_valise
     public :rel_dir, :default_valise
   end
 
   module TemplateHost
-    def self.template_cache
-      @template_cache ||= Tilt::Cache.new
-    end
-
     attr_accessor :valise
 
+    def templates_are_in(valise)
+      self.valise = valise.templates
+    end
+
+    #XXX Better to let clients stem or subset
     def find_template(path)
-      valise.find(["templates"] + valise.unpath(path))
+      valise.find(path)
     end
 
-    def template_contents(path)
+    def template(path)
       find_template(path).contents
     end
 
@@ -54,19 +34,13 @@ module Mattock
       find_template(path).full_path
     end
 
-    def render(path, template_options = nil)
-      template = TemplateHost::template_cache.fetch(path) do
-        Tilt.new(path, template_options || {}) do |tmpl|
-          template_contents(tmpl.file)
-        end
-      end
-
+    def render(path)
       locals = {}
       if block_given?
         yield locals
       end
 
-      template.render(self, locals)
+      template(path).render(self, locals)
     end
   end
 
@@ -74,10 +48,14 @@ module Mattock
     include TemplateHost
 
     def template_task(template_source, destination_path, template_options = nil)
+      unless template_options.nil?
+        valise.add_serialization_handler(template_source, :tilt, :template_options => template_options)
+      end
+
       file template_path(template_source)
       file destination_path => template_path(template_source) do
         File::open(destination_path, "w") do |file|
-          file.write(render(template_source, template_options))
+          file.write(render(template_source))
         end
       end
     end

data/lib/mattock/testing/rake-example-group.rb

@@ -4,20 +4,20 @@ module Mattock
   module RakeExampleGroup
     SavedEnvironmentVariables = %w{APPDATA HOME HOMEDRIVE HOMEPATH RAKE_COLUMNS RAKE_SYSTEM RAKEOPT USERPROFILE}
     DeletedEnvironmentVariables = %w{RAKE_COLUMNS RAKE_SYSTEM RAKEOPT}
-    include Rake::DSL
+    include ::Rake::DSL
     #include FileUtils
 
     class TaskManager
-      include Rake::TaskManager
+      include ::Rake::TaskManager
     end
 
     def self.included(mod)
       mod.class_eval do
         let! :rake do
-          Rake.application = Rake::Application.new
-          Rake::TaskManager.record_task_metadata = true
+          ::Rake.application = ::Rake::Application.new
+          ::Rake::TaskManager.record_task_metadata = true
           RakeFileUtils.verbose_flag = false
-          Rake.application
+          ::Rake.application
         end
 
         before :each do

data/spec/command-task.rb

@@ -9,7 +9,7 @@ describe Mattock::RemoteCommandTask do
 
   let! :remote_task do
     namespace :test do
-      Mattock::RemoteCommandTask.new do |t|
+      Mattock::Rake::RemoteCommandTask.define_task do |t|
         t.remote_server.address = "nowhere.com"
         t.command = Mattock::PrereqChain.new do |prereq|
           prereq.add Mattock::CommandLine.new("cd", "a_dir")
@@ -42,7 +42,7 @@ describe Mattock::BundleCommandTask do
   include Mattock::CommandLineExampleGroup
 
   let! :bundle_task do
-    Mattock::BundleCommandTask.new(:bundle_test) do |t|
+    Mattock::BundleCommandTask.define_task(:bundle_test) do |t|
       t.command = cmd("bundle", "install", "--standalone")
     end
   end

data/spec/configurable.rb

@@ -51,6 +51,113 @@ describe Mattock::Configurable do
     end.to_not raise_error
   end
 
+  describe "with DirectoryStructure" do
+    class DirectoryThing
+      include Mattock::Configurable
+      include DirectoryStructure
+
+      dir(:ephemeral_mountpoint,
+          dir(:bundle_workdir, "bundle_workdir",
+              path(:bundle_manifest),
+              path(:credentials_archive, "aws-creds.tar.gz"),
+              dir(:credentials_dir, "aws-creds",
+                  path(:private_key_file, "pk.pem"),
+                  path(:certificate_file, "cert.pem")
+                 )
+             )
+         )
+    end
+
+    def subject
+      DirectoryThing.new.tap do |thing|
+        thing.setup_defaults
+      end
+    end
+
+    it "should complain about missing fields" do
+      expect do
+        subject.check_required
+      end.to raise_error /Required field/
+    end
+
+    describe "with root path configured, but missing a relative path" do
+      def subject
+        DirectoryThing.new.tap do |thing|
+          thing.setup_defaults
+          thing.ephemeral_mountpoint.absolute_path = "/tmp"
+          thing.resolve_paths
+        end
+      end
+
+      it "should complain about missing fields" do
+        expect do
+          subject.check_required
+        end.to raise_error /Required field/
+      end
+    end
+
+    describe "with required paths configured" do
+      def subject
+        DirectoryThing.new.tap do |thing|
+          thing.setup_defaults
+          thing.ephemeral_mountpoint.absolute_path = "/tmp"
+          thing.bundle_manifest.relative_path = "image.manifest.xml"
+          thing.resolve_paths
+        end
+      end
+
+      it "should not complain about required fields" do
+        expect do
+          subject.check_required
+        end.not_to raise_error
+      end
+
+      its("certificate_file.absolute_path"){ should == "/tmp/bundle_workdir/aws-creds/cert.pem" }
+      its("bundle_manifest.absolute_path"){ should == "/tmp/bundle_workdir/image.manifest.xml" }
+      its("credentials_dir.absolute_path"){ should == "/tmp/bundle_workdir/aws-creds" }
+    end
+  end
+
+  describe "multiple instances" do
+    class MultiSource
+      include Mattock::Configurable
+
+      setting :one, 1
+      setting :nest, nested{
+        setting :two, 2
+      }
+    end
+
+    let :first do
+      MultiSource.new.setup_defaults
+    end
+
+    let :second do
+      MultiSource.new.setup_defaults
+    end
+
+    before :each do
+      first.one = "one"
+      first.nest.two = "two"
+      second
+    end
+
+    it "should not have any validation errors" do
+      expect do
+        first.check_required
+        second.check_required
+      end.not_to raise_error
+    end
+
+    it "should accurately reflect settings" do
+      first.one.should == "one"
+      second.one.should == 1
+
+      first.nest.two.should == "two"
+      second.nest.two.should == 2
+    end
+  end
+
   describe "copying settings" do
     class LeftStruct
       include Mattock::Configurable

data/spec/template-host.rb

@@ -9,9 +9,7 @@ describe Mattock::TemplateHost do
   end
 
   it "should be able to do easy templating" do
-    template_host.valise = Mattock::ValiseManager.default_valise("spec_help")
+    template_host.templates_are_in(Mattock::ValiseManager.default_valise("spec_help"))
     template_host.render("test.erb").should == "Templated: A test value\n"
-
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mattock
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-25 00:00:00.000000000 Z
+date: 2013-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corundum
-  requirement: &84793580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,24 +21,37 @@ dependencies:
         version: 0.0.1
   type: :development
   prerelease: false
-  version_requirements: *84793580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: valise
-  requirement: &84792520 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.9'
         segments:
         - 0
-        - 6
+        - 9
   type: :runtime
   prerelease: false
-  version_requirements: *84792520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+        segments:
+        - 0
+        - 9
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &84791720 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>'
@@ -48,7 +61,14 @@ dependencies:
         - 0
   type: :runtime
   prerelease: false
-  version_requirements: *84791720
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
 description: ! "  If Rake won't do it by itself, you oughtta Mattock.\n\n  If you
   survived the pun, you might enjoy this gem.\n\n  Features:\n\n  * Extensions to
   Tasklibs to support powerful deerpaths.\n  * A commandline library that supports
@@ -102,7 +122,7 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- mattock-0.3.4 RDoc
+- mattock-0.4.0 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -113,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1040167503
+      hash: 725889327
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: mattock
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A powerful companion to Rake