puppet 3.0.2 → 3.1.0.rc1

data/lib/puppet/dsl/resource_api.rb

@@ -1,120 +0,0 @@
-# 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'
-
-class Puppet::DSL::ResourceAPI
-  include Puppet::Resource::TypeCollectionHelper
-
-  FUNCTION_MAP = {:acquire => :include}
-
-  attr_reader :scope, :resource, :block
-
-  def environment
-    scope.environment
-  end
-
-  def evaluate
-    set_instance_variables
-    instance_eval(&block)
-  end
-
-  def initialize(resource, scope, block)
-    @scope = scope
-    @resource = resource
-    @block = block
-  end
-
-  # Try to convert a missing method into a resource type or a function.
-  def method_missing(name, *args)
-    raise "MethodMissing loop when searching for #{name} with #{args.inspect}" if searching_for_method?
-    @searching_for_method = true
-    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
-  ensure
-    @searching_for_method = false
-  end
-
-  def set_instance_variables
-    resource.eachparam do |param|
-      instance_variable_set("@#{param.name}", param.value)
-    end
-    @title = resource.title
-    @name ||= resource.title
-  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, name, :scope => scope)
-      arguments.each do |param, value|
-        resource[param] = value
-      end
-
-      resource.exported = true if exporting?
-      resource.virtual = true if virtualizing?
-      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 export(resources = nil, &block)
-    if resources
-      resources.each { |resource| resource.exported = true }
-      return resources
-    end
-    @exporting = true
-    instance_eval(&block)
-  ensure
-    @exporting = false
-  end
-
-  def virtual(resources = nil, &block)
-    if resources
-      resources.each { |resource| resource.virtual = true }
-      return resources
-    end
-    @virtualizing = true
-    instance_eval(&block)
-  ensure
-    @virtualizing = false
-  end
-
-  def valid_type?(name)
-    return true if [:class, :node].include?(name)
-    return true if Puppet::Type.type(name)
-    return(known_resource_types.definition(name) ? true : false)
-  end
-
-  private
-
-  def exporting?
-    @exporting
-  end
-
-  def map_function(name)
-    FUNCTION_MAP[name] || name
-  end
-
-  def searching_for_method?
-    @searching_for_method
-  end
-
-  def virtualizing?
-    @virtualizing
-  end
-end

data/lib/puppet/dsl/resource_type_api.rb

@@ -1,34 +0,0 @@
-require 'puppet/resource/type'
-
-# Type of the objects inside of which pure ruby manifest files are
-# executed.  Provides methods for creating defines, hostclasses, and
-# nodes.
-class Puppet::DSL::ResourceTypeAPI
-  def initialize
-    @__created_ast_objects__ = []
-  end
-
-  def define(name, *args, &block)
-    args = args.inject([]) do |result, item|
-      if item.is_a?(Hash)
-        item.each { |p, v| result << [p, v] }
-      else
-        result << item
-      end
-      result
-    end
-    @__created_ast_objects__.push Puppet::Parser::AST::Definition.new(name, {:arguments => args}, &block)
-    nil
-  end
-
-  def hostclass(name, options = {}, &block)
-    @__created_ast_objects__.push Puppet::Parser::AST::Hostclass.new(name, options, &block)
-    nil
-  end
-
-  def node(name, options = {}, &block)
-    name = [name] unless name.is_a?(Array)
-    @__created_ast_objects__.push Puppet::Parser::AST::Node.new(name, options, &block)
-    nil
-  end
-end

data/spec/integration/parser/ruby_manifest_spec.rb

@@ -1,127 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'tempfile'
-require 'puppet_spec/files'
-
-describe "Pure ruby manifests" do
-  include PuppetSpec::Files
-
-  before do
-    @node = Puppet::Node.new "testnode"
-
-    @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
-    @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
-    @test_dir = tmpdir('ruby_manifest_test')
-  end
-
-  after do
-    Puppet.settings.clear
-  end
-
-  def write_file(name, contents)
-    path = File.join(@test_dir, name)
-    File.open(path, "w") { |f| f.write(contents) }
-    path
-  end
-
-  def compile(contents)
-    Puppet[:code] = contents
-    Dir.chdir(@test_dir) do
-      Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-    end
-  end
-
-  it "should allow classes" do
-    write_file('foo.rb', ["hostclass 'one' do notify('one_notify') end",
-                          "hostclass 'two' do notify('two_notify') end"].join("\n"))
-    catalog = compile("import 'foo'\ninclude one")
-    catalog.resource("Notify[one_notify]").should_not be_nil
-    catalog.resource("Notify[two_notify]").should be_nil
-  end
-
-  it "should allow defines" do
-    write_file('foo.rb', 'define "bar", :arg do notify("bar_#{@name}_#{@arg}") end')
-    catalog = compile("import 'foo'\nbar { instance: arg => 'xyz' }")
-    catalog.resource("Notify[bar_instance_xyz]").should_not be_nil
-    catalog.resource("Bar[instance]").should_not be_nil
-  end
-
-  it "should allow node declarations" do
-    write_file('foo.rb', "node 'mynode' do notify('mynode') end")
-    catalog = compile("import 'foo'")
-    node_declaration = catalog.resource("Notify[mynode]")
-    node_declaration.should_not be_nil
-    node_declaration.title.should == 'mynode'
-  end
-
-  it "should allow access to the environment" do
-    write_file('foo.rb', ["hostclass 'bar' do",
-                          "  if environment.is_a? Puppet::Node::Environment",
-                          "    notify('success')",
-                          "  end",
-                          "end"].join("\n"))
-    compile("import 'foo'\ninclude bar").resource("Notify[success]").should_not be_nil
-  end
-
-  it "should allow creation of resources of built-in types" do
-    write_file('foo.rb', "hostclass 'bar' do file 'test_file', :owner => 'root', :mode => '644' end")
-    catalog = compile("import 'foo'\ninclude bar")
-    file = catalog.resource("File[test_file]")
-    file.should be_a(Puppet::Resource)
-    file.type.should == 'File'
-    file.title.should == 'test_file'
-    file.exported.should_not be
-    file.virtual.should_not be
-    file[:owner].should == 'root'
-    file[:mode].should == '644'
-    file[:stage].should be_nil # TODO: is this correct behavior?
-  end
-
-  it "should allow calling user-defined functions" do
-    write_file('foo.rb', "hostclass 'bar' do user_func 'name', :arg => 'xyz' end")
-    catalog = compile(['define user_func($arg) { notify {"n_$arg": } }',
-                       'import "foo"',
-                       'include bar'].join("\n"))
-    catalog.resource("Notify[n_xyz]").should_not be_nil
-    catalog.resource("User_func[name]").should_not be_nil
-  end
-
-  it "should be properly cached for multiple compiles" do
-    # Note: we can't test this by calling compile() twice, because
-    # that sets Puppet[:code], which clears out all cached
-    # environments.
-    Puppet[:filetimeout] = 1000
-    write_file('foo.rb', "hostclass 'bar' do notify('success') end")
-    Puppet[:code] = "import 'foo'\ninclude bar"
-
-    # Compile the catalog and check it
-    catalog = Dir.chdir(@test_dir) do
-      Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-    end
-    catalog.resource("Notify[success]").should_not be_nil
-
-    # Secretly change the file to make it invalid.  This change
-    # shouldn't be noticed because the we've set a high
-    # Puppet[:filetimeout].
-    write_file('foo.rb', "raise 'should not be executed'")
-
-    # Compile the catalog a second time and make sure it's still ok.
-    catalog = Dir.chdir(@test_dir) do
-      Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
-    end
-    catalog.resource("Notify[success]").should_not be_nil
-  end
-
-  it "should be properly reloaded when stale" do
-    Puppet[:filetimeout] = -1 # force stale check to happen all the time
-    write_file('foo.rb', "hostclass 'bar' do notify('version1') end")
-    catalog = compile("import 'foo'\ninclude bar")
-    catalog.resource("Notify[version1]").should_not be_nil
-    sleep 1 # so that timestamp will change forcing file reload
-    write_file('foo.rb', "hostclass 'bar' do notify('version2') end")
-    catalog = compile("import 'foo'\ninclude bar")
-    catalog.resource("Notify[version1]").should be_nil
-    catalog.resource("Notify[version2]").should_not be_nil
-  end
-end

data/spec/unit/dsl/resource_api_spec.rb

@@ -1,180 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/dsl/resource_api'
-
-describe Puppet::DSL::ResourceAPI do
-  before do
-    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-    @scope = Puppet::Parser::Scope.new(@compiler, :source => "foo")
-    @resource = Puppet::Parser::Resource.new(:mytype, "myresource", :scope => @scope)
-    @api = Puppet::DSL::ResourceAPI.new(@resource, @scope, proc { })
-  end
-
-  it "should include the resource type collection helper" do
-    Puppet::DSL::ResourceAPI.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
-  it "should use the scope's environment as its environment" do
-    @scope.expects(:environment).returns "myenv"
-    @api.environment.should == "myenv"
-  end
-
-  it "should be able to set all of its parameters as instance variables" do
-    @resource["foo"] = "myval"
-    @api.set_instance_variables
-    @api.instance_variable_get("@foo").should == "myval"
-  end
-
-  describe "when calling a function" do
-    it "should return false if the function does not exist" do
-      Puppet::Parser::Functions.expects(:function).with("myfunc").returns nil
-      @api.call_function("myfunc", "foo").should be_false
-    end
-
-    it "should use the scope the call the provided function with the provided arguments and return the results" do
-      scope = stub 'scope'
-      @api.stubs(:scope).returns scope
-      Puppet::Parser::Functions.expects(:function).with("myfunc").returns "myfunc_method"
-
-      scope.expects(:myfunc_method).with("one", "two")
-      @api.call_function("myfunc", ["one", "two"])
-    end
-
-    it "should call 'include' when asked to call 'acquire'" do
-      scope = stub 'scope'
-      @api.stubs(:scope).returns scope
-      @api.stubs(:valid_type?).returns false
-
-      scope.expects(:function_include).with("one", "two")
-      @api.acquire("one", "two")
-    end
-  end
-
-  describe "when determining if a provided name is a valid type" do
-    it "should be valid if it's :class" do
-      @api.should be_valid_type(:class)
-    end
-
-    it "should be valid if it's :node" do
-      @api.should be_valid_type(:node)
-    end
-
-    it "should be valid if it's a builtin type" do
-      Puppet::Type.expects(:type).with(:mytype).returns "whatever"
-      @api.should be_valid_type(:mytype)
-    end
-
-    it "should be valid if it's a defined resource type in the environment's known resource types" do
-      collection = stub 'collection'
-      @api.stubs(:known_resource_types).returns collection
-      collection.expects(:definition).with(:mytype).returns "whatever"
-      @api.should be_valid_type(:mytype)
-    end
-
-    it "should not be valid unless it's a node, class, builtin type, or defined resource" do
-      collection = stub 'collection'
-      @api.stubs(:known_resource_types).returns collection
-      collection.expects(:definition).returns nil
-      Puppet::Type.expects(:type).returns nil
-      @api.should_not be_valid_type(:mytype)
-    end
-  end
-
-  describe "when creating a resource" do
-    before do
-      @api.scope.stubs(:source).returns stub("source")
-      @api.scope.compiler.stubs(:add_resource)
-      @created_resource = Puppet::Parser::Resource.new("yay", "eh", :scope => @api.scope)
-    end
-
-    it "should create and return a resource of the type specified" do
-      Puppet::Parser::Resource.expects(:new).with { |type, title, args| type == "mytype" }.returns @created_resource
-      @api.create_resource("mytype", "myname", {:foo => "bar"}).should == [@created_resource]
-    end
-
-    it "should use the name from the first element of the provided argument array" do
-      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "myname" }.returns @created_resource
-      @api.create_resource("mytype", "myname", {:foo => "bar"})
-    end
-
-    it "should create multiple resources if the first element of the argument array is an array" do
-      second_resource = Puppet::Parser::Resource.new('yay', "eh", :scope => @api.scope)
-      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "first" }.returns @created_resource
-      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "second" }.returns @created_resource
-      @api.create_resource("mytype", ["first", "second"], {:foo => "bar"})
-    end
-
-    it "should provide its scope as the scope" do
-      Puppet::Parser::Resource.expects(:new).with { |type, title, args| args[:scope] == @api.scope }.returns @created_resource
-      @api.create_resource("mytype", "myname", {:foo => "bar"})
-    end
-
-    it "should set each provided argument as a parameter on the created resource" do
-      result = @api.create_resource("mytype", "myname", {"foo" => "bar", "biz" => "baz"}).shift
-      result["foo"].should == "bar"
-      result["biz"].should == "baz"
-    end
-
-    it "should add the resource to the scope's copmiler" do
-      Puppet::Parser::Resource.expects(:new).returns @created_resource
-      @api.scope.compiler.expects(:add_resource).with(@api.scope, @created_resource)
-      @api.create_resource("mytype", "myname", {:foo => "bar"})
-    end
-
-    it "should fail if the resource parameters are not a hash" do
-      lambda { @api.create_resource("mytype", "myname", %w{foo bar}) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "when an unknown method is called" do
-    it "should create a resource if the method name is a valid type" do
-      @api.expects(:valid_type?).with(:mytype).returns true
-      @api.expects(:create_resource).with(:mytype, "myname", {:foo => "bar"}).returns true
-
-      @api.mytype("myname", :foo => "bar")
-    end
-
-    it "should call any function whose name matches the undefined method if the name is not a valid type" do
-      @api.expects(:valid_type?).with(:myfunc).returns false
-      @api.expects(:create_resource).never
-
-      Puppet::Parser::Functions.expects(:function).with(:myfunc).returns true
-
-      @api.expects(:call_function).with(:myfunc, %w{foo bar})
-
-      @api.myfunc("foo", "bar")
-    end
-
-    it "should raise a method missing error if the method is neither a type nor a function" do
-      @api.expects(:valid_type?).with(:myfunc).returns false
-      @api.expects(:create_resource).never
-
-      Puppet::Parser::Functions.expects(:function).with(:myfunc).returns false
-
-      @api.expects(:call_function).never
-
-      lambda { @api.myfunc("foo", "bar") }.should raise_error(NoMethodError)
-    end
-  end
-
-  it "should mark the specified resource as exported when creating a single exported resource" do
-    resources = @api.export @api.file("/my/file", :ensure => :present)
-    resources[0].should be_exported
-  end
-
-  it "should mark all created resources as exported when creating exported resources using a block" do
-    @compiler.expects(:add_resource).with { |s, res| res.exported == true }
-    @api.export { file "/my/file", :ensure => :present }
-  end
-
-  it "should mark the specified resource as virtual when creating a single virtual resource" do
-    resources = @api.virtual @api.file("/my/file", :ensure => :present)
-    resources[0].should be_virtual
-  end
-
-  it "should mark all created resources as virtual when creating virtual resources using a block" do
-    @compiler.expects(:add_resource).with { |s, res| res.virtual == true }
-    @api.virtual { file "/my/file", :ensure => :present }
-  end
-end