[Pkg-puppet-devel] [SCM] Puppet packaging for Debian branch, upstream, updated. 0.25.5-639-g8f94f35
test branch
puppet-dev at googlegroups.com
Wed Jul 14 10:31:40 UTC 2010
The following commit has been merged in the upstream branch:
commit d0389f4d16efbeccf47d6cd2f1b0854ccb1c88d5
Author: Luke Kanies <luke at reductivelabs.com>
Date: Thu Jan 7 17:23:31 2010 -0800
Renaming Parser::ResourceType to Resource::Type
Basically, these classes (ResourceType and ResourceTypeCollection)
don't really belong in Parser, so I'm moving them to the
Resource namespace. This will be where anything RAL-related goes
from now on, and as we migrate functionality out of Puppet::Type,
it should go here.
Signed-off-by: Luke Kanies <luke at reductivelabs.com>
diff --git a/lib/puppet/application/main.rb b/lib/puppet/application/main.rb
index 3813df6..2952ef4 100644
--- a/lib/puppet/application/main.rb
+++ b/lib/puppet/application/main.rb
@@ -72,7 +72,7 @@ Puppet::Application.new(:main) do
Puppet[:manifest] = ARGV.shift
end
begin
- Puppet::Parser::ResourceTypeCollection.new(Puppet[:environment]).perform_initial_import
+ Puppet::Resource::TypeCollection.new(Puppet[:environment]).perform_initial_import
rescue => detail
Puppet.err detail
exit 1
diff --git a/lib/puppet/application/server.rb b/lib/puppet/application/server.rb
index e9253c6..afdad54 100644
--- a/lib/puppet/application/server.rb
+++ b/lib/puppet/application/server.rb
@@ -69,7 +69,7 @@ Puppet::Application.new(:server) do
command(:parseonly) do
begin
- Puppet::Parser::ResourceTypeCollection.new(Puppet[:environment]).perform_initial_import
+ Puppet::Resource::TypeCollection.new(Puppet[:environment]).perform_initial_import
rescue => detail
Puppet.err detail
exit 1
diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index a6e3370..537a5dd 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -44,7 +44,7 @@ class Puppet::Node::Environment
def known_resource_types
if @known_resource_types.nil? or @known_resource_types.stale?
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new(self)
+ @known_resource_types = Puppet::Resource::TypeCollection.new(self)
@known_resource_types.perform_initial_import
end
@known_resource_types
diff --git a/lib/puppet/parser.rb b/lib/puppet/parser.rb
index 3eda738..4d274b4 100644
--- a/lib/puppet/parser.rb
+++ b/lib/puppet/parser.rb
@@ -1,4 +1,4 @@
require 'puppet/parser/parser'
require 'puppet/parser/compiler'
-require 'puppet/parser/resource_type_collection'
+require 'puppet/resource/type_collection'
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 25b0641..c669076 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -5,14 +5,14 @@ require 'puppet/node'
require 'puppet/resource/catalog'
require 'puppet/util/errors'
-require 'puppet/parser/resource_type_collection_helper'
+require 'puppet/resource/type_collection_helper'
# Maintain a graph of scopes, along with a bunch of data
# about the individual catalog we're compiling.
class Puppet::Parser::Compiler
include Puppet::Util
include Puppet::Util::Errors
- include Puppet::Parser::ResourceTypeCollectionHelper
+ include Puppet::Resource::TypeCollectionHelper
def self.compile(node)
new(node).compile.to_resource
@@ -275,7 +275,7 @@ class Puppet::Parser::Compiler
# Find and evaluate our main object, if possible.
def evaluate_main
- @main = known_resource_types.find_hostclass("", "") || known_resource_types.add(Puppet::Parser::ResourceType.new(:hostclass, ""))
+ @main = known_resource_types.find_hostclass("", "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
@topscope.source = @main
@main_resource = Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => @topscope, :source => @main)
@topscope.resource = @main_resource
diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb
index b21ead3..e6bc46b 100644
--- a/lib/puppet/parser/parser_support.rb
+++ b/lib/puppet/parser/parser_support.rb
@@ -3,14 +3,14 @@
class Puppet::Parser::Parser
require 'puppet/parser/functions'
require 'puppet/parser/files'
- require 'puppet/parser/resource_type_collection'
- require 'puppet/parser/resource_type_collection_helper'
- require 'puppet/parser/resource_type'
+ require 'puppet/resource/type_collection'
+ require 'puppet/resource/type_collection_helper'
+ require 'puppet/resource/type'
require 'monitor'
AST = Puppet::Parser::AST
- include Puppet::Parser::ResourceTypeCollectionHelper
+ include Puppet::Resource::TypeCollectionHelper
attr_reader :version, :environment
attr_accessor :files
@@ -278,12 +278,12 @@ class Puppet::Parser::Parser
# Create a new class, or merge with an existing class.
def newclass(name, options = {})
- known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name, ast_context(true).merge(options))
+ known_resource_types.add Puppet::Resource::Type.new(:hostclass, name, ast_context(true).merge(options))
end
# Create a new definition.
def newdefine(name, options = {})
- known_resource_types.add Puppet::Parser::ResourceType.new(:definition, name, ast_context(true).merge(options))
+ known_resource_types.add Puppet::Resource::Type.new(:definition, name, ast_context(true).merge(options))
end
# Create a new node. Nodes are special, because they're stored in a global
@@ -292,7 +292,7 @@ class Puppet::Parser::Parser
names = [names] unless names.instance_of?(Array)
context = ast_context(true)
names.collect do |name|
- known_resource_types.add(Puppet::Parser::ResourceType.new(:node, name, context.merge(options)))
+ known_resource_types.add(Puppet::Resource::Type.new(:node, name, context.merge(options)))
end
end
diff --git a/lib/puppet/parser/resource/reference.rb b/lib/puppet/parser/resource/reference.rb
index bb50efd..ac1c79a 100644
--- a/lib/puppet/parser/resource/reference.rb
+++ b/lib/puppet/parser/resource/reference.rb
@@ -3,7 +3,7 @@ require 'puppet/resource/reference'
require 'puppet/file_collection/lookup'
require 'puppet/parser/yaml_trimmer'
-require 'puppet/parser/resource_type_collection_helper'
+require 'puppet/resource/type_collection_helper'
# A reference to a resource. Mostly just the type and title.
class Puppet::Parser::Resource::Reference < Puppet::Resource::Reference
@@ -11,7 +11,7 @@ class Puppet::Parser::Resource::Reference < Puppet::Resource::Reference
include Puppet::FileCollection::Lookup
include Puppet::Util::MethodHelper
include Puppet::Util::Errors
- include Puppet::Parser::ResourceTypeCollectionHelper
+ include Puppet::Resource::TypeCollectionHelper
attr_accessor :builtin, :file, :line, :scope
diff --git a/lib/puppet/parser/resource_type_collection_helper.rb b/lib/puppet/parser/resource_type_collection_helper.rb
deleted file mode 100644
index 51ccdc0..0000000
--- a/lib/puppet/parser/resource_type_collection_helper.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'puppet/parser/resource_type_collection'
-
-module Puppet::Parser::ResourceTypeCollectionHelper
- def known_resource_types
- environment.known_resource_types
- end
-end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 1f7fd71..b79b344 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -6,10 +6,10 @@ require 'puppet/parser/templatewrapper'
require 'puppet/transportable'
require 'strscan'
-require 'puppet/parser/resource_type_collection_helper'
+require 'puppet/resource/type_collection_helper'
class Puppet::Parser::Scope
- include Puppet::Parser::ResourceTypeCollectionHelper
+ include Puppet::Resource::TypeCollectionHelper
require 'puppet/parser/resource'
AST = Puppet::Parser::AST
diff --git a/lib/puppet/parser/resource_type.rb b/lib/puppet/resource/type.rb
similarity index 99%
rename from lib/puppet/parser/resource_type.rb
rename to lib/puppet/resource/type.rb
index c0d7f69..1a18b4e 100644
--- a/lib/puppet/parser/resource_type.rb
+++ b/lib/puppet/resource/type.rb
@@ -4,7 +4,7 @@ require 'puppet/util/errors'
require 'puppet/util/inline_docs'
require 'puppet/parser/ast/leaf'
-class Puppet::Parser::ResourceType
+class Puppet::Resource::Type
include Puppet::Util::InlineDocs
include Puppet::Util::Warnings
include Puppet::Util::Errors
diff --git a/lib/puppet/parser/resource_type_collection.rb b/lib/puppet/resource/type_collection.rb
similarity index 99%
rename from lib/puppet/parser/resource_type_collection.rb
rename to lib/puppet/resource/type_collection.rb
index cb90d9b..7ca95b1 100644
--- a/lib/puppet/parser/resource_type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,4 +1,4 @@
-class Puppet::Parser::ResourceTypeCollection
+class Puppet::Resource::TypeCollection
attr_reader :environment
def initialize(env)
diff --git a/lib/puppet/resource/type_collection_helper.rb b/lib/puppet/resource/type_collection_helper.rb
new file mode 100644
index 0000000..819cfba
--- /dev/null
+++ b/lib/puppet/resource/type_collection_helper.rb
@@ -0,0 +1,7 @@
+require 'puppet/resource/type_collection'
+
+module Puppet::Resource::TypeCollectionHelper
+ def known_resource_types
+ environment.known_resource_types
+ end
+end
diff --git a/spec/integration/parser/functions/include.rb b/spec/integration/parser/functions/include.rb
index 64346bf..f84d432 100755
--- a/spec/integration/parser/functions/include.rb
+++ b/spec/integration/parser/functions/include.rb
@@ -14,7 +14,7 @@ describe "The include function" do
end
it "should add a containment relationship between the 'included' class and our class" do
- @compiler.known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, "includedclass")
+ @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "includedclass")
@scope.function_include("includedclass")
diff --git a/spec/integration/parser/functions/require.rb b/spec/integration/parser/functions/require.rb
index 5f95ec5..1437299 100755
--- a/spec/integration/parser/functions/require.rb
+++ b/spec/integration/parser/functions/require.rb
@@ -16,7 +16,7 @@ describe "The require function" do
end
it "should add a dependency between the 'required' class and our class" do
- @compiler.known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, "requiredclass")
+ @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
@scope.function_require("requiredclass")
@scope.resource["require"].should_not be_nil
diff --git a/spec/integration/parser/parser.rb b/spec/integration/parser/parser.rb
index 08cab56..5a30f06 100755
--- a/spec/integration/parser/parser.rb
+++ b/spec/integration/parser/parser.rb
@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
describe Puppet::Parser::Parser do
before :each do
- @resource_type_collection = Puppet::Parser::ResourceTypeCollection.new("env")
+ @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
@parser = Puppet::Parser::Parser.new "development"
end
diff --git a/spec/integration/util/rdoc/parser.rb b/spec/integration/util/rdoc/parser.rb
index a52c11d..01bcb64 100755
--- a/spec/integration/util/rdoc/parser.rb
+++ b/spec/integration/util/rdoc/parser.rb
@@ -2,7 +2,7 @@
Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-require 'puppet/parser/resource_type_collection'
+require 'puppet/resource/type_collection'
require 'puppet/util/rdoc/parser'
require 'puppet/util/rdoc'
require 'puppet/util/rdoc/code_objects'
@@ -41,7 +41,7 @@ describe RDoc::Parser do
end
it "should parse to RDoc data structure" do
- @parser.expects(:document_class).with { |n,k,c| n == "::test" and k.is_a?(Puppet::Parser::ResourceType) }
+ @parser.expects(:document_class).with { |n,k,c| n == "::test" and k.is_a?(Puppet::Resource::Type) }
@parser.scan
end
diff --git a/spec/unit/application/main.rb b/spec/unit/application/main.rb
index ca185cb..74c40c1 100755
--- a/spec/unit/application/main.rb
+++ b/spec/unit/application/main.rb
@@ -144,7 +144,7 @@ describe "Puppet" do
@main.stubs(:exit)
@main.options.stubs(:[]).with(:code).returns "some code"
@collection = stub_everything
- Puppet::Parser::ResourceTypeCollection.stubs(:new).returns(@collection)
+ Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
end
it "should use a Puppet Resource Type Collection to parse the file" do
diff --git a/spec/unit/application/server.rb b/spec/unit/application/server.rb
index ba0fcfe..b300e94 100644
--- a/spec/unit/application/server.rb
+++ b/spec/unit/application/server.rb
@@ -262,7 +262,7 @@ describe "PuppetMaster" do
Puppet.stubs(:err)
@server_app.stubs(:exit)
@collection = stub_everything
- Puppet::Parser::ResourceTypeCollection.stubs(:new).returns(@collection)
+ Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
end
it "should use a Puppet Resource Type Collection to parse the file" do
diff --git a/spec/unit/node/environment.rb b/spec/unit/node/environment.rb
index 26d9aab..8198197 100755
--- a/spec/unit/node/environment.rb
+++ b/spec/unit/node/environment.rb
@@ -46,12 +46,12 @@ describe Puppet::Node::Environment do
describe "when managing known resource types" do
before do
@env = Puppet::Node::Environment.new("dev")
- @collection = Puppet::Parser::ResourceTypeCollection.new(@env)
+ @collection = Puppet::Resource::TypeCollection.new(@env)
@collection.stubs(:perform_initial_import)
end
it "should create a resource type collection if none exists" do
- Puppet::Parser::ResourceTypeCollection.expects(:new).with(@env).returns @collection
+ Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
@env.known_resource_types.should equal(@collection)
end
@@ -61,7 +61,7 @@ describe Puppet::Node::Environment do
it "should perform the initial import when creating a new collection" do
@collection.expects(:perform_initial_import)
- Puppet::Parser::ResourceTypeCollection.expects(:new).returns @collection
+ Puppet::Resource::TypeCollection.expects(:new).returns @collection
@env.known_resource_types
end
@@ -69,7 +69,7 @@ describe Puppet::Node::Environment do
it "should create and return a new collection rather than returning a stale collection" do
@env.known_resource_types.expects(:stale?).returns true
- Puppet::Parser::ResourceTypeCollection.expects(:new).returns @collection
+ Puppet::Resource::TypeCollection.expects(:new).returns @collection
@env.known_resource_types.should equal(@collection)
end
diff --git a/spec/unit/parser/compiler.rb b/spec/unit/parser/compiler.rb
index 4646f77..333046c 100755
--- a/spec/unit/parser/compiler.rb
+++ b/spec/unit/parser/compiler.rb
@@ -33,7 +33,7 @@ end
describe Puppet::Parser::Compiler do
before :each do
@node = Puppet::Node.new "testnode"
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new "development"
+ @known_resource_types = Puppet::Resource::TypeCollection.new "development"
@scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]', :type => "class"
@scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
@@ -62,7 +62,7 @@ describe Puppet::Parser::Compiler do
end
it "should include the resource type collection helper" do
- Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Parser::ResourceTypeCollectionHelper)
+ Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
end
it "should be able to return a class list containing all added classes" do
@@ -185,7 +185,7 @@ describe Puppet::Parser::Compiler do
it "should create a new, empty 'main' if no main class exists" do
compile_stub(:evaluate_main)
@compiler.compile
- @known_resource_types.find_hostclass("", "").should be_instance_of(Puppet::Parser::ResourceType)
+ @known_resource_types.find_hostclass("", "").should be_instance_of(Puppet::Resource::Type)
end
it "should evaluate any node classes" do
diff --git a/spec/unit/parser/parser.rb b/spec/unit/parser/parser.rb
index cb96e0c..bb0fa0a 100755
--- a/spec/unit/parser/parser.rb
+++ b/spec/unit/parser/parser.rb
@@ -7,7 +7,7 @@ describe Puppet::Parser do
ast = Puppet::Parser::AST
before :each do
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("development")
+ @known_resource_types = Puppet::Resource::TypeCollection.new("development")
@parser = Puppet::Parser::Parser.new "development"
@parser.stubs(:known_resource_types).returns @known_resource_types
@true_ast = Puppet::Parser::AST::Boolean.new :value => true
diff --git a/spec/unit/parser/resource.rb b/spec/unit/parser/resource.rb
index eb2cd49..bb3001c 100755
--- a/spec/unit/parser/resource.rb
+++ b/spec/unit/parser/resource.rb
@@ -8,7 +8,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
describe Puppet::Parser::Resource do
before do
@node = Puppet::Node.new("yaynode")
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("env")
+ @known_resource_types = Puppet::Resource::TypeCollection.new("env")
@compiler = Puppet::Parser::Compiler.new(@node)
@compiler.environment.stubs(:known_resource_types).returns @known_resource_types
@source = newclass ""
@@ -46,15 +46,15 @@ describe Puppet::Parser::Resource do
end
def newclass(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
end
def newdefine(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:definition, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
end
def newnode(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:node, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:node, name)
end
it "should use the file lookup module" do
diff --git a/spec/unit/parser/resource/reference.rb b/spec/unit/parser/resource/reference.rb
index 1034dbd..a386042 100755
--- a/spec/unit/parser/resource/reference.rb
+++ b/spec/unit/parser/resource/reference.rb
@@ -14,7 +14,7 @@ describe Puppet::Parser::Resource::Reference do
end
it "should use the resource type collection helper to find its known resource types" do
- Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Parser::ResourceTypeCollectionHelper)
+ Puppet::Parser::Resource::Reference.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
end
it "should use the file lookup module" do
@@ -70,21 +70,21 @@ end
describe Puppet::Parser::Resource::Reference, " when modeling defined types" do
def newclass(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
end
def newdefine(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:definition, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
end
def newnode(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:node, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:node, name)
end
before do
@type = Puppet::Parser::Resource::Reference
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("myenv")
+ @known_resource_types = Puppet::Resource::TypeCollection.new("myenv")
@definition = newdefine("mydefine")
@class = newclass("myclass")
@nodedef = newnode("mynode")
diff --git a/spec/unit/parser/scope.rb b/spec/unit/parser/scope.rb
index b48bd12..799d057 100755
--- a/spec/unit/parser/scope.rb
+++ b/spec/unit/parser/scope.rb
@@ -54,7 +54,7 @@ describe Puppet::Parser::Scope do
end
it "should use the resource type collection helper to find its known resource types" do
- Puppet::Parser::Scope.ancestors.should include(Puppet::Parser::ResourceTypeCollectionHelper)
+ Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
end
describe "when looking up a variable" do
@@ -99,7 +99,7 @@ describe Puppet::Parser::Scope do
end
def newclass(name)
- @known_resource_types.add Puppet::Parser::ResourceType.new(:hostclass, name)
+ @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
end
def create_class_scope(name)
diff --git a/spec/unit/parser/templatewrapper.rb b/spec/unit/parser/templatewrapper.rb
index b1f9d2a..1b41216 100755
--- a/spec/unit/parser/templatewrapper.rb
+++ b/spec/unit/parser/templatewrapper.rb
@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
describe Puppet::Parser::TemplateWrapper do
before(:each) do
- @known_resource_types = Puppet::Parser::ResourceTypeCollection.new("env")
+ @known_resource_types = Puppet::Resource::TypeCollection.new("env")
@compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
@compiler.environment.stubs(:known_resource_types).returns @known_resource_types
@scope = Puppet::Parser::Scope.new :compiler => @compiler
diff --git a/spec/unit/parser/resource_type.rb b/spec/unit/resource/type.rb
similarity index 72%
rename from spec/unit/parser/resource_type.rb
rename to spec/unit/resource/type.rb
index 816f861..14503b7 100755
--- a/spec/unit/parser/resource_type.rb
+++ b/spec/unit/resource/type.rb
@@ -2,16 +2,16 @@
require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/parser/resource_type'
+require 'puppet/resource/type'
-describe Puppet::Parser::ResourceType do
+describe Puppet::Resource::Type do
it "should have a 'name' attribute" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo").name.should == "foo"
+ Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
end
[:code, :doc, :line, :file, :code_collection].each do |attr|
it "should have a '#{attr}' attribute" do
- type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ type = Puppet::Resource::Type.new(:hostclass, "foo")
type.send(attr.to_s + "=", "yay")
type.send(attr).should == "yay"
end
@@ -19,156 +19,156 @@ describe Puppet::Parser::ResourceType do
describe "when a node" do
it "should allow a regex as its name" do
- lambda { Puppet::Parser::ResourceType.new(:node, /foo/) }.should_not raise_error
+ lambda { Puppet::Resource::Type.new(:node, /foo/) }.should_not raise_error
end
it "should allow a AST::HostName instance as its name" do
regex = Puppet::Parser::AST::Regex.new(:value => /foo/)
name = Puppet::Parser::AST::HostName.new(:value => regex)
- lambda { Puppet::Parser::ResourceType.new(:node, name) }.should_not raise_error
+ lambda { Puppet::Resource::Type.new(:node, name) }.should_not raise_error
end
it "should match against the regexp in the AST::HostName when a HostName instance is provided" do
regex = Puppet::Parser::AST::Regex.new(:value => /\w/)
name = Puppet::Parser::AST::HostName.new(:value => regex)
- node = Puppet::Parser::ResourceType.new(:node, name)
+ node = Puppet::Resource::Type.new(:node, name)
node.match("foo").should be_true
end
it "should return the value of the hostname if provided a string-form AST::HostName instance as the name" do
name = Puppet::Parser::AST::HostName.new(:value => "foo")
- node = Puppet::Parser::ResourceType.new(:node, name)
+ node = Puppet::Resource::Type.new(:node, name)
node.name.should == "foo"
end
describe "and the name is a regex" do
it "should have a method that indicates that this is the case" do
- Puppet::Parser::ResourceType.new(:node, /w/).should be_name_is_regex
+ Puppet::Resource::Type.new(:node, /w/).should be_name_is_regex
end
it "should set its namespace to ''" do
- Puppet::Parser::ResourceType.new(:node, /w/).namespace.should == ""
+ Puppet::Resource::Type.new(:node, /w/).namespace.should == ""
end
it "should return the regex converted to a string when asked for its name" do
- Puppet::Parser::ResourceType.new(:node, /ww/).name.should == "ww"
+ Puppet::Resource::Type.new(:node, /ww/).name.should == "ww"
end
it "should downcase the regex when returning the name as a string" do
- Puppet::Parser::ResourceType.new(:node, /W/).name.should == "w"
+ Puppet::Resource::Type.new(:node, /W/).name.should == "w"
end
it "should remove non-alpha characters when returning the name as a string" do
- Puppet::Parser::ResourceType.new(:node, /w*w/).name.should_not include("*")
+ Puppet::Resource::Type.new(:node, /w*w/).name.should_not include("*")
end
it "should remove leading dots when returning the name as a string" do
- Puppet::Parser::ResourceType.new(:node, /.ww/).name.should_not =~ /^\./
+ Puppet::Resource::Type.new(:node, /.ww/).name.should_not =~ /^\./
end
it "should have a method for matching its regex name against a provided name" do
- Puppet::Parser::ResourceType.new(:node, /.ww/).should respond_to(:match)
+ Puppet::Resource::Type.new(:node, /.ww/).should respond_to(:match)
end
it "should return true when its regex matches the provided name" do
- Puppet::Parser::ResourceType.new(:node, /\w/).match("foo").should be_true
+ Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
end
it "should return false when its regex does not match the provided name" do
- (!!Puppet::Parser::ResourceType.new(:node, /\d/).match("foo")).should be_false
+ (!!Puppet::Resource::Type.new(:node, /\d/).match("foo")).should be_false
end
it "should return true when its name, as a string, is matched against an equal string" do
- Puppet::Parser::ResourceType.new(:node, "foo").match("foo").should be_true
+ Puppet::Resource::Type.new(:node, "foo").match("foo").should be_true
end
it "should return false when its name is matched against an unequal string" do
- Puppet::Parser::ResourceType.new(:node, "foo").match("bar").should be_false
+ Puppet::Resource::Type.new(:node, "foo").match("bar").should be_false
end
it "should match names insensitive to case" do
- Puppet::Parser::ResourceType.new(:node, "fOo").match("foO").should be_true
+ Puppet::Resource::Type.new(:node, "fOo").match("foO").should be_true
end
end
it "should return the name converted to a string when the name is not a regex" do
pending "Need to define ResourceTypeCollection behaviour first"
name = Puppet::Parser::AST::HostName.new(:value => "foo")
- Puppet::Parser::ResourceType.new(:node, name).name.should == "foo"
+ Puppet::Resource::Type.new(:node, name).name.should == "foo"
end
it "should return the name converted to a string when the name is a regex" do
pending "Need to define ResourceTypeCollection behaviour first"
name = Puppet::Parser::AST::HostName.new(:value => /regex/)
- Puppet::Parser::ResourceType.new(:node, name).name.should == /regex/.to_s
+ Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
end
it "should mark any created scopes as a node scope" do
pending "Need to define ResourceTypeCollection behaviour first"
name = Puppet::Parser::AST::HostName.new(:value => /regex/)
- Puppet::Parser::ResourceType.new(:node, name).name.should == /regex/.to_s
+ Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
end
end
describe "when initializing" do
it "should require a resource super type" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo").type.should == :hostclass
+ Puppet::Resource::Type.new(:hostclass, "foo").type.should == :hostclass
end
it "should fail if provided an invalid resource super type" do
- lambda { Puppet::Parser::ResourceType.new(:nope, "foo") }.should raise_error(ArgumentError)
+ lambda { Puppet::Resource::Type.new(:nope, "foo") }.should raise_error(ArgumentError)
end
it "should set its name to the downcased, stringified provided name" do
- Puppet::Parser::ResourceType.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
+ Puppet::Resource::Type.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
end
it "should set its namespace to the downcased, stringified qualified portion of the name" do
- Puppet::Parser::ResourceType.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
+ Puppet::Resource::Type.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
end
%w{code line file doc}.each do |arg|
it "should set #{arg} if provided" do
- type = Puppet::Parser::ResourceType.new(:hostclass, "foo", arg.to_sym => "something")
+ type = Puppet::Resource::Type.new(:hostclass, "foo", arg.to_sym => "something")
type.send(arg).should == "something"
end
end
it "should set any provided arguments with the keys as symbols" do
- type = Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
+ type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
type.should be_validattr("foo")
type.should be_validattr("baz")
end
it "should set any provided arguments with they keys as strings" do
- type = Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
+ type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
type.should be_validattr(:foo)
type.should be_validattr(:baz)
end
it "should function if provided no arguments" do
- type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ type = Puppet::Resource::Type.new(:hostclass, "foo")
type.should_not be_validattr(:foo)
end
end
describe "when testing the validity of an attribute" do
it "should return true if the parameter was typed at initialization" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_validattr("foo")
+ Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_validattr("foo")
end
it "should return true if it is a metaparam" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo").should be_validattr("require")
+ Puppet::Resource::Type.new(:hostclass, "foo").should be_validattr("require")
end
it "should return true if the parameter is named 'name'" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo").should be_validattr("name")
+ Puppet::Resource::Type.new(:hostclass, "foo").should be_validattr("name")
end
it "should return false if it is not a metaparam and was not provided at initialization" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo").should_not be_validattr("yayness")
+ Puppet::Resource::Type.new(:hostclass, "foo").should_not be_validattr("yayness")
end
end
@@ -176,7 +176,7 @@ describe Puppet::Parser::ResourceType do
before do
@scope = stub 'scope', :newscope => nil
@resource = stub 'resource'
- @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ @type = Puppet::Resource::Type.new(:hostclass, "foo")
end
it "should return a new scope created with the provided scope as the parent" do
@@ -205,7 +205,7 @@ describe Puppet::Parser::ResourceType do
before do
@scope = stub 'scope', :newscope => nil, :setvar => nil
@resource = stub 'resource', :title => "yay", :name => "yea", :ref => "Foo[bar]"
- @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ @type = Puppet::Resource::Type.new(:hostclass, "foo")
end
it "should set each of the resource's parameters as variables in the scope" do
@@ -275,16 +275,16 @@ describe Puppet::Parser::ResourceType do
describe "when describing and managing parent classes" do
before do
- @code = Puppet::Parser::ResourceTypeCollection.new("env")
- @parent = Puppet::Parser::ResourceType.new(:hostclass, "bar")
+ @code = Puppet::Resource::TypeCollection.new("env")
+ @parent = Puppet::Resource::Type.new(:hostclass, "bar")
@code.add @parent
- @child = Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "bar")
+ @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
@code.add @child
end
it "should be able to define a parent" do
- Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "bar")
+ Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
end
it "should use the code collection to find the parent resource type" do
@@ -292,9 +292,9 @@ describe Puppet::Parser::ResourceType do
end
it "should be able to find parent nodes" do
- parent = Puppet::Parser::ResourceType.new(:node, "bar")
+ parent = Puppet::Resource::Type.new(:node, "bar")
@code.add parent
- child = Puppet::Parser::ResourceType.new(:node, "foo", :parent => "bar")
+ child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
@code.add child
child.parent_type.should equal(parent)
@@ -311,14 +311,14 @@ describe Puppet::Parser::ResourceType do
end
it "should be considered the child of a parent's parent" do
- @grandchild = Puppet::Parser::ResourceType.new(:hostclass, "baz", :parent => "foo")
+ @grandchild = Puppet::Resource::Type.new(:hostclass, "baz", :parent => "foo")
@code.add @grandchild
@grandchild.should be_child_of(@parent)
end
it "should correctly state when it is not another type's child" do
- @notchild = Puppet::Parser::ResourceType.new(:hostclass, "baz")
+ @notchild = Puppet::Resource::Type.new(:hostclass, "baz")
@code.add @notchild
@notchild.should_not be_child_of(@parent)
@@ -330,7 +330,7 @@ describe Puppet::Parser::ResourceType do
@compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
@scope = Puppet::Parser::Scope.new :compiler => @compiler
@resource = stub 'resource', :title => "yay", :name => "yea", :ref => "Foo[bar]", :scope => @scope
- @type = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ @type = Puppet::Resource::Type.new(:hostclass, "foo")
@type.stubs(:set_resource_parameters)
end
@@ -372,10 +372,10 @@ describe Puppet::Parser::ResourceType do
@compiler = Puppet::Parser::Compiler.new(@node)
@scope = Puppet::Parser::Scope.new(:compiler => @compiler)
- @top = Puppet::Parser::ResourceType.new :hostclass, "top"
- @middle = Puppet::Parser::ResourceType.new :hostclass, "middle", :parent => "top"
+ @top = Puppet::Resource::Type.new :hostclass, "top"
+ @middle = Puppet::Resource::Type.new :hostclass, "middle", :parent => "top"
- @code = Puppet::Parser::ResourceTypeCollection.new("env")
+ @code = Puppet::Resource::TypeCollection.new("env")
@code.add @top
@code.add @middle
end
@@ -385,15 +385,15 @@ describe Puppet::Parser::ResourceType do
end
it "should set its resource type to 'class' when it is a hostclass" do
- Puppet::Parser::ResourceType.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
+ Puppet::Resource::Type.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
end
it "should set its resource type to 'node' when it is a node" do
- Puppet::Parser::ResourceType.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
+ Puppet::Resource::Type.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
end
it "should fail when it is a definition" do
- lambda { Puppet::Parser::ResourceType.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
+ lambda { Puppet::Resource::Type.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
end
it "should add the created resource to the scope's catalog" do
@@ -409,7 +409,7 @@ describe Puppet::Parser::ResourceType do
end
it "should fail to evaluate if a parent class is defined but cannot be found" do
- othertop = Puppet::Parser::ResourceType.new :hostclass, "something", :parent => "yay"
+ othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
@code.add othertop
lambda { othertop.mk_plain_resource(@scope) }.should raise_error(Puppet::ParseError)
end
@@ -456,53 +456,53 @@ describe Puppet::Parser::ResourceType do
end
it "should fail unless it is a class" do
- lambda { Puppet::Parser::ResourceType.new(:node, "bar").merge("foo") }.should raise_error(ArgumentError)
+ lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(ArgumentError)
end
it "should fail unless the source instance is a class" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
- source = Puppet::Parser::ResourceType.new(:node, "foo")
+ dest = Puppet::Resource::Type.new(:hostclass, "bar")
+ source = Puppet::Resource::Type.new(:node, "foo")
lambda { dest.merge(source) }.should raise_error(ArgumentError)
end
it "should fail if both classes have different parent classes" do
- code = Puppet::Parser::ResourceTypeCollection.new("env")
+ code = Puppet::Resource::TypeCollection.new("env")
{"a" => "b", "c" => "d"}.each do |parent, child|
- code.add Puppet::Parser::ResourceType.new(:hostclass, parent)
- code.add Puppet::Parser::ResourceType.new(:hostclass, child, :parent => parent)
+ code.add Puppet::Resource::Type.new(:hostclass, parent)
+ code.add Puppet::Resource::Type.new(:hostclass, child, :parent => parent)
end
lambda { code.hostclass("b").merge(code.hostclass("d")) }.should raise_error(ArgumentError)
end
it "should copy the other class's parent if it has not parent" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
+ dest = Puppet::Resource::Type.new(:hostclass, "bar")
- parent = Puppet::Parser::ResourceType.new(:hostclass, "parent")
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :parent => "parent")
+ parent = Puppet::Resource::Type.new(:hostclass, "parent")
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "parent")
dest.merge(source)
dest.parent.should == "parent"
end
it "should copy the other class's documentation as its docs if it has no docs" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :doc => "yayness")
+ dest = Puppet::Resource::Type.new(:hostclass, "bar")
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
dest.merge(source)
dest.doc.should == "yayness"
end
it "should append the other class's docs to its docs if it has any" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :doc => "fooness")
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :doc => "yayness")
+ dest = Puppet::Resource::Type.new(:hostclass, "bar", :doc => "fooness")
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
dest.merge(source)
dest.doc.should == "foonessyayness"
end
it "should turn its code into an ASTArray if necessary" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :code => code("foo"))
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => code("bar"))
+ dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => code("foo"))
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
dest.merge(source)
@@ -510,8 +510,8 @@ describe Puppet::Parser::ResourceType do
end
it "should set the other class's code as its code if it has none" do
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar")
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => code("bar"))
+ dest = Puppet::Resource::Type.new(:hostclass, "bar")
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
dest.merge(source)
@@ -520,10 +520,10 @@ describe Puppet::Parser::ResourceType do
it "should append the other class's code to its code if it has any" do
dcode = Puppet::Parser::AST::ASTArray.new :children => [code("dest")]
- dest = Puppet::Parser::ResourceType.new(:hostclass, "bar", :code => dcode)
+ dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => dcode)
scode = Puppet::Parser::AST::ASTArray.new :children => [code("source")]
- source = Puppet::Parser::ResourceType.new(:hostclass, "foo", :code => scode)
+ source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
dest.merge(source)
diff --git a/spec/unit/parser/resource_type_collection.rb b/spec/unit/resource/type_collection.rb
similarity index 71%
rename from spec/unit/parser/resource_type_collection.rb
rename to spec/unit/resource/type_collection.rb
index b2f1588..2fc364d 100644
--- a/spec/unit/parser/resource_type_collection.rb
+++ b/spec/unit/resource/type_collection.rb
@@ -2,40 +2,40 @@
require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/parser/resource_type_collection'
-require 'puppet/parser/resource_type'
+require 'puppet/resource/type_collection'
+require 'puppet/resource/type'
-describe Puppet::Parser::ResourceTypeCollection do
+describe Puppet::Resource::TypeCollection do
before do
- @instance = Puppet::Parser::ResourceType.new(:hostclass, "foo")
- @code = Puppet::Parser::ResourceTypeCollection.new("env")
+ @instance = Puppet::Resource::Type.new(:hostclass, "foo")
+ @code = Puppet::Resource::TypeCollection.new("env")
end
it "should require an environment at initialization" do
env = Puppet::Node::Environment.new("testing")
- Puppet::Parser::ResourceTypeCollection.new(env).environment.should equal(env)
+ Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
end
it "should convert the environment into an environment instance if a string is provided" do
env = Puppet::Node::Environment.new("testing")
- Puppet::Parser::ResourceTypeCollection.new("testing").environment.should equal(env)
+ Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
end
it "should be able to add a resource type" do
- Puppet::Parser::ResourceTypeCollection.new("env").should respond_to(:add)
+ Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
end
it "should consider '<<' to be an alias to 'add' but should return self" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.expects(:add).with "foo"
loader.expects(:add).with "bar"
loader << "foo" << "bar"
end
it "should set itself as the code collection for added resource types" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
- node = Puppet::Parser::ResourceType.new(:node, "foo")
+ node = Puppet::Resource::Type.new(:node, "foo")
@code.add(node)
@code.node("foo").should equal(node)
@@ -44,21 +44,21 @@ describe Puppet::Parser::ResourceTypeCollection do
end
it "should store node resource types as nodes" do
- node = Puppet::Parser::ResourceType.new(:node, "foo")
+ node = Puppet::Resource::Type.new(:node, "foo")
@code.add(node)
@code.node("foo").should equal(node)
end
it "should store hostclasses as hostclasses" do
- klass = Puppet::Parser::ResourceType.new(:hostclass, "foo")
+ klass = Puppet::Resource::Type.new(:hostclass, "foo")
@code.add(klass)
@code.hostclass("foo").should equal(klass)
end
it "should store definitions as definitions" do
- define = Puppet::Parser::ResourceType.new(:definition, "foo")
+ define = Puppet::Resource::Type.new(:definition, "foo")
@code.add(define)
@code.definition("foo").should equal(define)
@@ -66,49 +66,49 @@ describe Puppet::Parser::ResourceTypeCollection do
%w{hostclass node definition}.each do |data|
it "should have a method for adding a #{data}" do
- Puppet::Parser::ResourceTypeCollection.new("env").should respond_to("add_" + data)
+ Puppet::Resource::TypeCollection.new("env").should respond_to("add_" + data)
end
it "should use the name of the instance to add it" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.send("add_#{data}", @instance)
loader.send(data, @instance.name).should equal(@instance)
end
it "should fail to add a #{data} when one already exists" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.add @instance
lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
end
it "should return the added #{data}" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.add(@instance).should equal(@instance)
end
it "should be able to retrieve #{data} by name" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(data, "bar")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(data, "bar")
loader.add instance
loader.send(data, "bar").should equal(instance)
end
it "should retrieve #{data} insensitive to case" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(data, "Bar")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(data, "Bar")
loader.add instance
loader.send(data, "bAr").should equal(instance)
end
it "should return nil when asked for a #{data} that has not been added" do
- Puppet::Parser::ResourceTypeCollection.new("env").send(data, "foo").should be_nil
+ Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
end
it "should be able to retrieve all #{data}s" do
plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(data, "foo")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(data, "foo")
loader.add instance
loader.send(plurals[data]).should == { "foo" => instance }
end
@@ -116,111 +116,111 @@ describe Puppet::Parser::ResourceTypeCollection do
describe "when finding a qualified instance" do
it "should return any found instance if the instance name is fully qualified" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
loader.add instance
loader.find("namespace", "::foo::bar", :hostclass).should equal(instance)
end
it "should return nil if the instance name is fully qualified and no such instance exists" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.find("namespace", "::foo::bar", :hostclass).should be_nil
end
it "should return the partially qualified object if it exists in the provided namespace" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
loader.add instance
loader.find("foo", "bar::baz", :hostclass).should equal(instance)
end
it "should return the unqualified object if it exists in the provided namespace" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
loader.add instance
loader.find("foo", "bar", :hostclass).should equal(instance)
end
it "should return the unqualified object if it exists in the parent namespace" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
loader.add instance
loader.find("foo::bar::baz", "bar", :hostclass).should equal(instance)
end
it "should should return the partially qualified object if it exists in the parent namespace" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
loader.add instance
loader.find("foo::bar", "bar::baz", :hostclass).should equal(instance)
end
it "should return the qualified object if it exists in the root namespace" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
loader.add instance
loader.find("foo::bar", "foo::bar::baz", :hostclass).should equal(instance)
end
it "should return nil if the object cannot be found" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- instance = Puppet::Parser::ResourceType.new(:hostclass, "foo::bar::baz")
+ loader = Puppet::Resource::TypeCollection.new("env")
+ instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
loader.add instance
loader.find("foo::bar", "eh", :hostclass).should be_nil
end
end
it "should use the generic 'find' method with an empty namespace to find nodes" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.expects(:find).with("", "bar", :node)
loader.find_node("bar")
end
it "should use the generic 'find' method to find hostclasses" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.expects(:find).with("foo", "bar", :hostclass)
loader.find_hostclass("foo", "bar")
end
it "should use the generic 'find' method to find definitions" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ loader = Puppet::Resource::TypeCollection.new("env")
loader.expects(:find).with("foo", "bar", :definition)
loader.find_definition("foo", "bar")
end
it "should indicate whether any nodes are defined" do
- loader = Puppet::Parser::ResourceTypeCollection.new("env")
- loader.add_node(Puppet::Parser::ResourceType.new(:node, "foo"))
+ loader = Puppet::Resource::TypeCollection.new("env")
+ loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
loader.should be_nodes
end
it "should indicate whether no nodes are defined" do
- Puppet::Parser::ResourceTypeCollection.new("env").should_not be_nodes
+ Puppet::Resource::TypeCollection.new("env").should_not be_nodes
end
describe "when finding nodes" do
before :each do
- @loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ @loader = Puppet::Resource::TypeCollection.new("env")
end
it "should return any node whose name exactly matches the provided node name" do
- node = Puppet::Parser::ResourceType.new(:node, "foo")
+ node = Puppet::Resource::Type.new(:node, "foo")
@loader << node
@loader.node("foo").should equal(node)
end
it "should return the first regex node whose regex matches the provided node name" do
- node1 = Puppet::Parser::ResourceType.new(:node, /\w/)
- node2 = Puppet::Parser::ResourceType.new(:node, /\d/)
+ node1 = Puppet::Resource::Type.new(:node, /\w/)
+ node2 = Puppet::Resource::Type.new(:node, /\d/)
@loader << node1 << node2
@loader.node("foo10").should equal(node1)
end
it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
- node1 = Puppet::Parser::ResourceType.new(:node, /\w/)
- node2 = Puppet::Parser::ResourceType.new(:node, "foo")
+ node1 = Puppet::Resource::Type.new(:node, /\w/)
+ node2 = Puppet::Resource::Type.new(:node, "foo")
@loader << node1 << node2
@loader.node("foo").should equal(node2)
@@ -229,7 +229,7 @@ describe Puppet::Parser::ResourceTypeCollection do
describe "when managing files" do
before do
- @loader = Puppet::Parser::ResourceTypeCollection.new("env")
+ @loader = Puppet::Resource::TypeCollection.new("env")
Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
end
@@ -272,7 +272,7 @@ describe Puppet::Parser::ResourceTypeCollection do
before do
@parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
Puppet::Parser::Parser.stubs(:new).returns @parser
- @code = Puppet::Parser::ResourceTypeCollection.new("env")
+ @code = Puppet::Resource::TypeCollection.new("env")
end
it "should create a new parser instance" do
@@ -312,7 +312,7 @@ describe Puppet::Parser::ResourceTypeCollection do
describe "when determining the configuration version" do
before do
- @code = Puppet::Parser::ResourceTypeCollection.new("env")
+ @code = Puppet::Resource::TypeCollection.new("env")
end
it "should default to the current time" do
diff --git a/spec/unit/parser/resource_type_collection_helper.rb b/spec/unit/resource/type_collection_helper.rb
similarity index 74%
rename from spec/unit/parser/resource_type_collection_helper.rb
rename to spec/unit/resource/type_collection_helper.rb
index c93c9f2..e390ff9 100644
--- a/spec/unit/parser/resource_type_collection_helper.rb
+++ b/spec/unit/resource/type_collection_helper.rb
@@ -2,13 +2,13 @@
require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/parser/resource_type_collection_helper'
+require 'puppet/resource/type_collection_helper'
class RTCHelperTester
- include Puppet::Parser::ResourceTypeCollectionHelper
+ include Puppet::Resource::TypeCollectionHelper
end
-describe Puppet::Parser::ResourceTypeCollectionHelper do
+describe Puppet::Resource::TypeCollectionHelper do
before do
@helper = RTCHelperTester.new
end
diff --git a/spec/unit/util/rdoc/parser.rb b/spec/unit/util/rdoc/parser.rb
index c62b01d..7113b95 100755
--- a/spec/unit/util/rdoc/parser.rb
+++ b/spec/unit/util/rdoc/parser.rb
@@ -2,7 +2,7 @@
Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-require 'puppet/parser/resource_type_collection'
+require 'puppet/resource/type_collection'
require 'puppet/util/rdoc/parser'
require 'puppet/util/rdoc/code_objects'
require 'rdoc/options'
@@ -141,7 +141,7 @@ describe RDoc::Parser do
@definition = stub_everything 'definition', :file => "module/manifests/init.pp", :type => :definition, :name => "mydef"
@node = stub_everything 'node', :file => "module/manifests/init.pp", :type => :node, :name => "mynode"
- @resource_type_collection = Puppet::Parser::ResourceTypeCollection.new("env")
+ @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
@parser.ast = @resource_type_collection
@container = stub_everything 'container'
diff --git a/test/language/parser.rb b/test/language/parser.rb
index 6c68184..a3311f4 100755
--- a/test/language/parser.rb
+++ b/test/language/parser.rb
@@ -426,7 +426,7 @@ file { "/tmp/yayness":
assert_nothing_raised do
out = parser.parse ""
- assert_instance_of(Puppet::Parser::ResourceTypeCollection, out)
+ assert_instance_of(Puppet::Resource::TypeCollection, out)
assert_nil(parser.hostclass(""), "Got a 'main' class when we had no code")
end
@@ -434,7 +434,7 @@ file { "/tmp/yayness":
parser.initvars
assert_nothing_raised do
out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
- assert_instance_of(Puppet::Parser::ResourceTypeCollection, out)
+ assert_instance_of(Puppet::Resource::TypeCollection, out)
assert_equal("", parser.hostclass("").classname)
assert_equal("", parser.hostclass("").namespace)
end
@@ -801,7 +801,7 @@ file { "/tmp/yayness":
assert_nothing_raised("Could not parse") do
result = parser.parse(str)
end
- assert_instance_of(Puppet::Parser::ResourceTypeCollection, result, "Did not get a ASTSet back from parsing")
+ assert_instance_of(Puppet::Resource::TypeCollection, result, "Did not get a ASTSet back from parsing")
assert_instance_of(AST::HostClass, result.hostclass("yay"), "Did not create 'yay' class")
assert_instance_of(AST::HostClass, result.hostclass(""), "Did not create main class")
--
Puppet packaging for Debian
More information about the Pkg-puppet-devel
mailing list