mattock 0.2.13 → 0.3.0

data/lib/mattock/cascading-definition.rb

@@ -24,6 +24,7 @@ module Mattock
     include Configurable
 
     def initialize(*tasklibs)
+      @runtime = false
       setup_defaults
       default_configuration(*tasklibs)
 
@@ -35,6 +36,7 @@ module Mattock
       define
     end
 
+
     #@param [TaskLib] tasklibs Other libs upon which this one depends to set
     #  its defaults
     #Sets default values for library settings
@@ -60,9 +62,42 @@ module Mattock
       check_required
     end
 
+
     #Any useful TaskLib will override this to define tasks, essentially like a
     #templated Rakefile snippet.
     def define
     end
   end
+
+  module DeferredDefinition
+    def self.add_settings(mod)
+      mod.setting(:configuration_block, proc{})
+    end
+
+    def initialize(*args, &block)
+      @runtime = false
+      @finalized = false
+      super
+    end
+
+    def runtime_definition(&block)
+      self.configuration_block = block
+    end
+
+    def runtime?
+      !!@runtime
+    end
+
+    def resolve_runtime_configuration
+    end
+
+    def finalize_configuration
+      return if @finalized
+      @runtime = true
+      configuration_block[self]
+      resolve_runtime_configuration
+      confirm_configuration
+      @finalized = true
+    end
+  end
 end

data/lib/mattock/command-line.rb

@@ -32,12 +32,32 @@ module Mattock
       when 0
         return exit_code
       else
-        fail "Command #{@command.inspect} failed with exit status #{$?.exitstatus}: \n#{streams.inspect}"
+        fail "Command #{@command.inspect} failed with exit status #{exit_code}: \n#{streams.inspect}"
       end
     end
   end
 
   class CommandLine
+    def self.define_chain_op(opname, klass)
+      define_method(opname) do |other|
+        unless CommandLine === other
+          other = CommandLine.new(*[*other])
+        end
+        chain = nil
+        if klass === self
+          chain = self
+        else
+          chain = klass.new
+          chain.add(self)
+        end
+        chain.add(other)
+      end
+    end
+
+    def self.define_op(opname)
+      CommandLine.define_chain_op(opname, self)
+    end
+
     def initialize(executable, *options)
       @executable = executable
       @options = options
@@ -56,7 +76,11 @@ module Mattock
     end
 
     def command
-      ([executable] + options + @redirections).join(" ")
+      ([executable] + options_composition + @redirections).join(" ")
+    end
+
+    def options_composition
+      options
     end
 
     def redirect_to(stream, path)
@@ -110,6 +134,12 @@ module Mattock
     end
   end
 
+  module CommandLineDSL
+    def cmd(*args)
+      CommandLine.new(*args)
+    end
+  end
+
   class ShellEscaped < CommandLine
     def initialize(cmd)
       @escaped = cmd
@@ -135,6 +165,7 @@ module Mattock
     def add(cmd)
       yield cmd if block_given?
       @commands << cmd
+      self
     end
 
     def name
@@ -143,18 +174,24 @@ module Mattock
   end
 
   class WrappingChain < CommandChain
+    define_op('-')
+
     def command
       @commands.map{|cmd| cmd.command}.join(" -- ")
     end
   end
 
   class PrereqChain < CommandChain
+    define_op('&')
+
     def command
       @commands.map{|cmd| cmd.command}.join(" && ")
     end
   end
 
   class PipelineChain < CommandChain
+    define_op('|')
+
     def command
       @commands.map{|cmd| cmd.command}.join(" | ")
     end

data/lib/mattock/command-task.rb

@@ -3,9 +3,12 @@ require 'mattock/command-line'
 
 module Mattock
   class CommandTask < Task
+    include CommandLineDSL
+    extend CommandLineDSL
+
     setting(:task_name, :run)
-    setting(:command)
-    setting(:verify_command, nil)
+    runtime_setting(:verify_command, nil)
+    runtime_setting(:command)
 
     def verify_command
       if @verify_command.respond_to?(:call)
@@ -14,8 +17,8 @@ module Mattock
       @verify_command
     end
 
-    def decorated(cmd)
-      cmd
+    def decorated(command)
+      command
     end
 
     def action
@@ -23,6 +26,7 @@ module Mattock
     end
 
     def needed?
+      finalize_configuration
       unless verify_command.nil?
         !decorated(verify_command).succeeds?
       else

data/lib/mattock/configurable.rb

@@ -10,17 +10,194 @@ module Mattock
   #
   #@example (see ClassMethods)
   module Configurable
-    RequiredField = Object.new
-    class << RequiredField
-      def to_s
-        "<unset>"
+    class FieldMetadata
+      attr_accessor :name, :default_value
+
+      DEFAULT_PROPERTIES = {
+        :copiable => true,
+        :proxiable => true,
+        :required => false,
+        :runtime => false,
+        :defaulting => true,
+      }
+      def initialize(name, value)
+        @name = name
+        @default_value = value
+        @properties = DEFAULT_PROPERTIES.clone
+      end
+
+      def inspect
+        set_props = DEFAULT_PROPERTIES.keys.find_all do |prop|
+          @properties[prop]
+        end
+        "Field: #{name}: #{default_value.inspect} #{set_props.inspect}"
+      end
+
+      def validate_property_name(name)
+        unless DEFAULT_PROPERTIES.has_key?(name)
+          raise "Invalid field property #{name.inspect} - valid are: #{DEFAULT_PROPERTIES.keys.inspect}"
+        end
+      end
+
+      def is?(property)
+        validate_property_name(property)
+        @properties[property]
+      end
+
+      def is_not?(property)
+        validate_property_name(property)
+        !@properties[property]
+      end
+      alias isnt? is_not?
+
+      def is(property)
+        validate_property_name(property)
+        @properties[property] = true
+        self
+      end
+
+      def is_not(property)
+        validate_property_name(property)
+        @properties[property] = false
+        self
+      end
+      alias isnt is_not
+
+      def ivar_name
+        "@#{name}"
+      end
+
+      def writer_method
+        "#{name}="
+      end
+
+      def reader_method
+        name
       end
 
+      def immediate_value_on(instance)
+        instance.instance_variable_get(ivar_name)
+      end
+
+      def value_on(instance)
+        value = immediate_value_on(instance)
+        if ProxyValue === value
+          value.field.value_on(value.source)
+        else
+          value
+        end
+      end
+
+      def set_on?(instance)
+        return false unless instance.instance_variable_defined?(ivar_name)
+        value = immediate_value_on(instance)
+        if name == :destination_path
+        end
+        if ProxyValue === value
+          value.field.set_on?(value.source)
+        else
+          true
+        end
+      end
+
+      def unset_on?(instance)
+        !set_on?(instance)
+      end
+
+      def missing_on?(instance)
+        return false unless is?(:required)
+        if instance.respond_to?(:runtime?) and !instance.runtime?
+          return runtime_missing_on?(instance)
+        else
+          return !set_on?(instance)
+        end
+      end
+
+      def runtime_missing_on?(instance)
+        return false if is?(:runtime)
+        return true unless instance.instance_variable_defined?(ivar_name)
+        value = immediate_value_on(instance)
+        if ProxyValue === value
+          value.field.runtime_missing_on?(value.source)
+        else
+          false
+        end
+      end
+    end
+
+    class ProxyValue
+      def initialize(source, field)
+        @source, @field = source, field
+      end
+      attr_reader :source, :field
+
       def inspect
-        to_s
+        "#{self.class.name.split(':').last}: #{value}"
+      end
+    end
+
+    class ProxyDecorator
+      def initialize(configurable)
+        @configurable = configurable
+      end
+
+      def method_missing(name, *args, &block)
+        super unless block.nil? and args.empty?
+        super unless @configurable.respond_to?(name)
+        return ProxyValue.new(@configurable, @configurable.class.field_metadata(name))
+      end
+    end
+
+    class FieldProcessor
+      def initialize(source)
+        @source = source
+        @field_names = filter(source.class.field_names)
+      end
+      attr_accessor :field_names
+      attr_reader :source
+
+      def filter_attribute
+        raise NotImplementedError
+      end
+
+      def filter(field_names)
+        field_names.find_all do |name|
+          source.class.field_metadata(name).is?(filter_attribute)
+        end
+      end
+
+      def value(field)
+        source.__send__(field.reader_method)
+      end
+
+      def to(target)
+        field_names.each do |name|
+          field = source.class.field_metadata(name)
+          next unless target.respond_to?(field.writer_method)
+          target.__send__(field.writer_method, value(field))
+        end
+      end
+    end
+
+    class SettingsCopier < FieldProcessor
+      def filter_attribute
+        :copiable
+      end
+
+      def value(field)
+        field.immediate_value_on(source)
+      end
+    end
+
+    class SettingsProxier < FieldProcessor
+      def filter_attribute
+        :proxiable
+      end
+
+      def value(field)
+        ProxyValue.new(source, field)
       end
     end
-    RequiredField.freeze
 
     #Describes class level DSL & machinery for working with configuration
     #managment.
@@ -46,76 +223,38 @@ module Mattock
     #    ce.check_required #=> raises error because :must and :foo aren't set
     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
+        @default_values ||= []
       end
 
-      def missing_required_fields_on(instance)
-        missing = []
+      def field_names
+        names = default_values.map{|field| field.name}
         if Configurable > superclass
-          missing = superclass.missing_required_fields_on(instance)
+          names | superclass.field_names
+        else
+          names
         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 copy_settings(from, to)
-        if Configurable > superclass
-          superclass.copy_settings(from, to)
+      def field_metadata(name)
+        field = default_values.find{|field| field.name == name}
+        if field.nil? and Configurable > superclass
+          superclass.field_metadata(name)
+        else
+          field
         end
-        default_values.keys.each do |field|
-          begin
-            to.__send__("#{field}=", from.__send__(field))
-          rescue NoMethodError
-            #shrug it off
-          end
-        end
-      end
-
-      def to_hash(obj)
-        hash = if Configurable > superclass
-                 superclass.to_hash(obj)
-               else
-                 {}
-               end
-        hash.merge( Hash[default_values.keys.zip(default_values.keys.map{|key|
-          begin
-            obj.__send__(key)
-          rescue NoMethodError
-          end
-        }).to_a])
       end
 
       #Creates an anonymous Configurable - useful in complex setups for nested
       #settings
       #@example SSH options
       #  setting :ssh => nested(:username => "me", :password => nil)
-      def nested(hash=nil)
-        obj = Class.new(Struct).new
-        obj.settings(hash || {})
-        return obj
+      def nested(hash=nil, &block)
+        nested = Class.new(Struct)
+        nested.settings(hash || {})
+        if block_given?
+          nested.instance_eval(&block)
+        end
+        return nested
       end
 
       #Quick list of setting fields with a default value of nil.  Useful
@@ -124,6 +263,7 @@ module Mattock
         names.each do |name|
           setting(name, nil)
         end
+        self
       end
       alias nil_field nil_fields
 
@@ -133,18 +273,47 @@ module Mattock
         names.each do |name|
           setting(name)
         end
+        self
       end
       alias required_field required_fields
 
+      RequiredField = Object.new.freeze
+
       #Defines a setting on this class - much like a attr_accessible call, but
       #allows for defaults and required settings
       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}"
+        metadata =
+          if default_value == RequiredField
+            FieldMetadata.new(name, nil).is(:required).isnt(:defaulting)
+          else
+            FieldMetadata.new(name, default_value)
+          end
+
+        attr_writer(name)
+        define_method(metadata.reader_method) do
+          value = metadata.value_on(self)
+        end
+
+        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})"
         end
-        default_values[name] = default_value
+        default_values << metadata
+        metadata
+      end
+
+      def runtime_required_fields(*names)
+        names.each do |name|
+          runtime_setting(name)
+        end
+        self
+      end
+      alias runtime_required_field runtime_required_fields
+
+      def runtime_setting(name, default_value = RequiredField)
+        setting(name, default_value).is(:runtime)
       end
 
       #@param [Hash] hash Pairs of name/value to be converted into
@@ -155,6 +324,87 @@ module Mattock
         end
         return self
       end
+      alias runtime_settings settings
+
+      def set_defaults_on(instance)
+        if Configurable > superclass
+          superclass.set_defaults_on(instance)
+        end
+        default_values.each do |field|
+          next unless field.is? :defaulting
+          value = field.default_value
+          if Module === value and Configurable > value
+            value = value.new
+            value.class.set_defaults_on(value)
+          end
+          instance.__send__(field.writer_method, value)
+        end
+      end
+
+      def missing_required_fields_on(instance)
+        missing = []
+        if Configurable > superclass
+          missing = superclass.missing_required_fields_on(instance)
+        end
+        default_values.each do |field|
+          if field.missing_on?(instance)
+            missing << field.name
+          else
+            set_value = instance.__send__(field.reader_method)
+            if Configurable === set_value
+              missing += set_value.class.missing_required_fields_on(set_value).map do |field|
+                [name, field].join(".")
+              end
+            end
+          end
+        end
+        return missing
+      end
+
+      def copy_settings(from, to, &block)
+        if Configurable > superclass
+          superclass.copy_settings(from, to, &block)
+        end
+        default_values.each do |field|
+          begin
+            value =
+              if block_given?
+                yield(from, field)
+              else
+                from.__send__(field.reader_method)
+              end
+            if Configurable === value
+              value = value.clone
+            end
+            to.__send__(field.writer_method, value)
+          rescue NoMethodError
+            #shrug it off
+          end
+        end
+      end
+
+      def to_hash(obj)
+        hash = if Configurable > superclass
+                 superclass.to_hash(obj)
+               else
+                 {}
+               end
+        hash.merge( Hash[default_values.map{|field|
+          begin
+            value = obj.__send__(field.reader_method)
+            value =
+              case value
+              when Configurable
+                value.to_hash
+              else
+                value
+              end
+            [field.name, value]
+          rescue NoMethodError
+          end
+        }])
+      end
+
 
       def included(mod)
         mod.extend ClassMethods
@@ -163,18 +413,37 @@ module Mattock
 
     extend ClassMethods
 
+    def copy_settings
+      SettingsCopier.new(self)
+    end
+
     def copy_settings_to(other)
-      self.class.copy_settings(self, other)
+      copy_settings.to(other)
       self
     end
 
+    def proxy_settings
+      SettingsProxier.new(self)
+    end
+
+    def proxy_settings_to(other)
+      proxy_settings.to(other)
+    end
+
     def to_hash
       self.class.to_hash(self)
     end
 
+    def unset_defaults_guard
+      raise "Tried to check required settings before running setup_defaults"
+    end
+
     #Call during initialize to set default values on settings - if you're using
     #Configurable outside of Mattock, be sure this gets called.
     def setup_defaults
+      def self.unset_defaults_guard
+      end
+
       self.class.set_defaults_on(self)
       self
     end
@@ -182,6 +451,7 @@ module Mattock
     #Checks that all required fields have be set, otherwise raises an error
     #@raise RuntimeError if any required fields are unset
     def check_required
+      unset_defaults_guard
       missing = self.class.missing_required_fields_on(self)
       unless missing.empty?
         raise "Required field#{missing.length > 1 ? "s" : ""} #{missing.map{|field| field.to_s.inspect}.join(", ")} unset on #{self.inspect}"
@@ -189,33 +459,25 @@ module Mattock
       self
     end
 
-    def unset?(value)
-      value == RequiredField
-    end
-
-    def setting(name, default_value = nil)
-      self.class.setting(name, default_value)
-      instance_variable_set("@#{name}", default_value)
+    def proxy_value
+      ProxyDecorator.new(self)
     end
 
-    def settings(hash)
-      hash.each_pair do |name, value|
-        setting(name, value)
-      end
-      return self
+    #XXX deprecate
+    def unset?(value)
+      value.nil?
     end
 
-    def required_fields(*names)
-      self.class.required_fields(*names)
-      self
+    def field_unset?(name)
+      self.class.field_metadata(name).unset_on?(self)
     end
-    alias required_field required_fields
 
-    def nil_fields(*names)
-      self.class.nil_fields(*names)
-      self
+    def fail_unless_set(name)
+      if self.class.field_metadata(name).unset_on?(self)
+        raise "Assertion failed: Field #{name} unset"
+      end
+      true
     end
-    alias nil_field nil_fields
 
     class Struct
       include Configurable

data/lib/mattock/configuration-store.rb

@@ -50,12 +50,18 @@ module Mattock
     def initialize(app_name, library_default_dir = nil)
       @app_name = app_name
       @valise = Valise::Set.define do
-        rw "~/.#{@app_name}"
+        rw "~/.#{app_name}"
+        rw "~/.mattock/#{app_name}"
         rw "~/.mattock"
-        rw "/usr/share/#{@app_name}"
+
+        rw "/usr/share/#{app_name}"
+        rw "/usr/share/mattock/#{app_name}"
         rw "/usr/share/mattock"
-        rw "/etc/#{@app_name}"
+
+        rw "/etc/#{app_name}"
+        rw "/etc/mattock/#{app_name}"
         rw "/etc/mattock"
+
         ro library_default_dir unless library_default_dir.nil?
         ro from_here("default_configuration")
 
@@ -67,6 +73,12 @@ module Mattock
 
     attr_reader :loaded, :valise
 
+    #Add special file handling for a particular file
+    def register_file(name, type, merge)
+      @valise.add_handler(name, type, merge)
+    end
+
+    #Add a search path to look for configuration files
     def register_search_path(from_file)
       directory = File::expand_path("../.#{@app_name}", from_file)
       @valise.prepend_search_root(Valise::SearchRoot.new(directory))

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

@@ -1,12 +1,21 @@
 require 'mattock/command-task'
 module Mattock
   class RemoteCommandTask < CommandTask
-    setting(:remote_server, nested(
-      :address => "localhost",
+    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
+      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 decorated(command_on_remote)
       fail "Need remote server for #{self.class.name}" unless remote_server.address
@@ -14,14 +23,13 @@ module Mattock
       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}"
+              cmd.options << "-o #{opt}"
             end
           end
-          cmd.options << remote_server.address
+          cmd.options << remote_target
         end
         cmd.add Mattock::ShellEscaped.new(command_on_remote)
       end

data/lib/mattock/task.rb

@@ -9,6 +9,7 @@ module Mattock
 
   module TaskMixin
     include CascadingDefinition
+    include DeferredDefinition
 
     setting :task_name
     setting :task_args
@@ -20,8 +21,11 @@ module Mattock
     end
 
     def self.included(mod)
-      mod.class_eval{ extend ClassMethods }
       super
+      mod.class_eval do
+        extend ClassMethods
+        DeferredDefinition.add_settings(self)
+      end
     end
 
     def initialize(*args)
@@ -44,17 +48,34 @@ module Mattock
     def action
     end
 
+
+    module ChildTask
+      attr_accessor :source_task
+
+      def unset_defaults_guard
+        source_task.unset_defaults_guard
+      end
+
+      def inspect
+        "From: " + source_task.inspect
+      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
     end
 
@@ -64,8 +85,10 @@ module Mattock
 
     def define
       task = task_class.define_task(*task_args) do
+        finalize_configuration
         task.action
       end
+      task.source_task = self
       copy_settings_to(task)
     end
   end

data/lib/mattock/tasklib.rb

@@ -43,9 +43,9 @@ module Mattock
     attr_writer :namespace_name
 
     #The namespace this lib's tasks will created within.  Changeable at
-    #instatiation
+    #instantiation
     def self.default_namespace(name)
-      setting(:namespace_name, name)
+      setting(:namespace_name, name).isnt(:copiable)
     end
 
     attr_reader :tasks
@@ -62,6 +62,18 @@ module Mattock
       return a_task
     end
 
+    def bracket_task(before, name, after)
+      task self[name] => before
+      task after => self[name]
+    end
+
+    def task_spine(*list)
+      task list.first
+      list.each_cons(2) do |first, second|
+        task second => first
+      end
+    end
+
     #@overload in_namespace(args)
     #  maps the arguments to namespace-prefixed names, for use in Rake
     #  dependency declaration

data/lib/mattock/template-host.rb

@@ -26,12 +26,13 @@ module Mattock
       end
 
       if base_path.empty?
-        raise "Relative root #{up_to} not found in #{abs_path}"
+        raise "Relative root #{up_to.inspect} not found in #{abs_path.inspect}"
       end
 
       return base_path
     end
     module_function :rel_dir, :default_valise
+    public :rel_dir, :default_valise
   end
 
   module TemplateHost
@@ -60,7 +61,12 @@ module Mattock
         end
       end
 
-      template.render(self)
+      locals = {}
+      if block_given?
+        yield locals
+      end
+
+      template.render(self, locals)
     end
   end
 

data/lib/mattock/yard_extensions.rb

@@ -68,18 +68,21 @@ module Mattock
         "#{prefix[0]}.#{name}"
       end
 
+      def setting_method_name
+        "setting"
+      end
+
       def synthetic_setting(name, value=nil)
         args = s( s(:string_literal, s(:string_content, s(:tstring_content, name))))
         args << value unless value.nil?
         args << false
-        new_call = s(:fcall, s(:ident, "setting"), s(:arg_paren, args))
+        new_call = s(:fcall, s(:ident, setting_method_name), s(:arg_paren, args))
         new_call.line_range = (1..1)
         new_call.traverse do |node|
           node.full_source ||= ""
         end
-        new_call.full_source = "setting('#{name}'#{value.nil? ? "" : ", #{value.source}"})"
+        new_call.full_source = "#{setting_method_name}('#{name}'#{value.nil? ? "" : ", #{value.source}"})"
         new_call
-
       end
 
       def process
@@ -152,6 +155,24 @@ module Mattock
       end
     end
 
+    class RuntimeRequiredFieldsHandler < SettingHandler
+      handles method_call(:runtime_required_field)
+      handles method_call(:runtime_required_fields)
+      namespace_only
+
+      def setting_method_name
+        "runtime_setting"
+      end
+
+      def process
+        return unless mattock_configurable?(namespace)
+        remapped = statement.parameters(false).map do |name|
+          synthetic_setting(extract_name(name))
+        end
+        parser.process(remapped)
+      end
+    end
+
     class RequiredFieldsHandler < SettingHandler
       handles method_call(:required_field)
       handles method_call(:required_fields)

data/spec/command-line.rb

@@ -46,6 +46,52 @@ describe Mattock::CommandLine do
   end
 end
 
+describe Mattock::CommandLineDSL do
+  include described_class
+
+  describe "using the - operator" do
+    let :command do
+      cmd("sudo") - ["gem", "install", "bundler"]
+    end
+
+    it "should define commands" do
+      command.should be_an_instance_of(Mattock::WrappingChain)
+      command.should have(2).commands
+      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
+      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
+      command.command.should == "sudo -- gem install bundler"
+    end
+  end
+
+  describe "using the | operator" do
+    let :command do
+      cmd("cat", "/etc/passwd") | ["grep", "root"]
+    end
+
+    it "should define commands" do
+      command.should be_an_instance_of(Mattock::PipelineChain)
+      command.should have(2).commands
+      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
+      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
+      command.command.should == "cat /etc/passwd | grep root"
+    end
+  end
+
+  describe "using the && operator" do
+    let :command do
+      cmd("cd", "/tmp/trash") & %w{rm -rf *}
+    end
+
+    it "should define commands" do
+      command.should be_an_instance_of(Mattock::PrereqChain)
+      command.should have(2).commands
+      command.commands[0].should be_an_instance_of(Mattock::CommandLine)
+      command.commands[1].should be_an_instance_of(Mattock::CommandLine)
+      command.command.should == "cd /tmp/trash && rm -rf *"
+    end
+  end
+end
+
 describe Mattock::CommandLine, "that fails" do
   let :commandline do
     Mattock::CommandLine.new("false")

data/spec/configurable.rb

@@ -1,3 +1,5 @@
+require 'mattock'
+
 describe Mattock::Configurable do
   class TestSuperStruct
     include Mattock::Configurable
@@ -7,7 +9,7 @@ describe Mattock::Configurable do
   end
 
   class TestStruct < TestSuperStruct
-    settings(:one => 1, :two => nested(:a => "a").required_field(:b))
+    settings(:one => 1, :two => nested(:a => "a"){ required_field(:b)} )
     nil_field(:five)
   end
 
@@ -22,8 +24,15 @@ describe Mattock::Configurable do
     subject.five.should be_nil
   end
 
+  it "#to_hash" do
+    hash = subject.to_hash
+    hash[:one].should == 1
+    hash[:two][:a].should == "a"
+  end
+
   it "should complain about unset required fields" do
     expect do
+      p subject
       subject.check_required
     end.to raise_error
   end
@@ -42,4 +51,50 @@ describe Mattock::Configurable do
       subject.check_required
     end.to_not raise_error
   end
+
+  describe "copying settings" do
+    class LeftStruct
+      include Mattock::Configurable
+
+      setting(:normal, 1)
+      setting(:no_copy, 2).isnt(:copiable)
+      setting(:no_proxy, 3).isnt(:proxiable)
+      setting(:no_nothing, 4).isnt(:copiable).isnt(:proxiable)
+      setting(:not_on_target, 5)
+    end
+
+    class RightStruct
+      include Mattock::Configurable
+
+      required_fields(:normal, :no_copy, :no_proxy, :no_nothing)
+    end
+
+    let :left do
+      LeftStruct.new.setup_defaults
+    end
+
+    let :right do
+      RightStruct.new.setup_defaults
+    end
+
+    it "should not copy no_copy" do
+      left.copy_settings.to(right)
+      right.unset?(right.normal).should be_false
+      right.normal.should == 1
+      right.unset?(right.no_copy).should be_true
+      right.unset?(right.no_proxy).should be_false
+      right.no_proxy.should == 3
+      right.unset?(right.no_nothing).should be_true
+    end
+
+    it "should not proxy no_proxy" do
+      left.proxy_settings.to(right)
+      right.unset?(right.normal).should be_false
+      right.normal.should == 1
+      right.unset?(right.no_copy).should be_false
+      right.no_copy.should == 2
+      right.unset?(right.no_proxy).should be_true
+      right.unset?(right.no_nothing).should be_true
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mattock
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-12 00:00:00.000000000 Z
+date: 2012-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corundum
-  requirement: &76587950 !ruby/object:Gem::Requirement
+  requirement: &82047460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,21 +21,24 @@ dependencies:
         version: 0.0.1
   type: :development
   prerelease: false
-  version_requirements: *76587950
+  version_requirements: *82047460
 - !ruby/object:Gem::Dependency
   name: valise
-  requirement: &76587340 !ruby/object:Gem::Requirement
+  requirement: &82046930 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0.6'
+        segments:
+        - 0
+        - 6
   type: :runtime
   prerelease: false
-  version_requirements: *76587340
+  version_requirements: *82046930
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &76587100 !ruby/object:Gem::Requirement
+  requirement: &82046620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>'
@@ -45,7 +48,7 @@ dependencies:
         - 0
   type: :runtime
   prerelease: false
-  version_requirements: *76587100
+  version_requirements: *82046620
 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
@@ -98,7 +101,7 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- mattock-0.2.13 RDoc
+- mattock-0.3.0 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -109,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 332286803
+      hash: 900034003
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: