Adding simplistic pure ruby interface

This is a simplistic DSL - you can create
resource types (defined resources), classes,
and nodes, and they can call functions and
create resources.  Nothing else, at this point.

Signed-off-by: Luke Kanies <luke@reductivelabs.com>

2 files changed, 102 insertions, 0 deletions

diff --git a/lib/puppet/dsl/resource_helper.rb b/lib/puppet/dsl/resource_helper.rb
new file mode 100644
index 000000000..aaf8ab5f7
--- /dev/null
+++ b/lib/puppet/dsl/resource_helper.rb
@@ -0,0 +1,62 @@
+# This module adds functionality to a resource to make it
+# capable of evaluating the DSL resource type block and also
+# hooking into the scope system.
+require 'puppet/resource/type_collection_helper'
+
+module Puppet::DSL::ResourceHelper
+    include Puppet::Resource::TypeCollectionHelper
+
+    FUNCTION_MAP = {:acquire => :include}
+
+    # Try to convert a missing method into a resource type or a function.
+    def method_missing(name, *args)
+        return create_resource(name, args[0], args[1]) if valid_type?(name)
+
+        name = map_function(name)
+
+        return call_function(name, args) if Puppet::Parser::Functions.function(name)
+
+        super
+    end
+
+    def set_instance_variables
+        eachparam do |param|
+            instance_variable_set("@#{param.name}", param.value)
+        end
+    end
+
+    def create_resource(type, names, arguments = nil)
+        names = [names] unless names.is_a?(Array)
+
+        arguments ||= {}
+        raise ArgumentError, "Resource arguments must be provided as a hash" unless arguments.is_a?(Hash)
+
+        names.collect do |name|
+            resource = Puppet::Parser::Resource.new(:type => type, :title => name, :scope => scope)
+            arguments.each do |param, value|
+                resource[param] = value
+            end
+
+            scope.compiler.add_resource(scope, resource)
+            resource
+        end
+    end
+
+    def call_function(name, args)
+        return false unless method = Puppet::Parser::Functions.function(name)
+        scope.send(method, *args)
+    end
+
+    def valid_type?(name)
+        return true if [:class, :node].include?(name)
+        return true if Puppet::Type.type(name)
+        return true if known_resource_types.definition(name)
+        return false
+    end
+
+    private
+
+    def map_function(name)
+        return FUNCTION_MAP[name] || name
+    end
+end
diff --git a/lib/puppet/dsl/resource_type_api.rb b/lib/puppet/dsl/resource_type_api.rb
new file mode 100644
index 000000000..014d1a3dc
--- /dev/null
+++ b/lib/puppet/dsl/resource_type_api.rb
@@ -0,0 +1,40 @@
+require 'puppet/resource/type'
+
+module Puppet::DSL::ResourceTypeAPI
+    def resource_type(name, *args, &block)
+        result = mk_resource_type(:definition, name, Hash.new, block)
+        result.set_arguments(munge_type_arguments(args))
+        result
+    end
+
+    def hostclass(name, options = {}, &block)
+        mk_resource_type(:hostclass, name, options, block)
+    end
+
+    def node(name, options = {}, &block)
+        mk_resource_type(:node, name, options, block)
+    end
+
+    private
+
+    def mk_resource_type(type, name, options, code)
+        klass = Puppet::Resource::Type.new(type, name, options)
+
+        klass.ruby_code = code if code
+
+        Puppet::Node::Environment.new.known_resource_types.add klass
+
+        klass
+    end
+
+    def munge_type_arguments(args)
+        args.inject([]) do |result, item|
+            if item.is_a?(Hash)
+                item.each { |p, v| result << [p, v] }
+            else
+                result << item
+            end
+            result
+        end
+    end
+end