puppet 3.1.0.rc1 → 3.1.0.rc2

data/lib/puppet/dsl/resource_decorator.rb

@@ -1,56 +0,0 @@
-require 'puppet/dsl/blank_slate'
-require 'puppet/dsl/resource_reference'
-
-module Puppet
-  # @since 3.1 
-  # @status EXPERIMENTAL
-  module DSL
-    # Thin decorator layer for accessing attributes of array/hash-like objects.
-    # @see Puppet::DSL::Context#create_resource  Context#create_resource for examples of usage
-    #
-    class ResourceDecorator < BlankSlate
-
-      # Initializes new object.
-      # @overload initialize(resource, {|r| block})
-      # @param resource [#[], #[]=] any object responding to these methods
-      # @yieldparam r [ResourceDecorator] the `self` when evaluating the ruby block
-      # @param block [ruby] the Ruby DSL statements to evaluate.
-      #
-      def initialize(resource, &block)
-        @resource = resource
-        block.call self
-      end
-
-      # A proxy method allowing direct access to resource parameters instead of
-      # having to use `#[]` or `#[]=`
-      #
-      # After a first call it creates a cached version of the created access method.
-      #
-      # @example
-      #   # allows using this
-      #   r.title = "I am a resource"
-      #   # instead of this
-      #   r[:title] = "I am a resource"
-      #
-      def method_missing(name, *args)
-        if name.to_s =~ /\A(.*)=\z/
-          define_singleton_method name do |*a|
-            value = a.first
-            value = value.reference if value.is_a? ::Puppet::DSL::ResourceReference
-            value = value.to_s  unless value.is_a? ::Puppet::Resource
-            @resource[$1.to_sym] = value
-          end
-
-          self.__send__ name, *args
-        else
-          define_singleton_method name do
-            @resource[name]
-          end
-
-          self.__send__ name, *args
-        end
-      end
-
-    end
-  end
-end

data/lib/puppet/dsl/resource_reference.rb

@@ -1,95 +0,0 @@
-require 'puppet/dsl/resource_decorator'
-require 'puppet/dsl/parser'
-require 'puppet/parser/resource/param'
-require 'puppet/parser/resource'
-
-module Puppet
-  # @since 3.1 
-  # @status EXPERIMENTAL
-  module DSL
-    # ResourceReference is a thin wrapper for assigning references to the
-    # resources and creating overrides.
-    #
-    class ResourceReference
-      # @return [Puppet::Parser::Resource] referenced resource
-      #
-      attr_reader :resource
-
-      # Creates a new ResourceReference.
-      # @param typeref [String] the name of the type
-      # @param name [String] the name of a resource instance of this type
-      # @raise [ArgumentError] if the referenced _typename_/_name_ is not found
-      #
-      def initialize(typeref, name)
-        @resource = Puppet::DSL::Parser.current_scope.findresource typeref.type_name, name
-        raise ArgumentError, "resource `#{typeref.type_name}[#{name}]' not found" unless @resource
-      end
-
-      # This method is used by ResourceDecorator for stringifying references.
-      # @return [String] the resource in string form
-      #
-      def reference
-        @resource.to_s
-      end
-      alias to_s reference
-
-      # Creates overrides for a resource and returns the resulting overrides as a Hash.
-      # @overload override(options)
-      # @overload override(options, {|r| block}
-      # @overload override({|r| block})
-      # @param options [Hash] parameter name to value mapping of values to override.
-      # @param r [ResourceReference] the `self` when evaluating the Ruby DSL block.
-      # @param block [ruby] Ruby DSL statements to be executed.
-      # @return [Hash] a hash with a mapping from parameter name to value with overridden name/values.
-      # @raise [ArgumentError] when no block or options have been supplied.
-      #
-      def override(options = {}, &block)
-        raise ArgumentError, "no block or options supplied" if options == {} and block.nil?
-
-        Puppet::DSL::ResourceDecorator.new(options, &block) unless block.nil?
-        scope = Puppet::DSL::Parser.current_scope
-
-        # for compatibility with Puppet parser
-        params = options.map do |k, v|
-          Puppet::Parser::Resource::Param.new :name => k, :value => v, :source => scope.source
-        end
-
-        resource = Puppet::Parser::Resource.new @resource.type, @resource.name,
-                                                :parameters => params, :scope => scope,
-                                                :source => scope.source
-
-        override = scope.compiler.add_override resource
-
-        result = {}
-        override.each do |_, v|
-          result.merge! v.name => v.value
-        end
-        result
-      end
-
-      # Realizes referenced virtual resource.
-      # @return [Puppet::Parser::Collector, nil] collector containing the realized resource, or nil if it is not virtual.
-      #
-      def realize
-        return unless @resource.virtual
-        scope = Puppet::DSL::Parser.current_scope
-        c = Puppet::Parser::Collector.new scope, @type, nil, nil, :virtual
-        c.resources = [@resource]
-        scope.compiler.add_collection c
-        c
-      end
-
-      # Collects referenced exported resource
-      # @return [Puppet::Parser::Collector, nil] collector containing the collected resource, or nil if it is not exported.
-      #
-      def collect
-        return unless @resource.exported
-        scope = Puppet::DSL::Parser.current_scope
-        c = Puppet::Parser::Collector.new scope, @type, nil, nil, :exported
-        c.resources = [@resource]
-        scope.compiler.add_collection c
-        c
-      end
-    end
-  end
-end

data/lib/puppet/dsl/type_reference.rb

@@ -1,102 +0,0 @@
-require 'puppet/parser/collector'
-require 'puppet/parser/resource/param'
-require 'puppet/dsl/resource_reference'
-require 'puppet/dsl/resource_decorator'
-require 'puppet/dsl/parser'
-
-module Puppet
-  # @since 3.1 
-  # @status EXPERIMENTAL
-  module DSL
-
-    # TypeReference object is returned by `Context#const_missing`.
-    # It allows to set defaults, create collections and get references for
-    # resources of given type.
-    #
-    class TypeReference
-
-      # @return [String] Puppet type represented by this reference
-      #
-      attr_reader :type_name
-      alias to_s type_name
-
-      # Creates new TypeReference of the given _typename_ type.
-      # @param typename [String] the name of the type to create a reference to.
-      # @raise [NameError] when resource type is not found
-      #
-      def initialize(typename)
-        name = Puppet::Resource.canonicalize_type typename
-        if Puppet::DSL::Context.const_defined? name
-          @type_name = name
-          @cache = {}
-        else
-          raise NameError, "resource type `#{name}' not found"
-        end
-      end
-
-      # Produces a reference to a resource identified by the given _reference_.
-      # The result is cached for future use.
-      # @return [ResourceReference] reference to resource identified by the given _reference_
-      # @raise [ArgumentError] when resource cannot be found.
-      #
-      def [](reference)
-        @cache[reference] ||= Puppet::DSL::ResourceReference.new self, reference
-      end
-
-      # Creates a collection for exported resources.
-      # @return [Puppet::Parser::Collector] for exported instances of this type reference's type.
-      #
-      def collect
-        scope = Puppet::DSL::Parser.current_scope
-        c = Puppet::Parser::Collector.new scope, @type_name, nil, nil, :exported
-        scope.compiler.add_collection c
-        c
-      end
-
-      # Creates a collection for virtual resources.
-      # @return [Puppet::Parser::Collector] for virtual instances of this type reference's type.
-      #
-      def realize
-        scope = Puppet::DSL::Parser.current_scope
-        c = Puppet::Parser::Collector.new scope, @type_name, nil, nil, :virtual
-        scope.compiler.add_collection c
-        c
-      end
-
-      # Sets and/or gets defaults for the resource type this type reference represents. The values
-      # returned are the defaults in effect after the operation.
-      # @overload defaults()
-      #   @return [Hash] a parameter to value mapping of the current set of defaults.
-      #
-      # @overload defaults(options)
-      #   Sets the defaults in the given options hash as new default values. Only changes
-      #   values for the given keys.
-      #   @param options [Hash] mapping from parameter name to value of new defaults to set.
-      #
-      # @overload defaults(options, {|r| block})
-      #   @param options [Hash] a parameter to value mapping of the new defaults to set.
-      #   @param r [ResourceDecorator] the `self` when evaluating the Ruby DSL block.
-      #   @param block [ruby] a block in which Ruby DSL statements can be executed for the resource type.
-      # @return [Hash] mapping from parameter name to value of the resulting set of defaults.
-      #
-      def defaults(options = {}, &block)
-        if options != {} or block
-          Puppet::DSL::ResourceDecorator.new(options, &block) unless block.nil?
-
-          # for compatibility with Puppet parser
-          options = options.map do |k, v|
-            Puppet::Parser::Resource::Param.new :name => k, :value => v
-          end
-          Puppet::DSL::Parser.current_scope.define_settings @type_name, options
-        end
-
-        result = {}
-        Puppet::DSL::Parser.current_scope.lookupdefaults(@type_name).map do |_, v|
-          result[v.name] = v.value
-        end
-        result
-      end
-
-    end
-  end
-end

data/lib/puppet/util/manifest_filetype_helper.rb

@@ -1,22 +0,0 @@
-module Puppet
-  module Util
-
-    ##
-    # Module that gathers helper functions for determining type of manifests.
-    ##
-    module ManifestFiletypeHelper
-      extend self
-
-      def is_ruby_filename?(file)
-        !!(file =~ /\.rb\z/i)
-      end
-
-      def is_puppet_filename?(file)
-        !!(file =~ /\.pp\z/i)
-      end
-
-    end
-  end
-end
-
-

data/spec/integration/dsl/classes_spec.rb

@@ -1,191 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'matchers/catalog'
-require 'puppet_spec/compiler'
-
-include PuppetSpec::Compiler
-
-describe Puppet::DSL do
-  prepare_compiler
-
-  describe "classes" do
-
-    it "should be able to create a class" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {}
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do; end
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "shouldn't evaluate the body of the class until it is used" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          notify {"bar": }
-        }
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do
-          notify "bar"
-        end
-      MANIFEST
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should be able to use created class" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {
-        }
-
-        node default {
-          include foo
-        }
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do
-        end
-
-        node "default" do
-          use :foo
-        end
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should evaluate contents of the class when the class is used" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          notify {"bar": }
-        }
-
-        include foo
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do
-          notify "bar"
-        end
-
-        use :foo
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should be able to create class with arguments and use them" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo($param = "value") {}
-
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo, :arguments => {:param => "value"} do; end
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should be able to use class with arguments" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo($param = "value") {
-          notify {"$param": }
-        }
-
-        class {"foo": param => "bar"}
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo, :arguments => {:param => "value"} do
-          notify params[:param]
-        end
-
-        use :foo, :param => "bar"
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should be able to create class with arguments with default values" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo($param = "value") {
-          notify {"$param": }
-        }
-
-        class {"foo": param => "bar"}
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo, :arguments => {:param => "value"} do
-          notify params[:param]
-        end
-
-        use :foo, :param => "bar"
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should allow inheritance" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          notify {"foo": }
-        }
-
-        class bar inherits foo {
-          notify {"bar": }
-        }
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do
-          notify "foo"
-        end
-
-        hostclass :bar, :inherits => :foo do
-          notify "bar"
-        end
-
-        use :bar
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should allow inheritance with arguments" do
-      p = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          notify {"foo": }
-        }
-
-        class bar($msg) inherits foo {
-          notify {"bar": message => $msg}
-        }
-
-        class {"bar": msg => "foobarbaz"}
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        hostclass :foo do
-          notify "foo"
-        end
-
-        hostclass :bar, :inherits => :foo, :arguments => {:msg => nil} do
-          notify "bar", :message => params[:msg]
-        end
-
-        use "bar", :msg => "foobarbaz"
-      MANIFEST
-
-      r.should be_equivalent_to_catalog p
-    end
-
-  end
-end
-