mattock 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 058ff110aa5e5ffd99da0527d769e565d2219fd1
-  data.tar.gz: 56845e99beb502e10826cd0baa17385ec49a66db
+  metadata.gz: 70b769461d13694dbd33d6aca28506eb472e8ae5
+  data.tar.gz: 27701d143e0ddd82f0edd468a2b7d8e82ef6a3e0
 SHA512:
-  metadata.gz: 8c9ae840327f2fdf631b8505221b416fba46e2d635c928cfa9875225bb41ac0ace63261ad71c30891cc8f4a411a5466331da3ca325fdc107a8e3574b41392419
-  data.tar.gz: f31d1b3427076cf6fd81ec8dc4d7361bd4e4e7e949e2e0dd0b4810c6964a50654f19ffe65fa7cdcfc03ac9021aca8b58e396b594e4519a619bab9755dc055f13
+  metadata.gz: c900dab527d13a9debdb1b7675476da4cca839c59fa2883831f968a3871b307a2114d139e1cb632d47fe50a91241bd869da57c70b55e2fbbdf8760b9ad5539a4
+  data.tar.gz: 8f0b1dfb07599a17df00ba078c591569164c023c721a9e367ade70ed76515577881206ad7e8d3980693415b2d811865f591cc7ed5bab3bbf236b6ea187c8a408

data/lib/mattock/cascading-definition.rb

@@ -1,4 +1,4 @@
-require 'mattock/configurable'
+require 'calibrate/configurable'
 
 module Mattock
   #Collects shared configuration management behavior for TaskLibs and Tasks
@@ -23,7 +23,7 @@ module Mattock
   #
   #For an overview see {TaskLib}
   module CascadingDefinition
-    include Configurable
+    include Calibrate::Configurable
 
     def setup_cascade(*other_definitions)
       @runtime = false

data/lib/mattock/task.rb

@@ -1,4 +1,5 @@
 require 'mattock/cascading-definition'
+require 'calibrate'
 require 'singleton' #Rake fails to require this properly
 require 'rake/task'
 require 'rake/file_task'
@@ -10,10 +11,10 @@ module Mattock
   # configuration block to change how a common task behaves, while still
   # overriding Rake API methods like Task#needed? and Task#timestamp
   module ConfigurableTask
-    include Configurable
+    include Calibrate::Configurable
     include CascadingDefinition
     include DeferredDefinition
-    include Configurable::DirectoryStructure
+    include Calibrate::Configurable::DirectoryStructure
 
     module ClassMethods
       def default_taskname(name)
@@ -21,9 +22,9 @@ module Mattock
       end
 
       def define_task(*args)
-        configs = args.take_while{|arg| Configurable === arg}
+        configs = args.take_while{|arg| Calibrate::Configurable === arg}
         extracted_task_args = args[configs.length..-1]
-        if extracted_task_args.any?{|arg| Configurable === arg}
+        if extracted_task_args.any?{|arg| Calibrate::Configurable === arg}
           raise "Mattock::Task classes should be created with parent configs, then Rake task args"
         end
 
@@ -56,8 +57,8 @@ module Mattock
 
     def self.included(sub)
       sub.extend ClassMethods
-      Configurable.included(sub)
-      Configurable::DirectoryStructure.included(sub)
+      Calibrate::Configurable.included(sub)
+      Calibrate::Configurable::DirectoryStructure.included(sub)
       DeferredDefinition.add_settings(sub)
       sub.setting :task_name
       sub.setting :task_args

data/lib/mattock/tasklib.rb

@@ -50,7 +50,7 @@ module Mattock
   #configuration options are built using {Configurable}
   class TaskLib < ::Rake::TaskLib
     include CascadingDefinition
-    include Configurable::DirectoryStructure
+    include Calibrate::Configurable::DirectoryStructure
 
     attr_writer :namespace_name
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mattock
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Judson Lester
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-24 00:00:00.000000000 Z
+date: 2015-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corundum
@@ -80,6 +80,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: calibrate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: |2+
     If Rake won't do it by itself, you oughtta Mattock.
 
@@ -99,43 +113,35 @@ extra_rdoc_files:
 - doc/README
 - doc/Specifications
 files:
-- yard_templates/default/module/setup.rb
-- yard_templates/default/module/html/setting_summary.erb
-- yard_templates/default/module/html/settings.erb
-- yard_templates/default/module/html/task_definition.erb
-- yard_templates/default/layout/html/setup.rb
-- yard_templates/default/layout/html/tasklib_list.erb
+- doc/README
+- doc/Specifications
+- lib/mattock.rb
+- lib/mattock/bundle-command-task.rb
+- lib/mattock/cascading-definition.rb
 - lib/mattock/command-task.rb
 - lib/mattock/command-tasklib.rb
-- lib/mattock/testing/rake-example-group.rb
-- lib/mattock/template-host.rb
-- lib/mattock/yard_extensions.rb
+- lib/mattock/configuration-store.rb
 - lib/mattock/remote-command-task.rb
-- lib/mattock/bundle-command-task.rb
-- lib/mattock/tasklib.rb
 - lib/mattock/task.rb
+- lib/mattock/tasklib.rb
+- lib/mattock/template-host.rb
 - lib/mattock/template-task.rb
-- lib/mattock/configurable.rb
-- lib/mattock/configurable/field-processor.rb
-- lib/mattock/configurable/proxy-value.rb
-- lib/mattock/configurable/instance-methods.rb
-- lib/mattock/configurable/class-methods.rb
-- lib/mattock/configurable/directory-structure.rb
-- lib/mattock/configurable/field-metadata.rb
-- lib/mattock/configuration-store.rb
-- lib/mattock/cascading-definition.rb
-- lib/mattock.rb
-- doc/README
-- doc/Specifications
+- lib/mattock/testing/rake-example-group.rb
+- lib/mattock/yard_extensions.rb
 - spec/command-task.rb
-- spec/tasklib.rb
-- spec/configurable.rb
 - spec/configuration-store.rb
-- spec/yard-extensions.rb
+- spec/tasklib.rb
 - spec/template-host.rb
-- spec_help/spec_helper.rb
+- spec/yard-extensions.rb
 - spec_help/gem_test_suite.rb
-homepage: http://nyarly.github.com/mattock/
+- spec_help/spec_helper.rb
+- yard_templates/default/layout/html/setup.rb
+- yard_templates/default/layout/html/tasklib_list.erb
+- yard_templates/default/module/html/setting_summary.erb
+- yard_templates/default/module/html/settings.erb
+- yard_templates/default/module/html/task_definition.erb
+- yard_templates/default/module/setup.rb
+homepage: https://git.lrdesign.com/judson/mattock/tree/master
 licenses:
 - MIT
 metadata: {}
@@ -145,7 +151,7 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- mattock-0.9.0 RDoc
+- mattock-0.10.0 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -160,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: mattock
-rubygems_version: 2.0.14
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 3
 summary: A powerful companion to Rake

data/lib/mattock/configurable.rb

@@ -1,29 +0,0 @@
-module Mattock
-  #Handles setting options on objects it's mixed into
-  #
-  #Settings can have default values or be required (as opposed to defaulting to
-  #nil).  Settings and their defaults are inherited (and can be overridden) by
-  #subclasses.
-  #
-  #Mattock also includes a yard-extension that will document settings of a
-  #Configurable
-  #
-  #@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
-  end
-end
-
-require 'mattock/configurable/field-metadata'
-require 'mattock/configurable/proxy-value'
-require 'mattock/configurable/field-processor'
-require 'mattock/configurable/class-methods'
-require 'mattock/configurable/instance-methods'
-require 'mattock/configurable/directory-structure'

data/lib/mattock/configurable/class-methods.rb

@@ -1,227 +0,0 @@
-module Mattock
-  module Configurable
-    RequiredField = Object.new.freeze
-
-    #Describes class level DSL & machinery for working with configuration
-    #managment.
-    #
-    #@example
-    #    class ConfExample
-    #      include Configurable
-    #
-    #      setting :foo
-    #      settings :bar => 1, :baz => 3
-    #      nil_fields :hoo, :ha, :harum
-    #      required_fields :must
-    #
-    #      def initialize
-    #        setup_defaults
-    #      end
-    #    end
-    #
-    #    ce = ConfExample.new
-    #    ce.bar #=> 1
-    #    ce.hoo #=> nil
-    #    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_on(instance, indent * 2)}"
-        end.join("\n")
-      end
-
-      def default_values
-        @default_values ||= []
-      end
-
-      def field_names
-        names = default_values.map{|field| field.name}
-        if Configurable > superclass
-          names | superclass.field_names
-        else
-          names
-        end
-      end
-
-      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
-      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
-      #  setting :ssh => nested(:username => "me", :password => nil)
-      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
-      #especially with {CascadingDefinition#resolve_configuration}
-      def nil_fields(*names)
-        names.each do |name|
-          setting(name, nil)
-        end
-        self
-      end
-      alias nil_field nil_fields
-
-      #List fields with no default for with a value must be set before
-      #definition.
-      def required_fields(*names)
-        names.each do |name|
-          setting(name)
-        end
-        self
-      end
-      alias required_field required_fields
-
-      #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
-        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
-          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 << 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
-      #  setting/default
-      def settings(hash)
-        hash.each_pair do |name, value|
-          setting(name, value)
-        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.build_default_value
-          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 |sub_field|
-                [field.name, sub_field].join(".")
-              end
-            end
-          end
-        end
-        return missing
-      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 from_hash(obj, hash) #XXX It'd be really nice if this could report unused fields
-        if Configurable > superclass
-          superclass.from_hash(obj, hash)
-        end
-        default_values.each do |field|
-          catch :next do
-            key = field.reader_method.to_s
-            value = hash.fetch(key.to_s) do
-              key = key.to_sym
-              hash.fetch(key) do
-                throw :next
-              end
-            end
-
-            existing_value = obj.__send__(field.reader_method)
-            if Configurable === existing_value and value.is_a? Hash
-              existing_value.from_hash(value)
-            else
-              obj.__send__(field.writer_method, value)
-            end
-          end
-        end
-      end
-
-      def included(mod)
-        mod.extend ClassMethods
-      end
-    end
-
-    extend ClassMethods
-  end
-end

data/lib/mattock/configurable/directory-structure.rb

@@ -1,163 +0,0 @@
-require 'rake'
-
-module Mattock
-  module Configurable
-    class MissingRelativePaths < Exception; end
-
-    #XXX Consider making the actual dir/path settings r/o
-    #Very easy to say
-    #  filename = "string"
-    #rather than
-    #  filename.relative_path = "string"
-    #and it isn't clear which (abs/rel) you mean
-    #
-    module DirectoryStructure
-      class StructurePath
-        include Configurable
-
-        setting :absolute_path
-        setting :relative_path
-
-        alias abspath absolute_path
-        alias relpath relative_path
-
-        #No #path - ambiguous whether that would be abspath or pathname
-
-        def initialize(rel_path)
-          self.relative_path = rel_path unless rel_path == Configurable::RequiredField
-        end
-
-        def pathname
-          @pathname ||=
-            begin
-              fail_unless_set(:absolute_path)
-              require 'pathname'
-              Pathname.new(absolute_path)
-            end
-        end
-        alias path_name pathname
-
-        def to_s
-          fail_unless_set(:absolute_path)
-          absolute_path
-        end
-
-        def inspect
-          "<path: #{
-            if field_unset?(:absolute_path)
-              if field_unset?(:relative_path)
-                "<<?>>"
-              else
-                "?/#{relative_path}"
-              end
-            else
-              absolute_path.inspect
-            end
-          }>"
-        end
-      end
-
-      module ClassMethods
-        RequiredField = Configurable::RequiredField
-
-        def root_paths
-          @root_paths ||= []
-        end
-
-        def path_heirarchy
-          @path_heirarchy ||= []
-        end
-        attr_writer :path_heirarchy
-
-        def path_fields
-          @path_fields ||= []
-        end
-
-        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, StructurePath.new(rel_path))
-          root_paths << field
-          path_fields << field
-          return field
-        end
-
-        def resolve_path_on(instance, parent, child_field, missing_relatives)
-          child = child_field.value_on(instance)
-          return unless child.field_unset?(:absolute_path)
-          if child.field_unset?(:relative_path)
-            missing_relatives << child_field
-            return
-          end
-          child.absolute_path = File::join(parent.absolute_path, child.relative_path)
-        end
-
-        def resolve_paths_on(instance)
-          superclass_exception = nil
-          if superclass < DirectoryStructure
-            begin
-            superclass.resolve_paths_on(instance)
-            rescue MissingRelativePaths => mrp
-              superclass_exception = mrp
-            end
-          end
-          missing_relatives = []
-
-          (root_paths - path_heirarchy.map{|_, child| child }).each do |field|
-            resolve_path_on(instance, instance, field, missing_relatives)
-          end
-
-          path_heirarchy.reverse.each do |parent_field, child_field|
-            next if missing_relatives.include?(parent_field)
-            parent = parent_field.value_on(instance)
-            resolve_path_on(instance, parent, child_field, missing_relatives)
-          end
-
-          case [missing_relatives.empty?, superclass_exception.nil?]
-          when [true, false]
-            raise superclass_exception
-          when [false, true]
-            raise MissingRelativePaths, "Required field#{missing_relatives.length == 1 ? "" : "s"} #{missing_relatives.map{|field| "#{field.name}.relative_path".inspect}.join(", ")} unset on #{self.inspect}"
-          when [false, false]
-            raise MissingRelativePaths, "Required field#{missing_relatives.length == 1 ? "" : "s"} #{missing_relatives.map{|field| "#{field.name}.relative_path".inspect}.join(", ")} unset on #{self.inspect}" + "\n" + superclass_exception.message
-          end
-
-          path_fields.each do |field|
-            value = field.value_on(instance)
-            next unless value.field_unset?(:relative_path)
-            value.relative_path = value.absolute_path
-          end
-        end
-      end
-
-      def self.included(sub)
-        sub.extend ClassMethods
-        dir_path =
-          if not (file_path = ::Rake.application.rakefile).nil?
-            File::dirname(File::expand_path(file_path))
-          elsif not (dir_path = ::Rake.application.original_dir).nil?
-            dir_path
-          else
-            file_path = caller[0].split(':')[0]
-            File::dirname(File::expand_path(file_path))
-          end
-        sub.setting :absolute_path, dir_path
-      end
-
-      def resolve_paths
-        self.class.resolve_paths_on(self)
-      end
-    end
-  end
-end

data/lib/mattock/configurable/field-metadata.rb

@@ -1,157 +0,0 @@
-module Mattock
-  module Configurable
-    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 inspect_on(instance, indent=nil)
-        set_props = DEFAULT_PROPERTIES.keys.find_all do |prop|
-          @properties[prop]
-        end
-        "Field: #{name}: #{value_on(instance).inspect} \n#{indent||""}(default: #{default_value.inspect} immediate: #{immediate_value_on(instance).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 copy_from(instance)
-        return if unset_on?(instance)
-        copy_value(immediate_value_on(instance))
-      end
-
-      def build_default_value
-        if Module === @default_value and Configurable > @default_value
-          value = @default_value.new
-          value.class.set_defaults_on(value)
-          value
-        else
-          copy_value(@default_value)
-        end
-      end
-
-      def copy_value(value)
-        case value
-        when Symbol, Numeric, NilClass, TrueClass, FalseClass
-          value
-        else
-          if value.class == BasicObject
-            value
-          elsif value.respond_to?(:dup)
-            value.dup
-          elsif value.respond_to?(:clone)
-            value.clone
-          else
-            value
-          end
-        end
-      end
-
-      def immediate_value_on(instance)
-        instance.instance_variable_get(ivar_name)
-        #instance.__send__(reader_method)
-      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 true unless instance.__send__(reader_method).nil?
-        return false unless instance.instance_variable_defined?(ivar_name)
-        value = immediate_value_on(instance)
-        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
-  end
-end

data/lib/mattock/configurable/field-processor.rb

@@ -1,54 +0,0 @@
-module Mattock
-  module Configurable
-    class FieldProcessor
-      def initialize(source)
-        @source = source
-        @field_names = filter(source.class.field_names)
-      end
-      attr_accessor :field_names
-      attr_reader :source
-
-      def filter(field_names)
-        field_names.find_all do |name|
-          source.class.field_metadata(name).is?(filter_attribute)
-        end
-      end
-
-      def can_process(field, target)
-        target.respond_to?(field.writer_method)
-      end
-
-      def to(target)
-        field_names.each do |name|
-          field = source.class.field_metadata(name)
-          next unless can_process(field, target)
-          target.__send__(field.writer_method, value(field))
-        end
-      end
-    end
-
-    class SettingsCopier < FieldProcessor
-      def filter_attribute
-        :copiable
-      end
-
-      def can_process(field, target)
-        super and not( field.unset_on?(source) and field.unset_on?(target) )
-      end
-
-      def value(field)
-        return field.copy_from(source)
-      end
-    end
-
-    class SettingsProxier < FieldProcessor
-      def filter_attribute
-        :proxiable
-      end
-
-      def value(field)
-        ProxyValue.new(source, field)
-      end
-    end
-  end
-end

data/lib/mattock/configurable/instance-methods.rb

@@ -1,87 +0,0 @@
-require 'mattock/configurable/directory-structure'
-
-module Mattock
-  module Configurable
-    def initialize_copy(original)
-      original.copy_settings_to(self)
-    end
-
-    def copy_settings
-      SettingsCopier.new(self)
-    end
-
-    def copy_settings_to(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 from_hash(hash)
-      self.class.from_hash(self, hash)
-    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
-
-    #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}"
-      end
-      self
-    end
-
-    def proxy_value
-      ProxyDecorator.new(self)
-    end
-
-    #XXX deprecate
-    def unset?(value)
-      warn "#unset? is deprecated - use field_unset? instead"
-      value.nil?
-    end
-
-    def field_unset?(name)
-      self.class.field_metadata(name).unset_on?(self)
-    end
-
-    #Requires that a named field be set
-    def fail_unless_set(name)
-      if field_unset?(name)
-        raise "Assertion failed: Field #{name} unset"
-      end
-      true
-    end
-    alias fail_if_unset fail_unless_set
-
-    class Struct
-      include Configurable
-      include Configurable::DirectoryStructure
-    end
-  end
-end

data/lib/mattock/configurable/proxy-value.rb

@@ -1,30 +0,0 @@
-module Mattock
-  module Configurable
-    class ProxyValue
-      def initialize(source, field)
-        @source, @field = source, field
-      end
-      attr_reader :source, :field
-
-      def inspect
-        "#{self.class.name.split(':').last}: #{source.class.name}.#{field.inspect}"
-      end
-    end
-
-    class ProxyDecorator
-      def initialize(configurable)
-        @configurable = configurable
-      end
-
-      def method_missing(name, *args, &block)
-        unless block.nil? and args.empty?
-          raise NoMethodError, "method `#{name}' not defined with arguments or block when proxied"
-        end
-        unless @configurable.respond_to?(name)
-          raise NoMethodError, "cannot proxy `#{name}' - undefined on #{@configurable}"
-        end
-        return ProxyValue.new(@configurable, @configurable.class.field_metadata(name))
-      end
-    end
-  end
-end

data/spec/configurable.rb

@@ -1,270 +0,0 @@
-require 'mattock'
-
-describe Mattock::Configurable do
-  class TestSuperStruct
-    include Mattock::Configurable
-
-    setting(:three, 3)
-    required_field(:four)
-    required_field(:override)
-  end
-
-  class TestStruct < TestSuperStruct
-    settings(:one => 1, :two => nested(:a => "a"){ required_field(:b)} )
-    nil_field(:five)
-
-    def override
-      17
-    end
-  end
-
-  subject do
-    TestStruct.new.setup_defaults
-  end
-
-  it "should set defaults" do
-    subject.one.should == 1
-    subject.two.a.should == "a"
-    subject.three.should == 3
-    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 "#from_hash" do
-    subject.from_hash({:one => 111, "two" => { :a => "aaa" }})
-
-    subject.one.should == 111
-    subject.two.a.should == "aaa"
-  end
-
-  it "should complain about unset required fields" do
-    expect do
-      subject.check_required
-    end.to raise_error
-  end
-
-  it "should complain about unset nested required fields" do
-    subject.four = 4
-    expect do
-      subject.check_required
-    end.to raise_error
-  end
-
-  it "should not complain when required fields are set" do
-    subject.four = 4
-    subject.two.b = "b"
-    expect do
-      subject.check_required
-    end.to_not raise_error
-    subject.override.should == 17
-  end
-
-  it "should inspect cleanly" do
-    subject.inspect.should be_a(String)
-  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")
-                 )
-             )
-         )
-
-      dir(:next_to_me, "rainbow", dir(:in_there, "a_place", path(:nearby, "a.file")))
-
-      path(:loose_path, "here")
-    end
-
-    describe "distinctness" do
-      let :one do
-        DirectoryThing.new.tap do |thing|
-          thing.setup_defaults
-        end
-      end
-
-      let :other do
-        DirectoryThing.new.tap do |thing|
-          thing.setup_defaults
-        end
-      end
-
-      it "should have same values" do
-        one.bundle_workdir.relative_path.should == other.bundle_workdir.relative_path
-      end
-
-      it "should have different actual objects" do
-        one.bundle_workdir.relative_path.should_not equal other.bundle_workdir.relative_path
-        one.bundle_workdir.should_not equal other.bundle_workdir
-      end
-
-    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
-
-    it "should inspect cleanly" do
-      subject.inspect.should be_a(String)
-    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("nearby.absolute_path"){ should =~ %r"rainbow/a_place/a.file$"}
-      its("nearby.absolute_path"){ should =~ %r"^#{subject.absolute_path}"}
-
-      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
-
-      setting(:normal, "1")
-      setting(:nested, nested{
-        setting :value, "2"
-      })
-      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, :nested, :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 make copies not references" do
-      left.copy_settings_to(right)
-      right.normal.should == left.normal
-      right.normal.should_not equal(left.normal)
-      right.nested.value.should == left.nested.value
-      right.nested.should_not equal(left.nested)
-      right.nested.value.should_not equal left.nested.value
-    end
-
-    it "should not copy no_copy" do
-      left.copy_settings_to(right)
-      right.field_unset?(:normal).should be_false
-      right.normal.should == "1"
-      right.field_unset?(:no_copy).should be_true
-      right.field_unset?(:no_proxy).should be_false
-      right.no_proxy.should == 3
-      right.field_unset?(:no_nothing).should be_true
-    end
-
-    it "should not proxy no_proxy" do
-      left.proxy_settings.to(right)
-      right.field_unset?(:normal).should be_false
-      right.normal.should == "1"
-      right.field_unset?(:no_copy).should be_false
-      right.no_copy.should == 2
-      right.field_unset?(:no_proxy).should be_true
-      right.field_unset?(:no_nothing).should be_true
-    end
-  end
-end