Removing old, never-used DSL code

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

2 files changed, 0 insertions, 490 deletions

diff --git a/lib/puppet/dsl.rb b/lib/puppet/dsl.rb
deleted file mode 100644
index ca01a9c42..000000000
--- a/lib/puppet/dsl.rb
+++ /dev/null
@@ -1,275 +0,0 @@
-# Just quick mess-around to see what a DSL would look like.
-#
-# This is what the executable could look like:
-##!/usr/bin/env ruby
-#
-#require 'puppet'
-#require 'puppet/dsl'
-#
-#Puppet::DSL.import(ARGV[0])
-#
-#bucket = Puppet::TransBucket.new
-#bucket.type = "top"
-#bucket.keyword = "class"
-#
-#Puppet::DSL.find_all do |name, sub|
-#    sub.included
-#end.each do |name, sub|
-#    bucket.push sub.export
-#end
-#
-#puts bucket.to_manifest
-#
-# And here's what an example config could look like:
-#
-
-##!/usr/bin/env ruby
-#
-#
-# require 'puppet'
-# require 'puppet/dsl'
-#
-# include Puppet::DSL
-# init()
-#
-# aspect :webserver do
-#     file "/tmp/testone", :content => "yaytest"
-#
-#     exec "testing", :command => "/bin/echo this is a test"
-# end
-#
-# aspect :other, :inherits => :webserver do
-#     file "/tmp/testone", :mode => "755"
-# end
-#
-# acquire :other
-#
-# apply
-
-require 'puppet'
-
-# Provide the actual commands for acting like a language.
-module Puppet::DSL
-    def aspect(name, options = {}, &block)
-        Puppet::DSL::Aspect.new(name, options, &block)
-    end
-
-    def acquire(*names)
-        names.each do |name|
-            if aspect = Puppet::DSL::Aspect[name]
-                unless aspect.evaluated?
-                    aspect.evaluate
-                end
-            else
-                raise "Could not find aspect %s" % name
-            end
-        end
-    end
-
-    def apply
-        bucket = export()
-        catalog = bucket.to_catalog
-        catalog.apply
-    end
-
-    def export
-        objects = Puppet::DSL::Aspect.collect do |name, aspect|
-            if aspect.evaluated?
-                aspect.export
-            end
-        end.reject { |a| a.nil? }.flatten.collect do |obj|
-            obj.to_trans
-        end
-        bucket = Puppet::TransBucket.new(objects)
-        bucket.name = "top"
-        bucket.type = "class"
-
-        return bucket
-    end
-
-    def init
-        unless Process.uid == 0
-            Puppet[:confdir] = File.expand_path("~/.puppet")
-            Puppet[:vardir] = File.expand_path("~/.puppet/var")
-        end
-        Puppet[:user] = Process.uid
-        Puppet[:group] = Process.gid
-        Puppet::Util::Log.newdestination(:console)
-        Puppet::Util::Log.level = :info
-    end
-
-    class Aspect
-        Resource = Puppet::Parser::Resource
-
-        include Puppet::Util
-        include Puppet::DSL
-        extend Puppet::Util
-        extend Enumerable
-        attr_accessor :parent, :name, :evaluated
-
-        @aspects = {}
-
-        @@objects = Hash.new do |hash, key|
-            hash[key] = {}
-        end
-
-        # Create an instance method for every type
-        Puppet::Type.loadall
-        Puppet::Type.eachtype do |type|
-            define_method(type.name) do |*args|
-                newresource(type, *args)
-            end
-        end
-
-        def self.[]=(name, aspect)
-            name = symbolize(name)
-            @aspects[name] = aspect
-        end
-
-        def self.[](name)
-            name = symbolize(name)
-
-            # Make sure there's always a main.  This can get deleted in testing.
-            if name == :main and ! @aspects[name]
-                new(:main) {}
-            end
-            @aspects[name]
-        end
-
-        def self.clear
-            @aspects.clear
-            @@objects.clear
-        end
-
-        def self.delete(name)
-            name = symbolize(name)
-            if @aspects.has_key?(name)
-                @aspects.delete(name)
-            end
-        end
-
-        def self.each
-            @aspects.each do |name, a|
-                yield name, a
-            end
-        end
-
-        def child_of?(aspect)
-            unless aspect.is_a?(self.class)
-                obj = self.class[aspect]
-                unless obj
-                    raise "Could not find aspect %s" % aspect
-                end
-                aspect = obj
-            end
-            if self.parent
-                if self.parent == aspect
-                    return true
-                elsif self.parent.child_of?(aspect)
-                    return true
-                else
-                    return false
-                end
-            else
-                return false
-            end
-        end
-
-        def evaluate
-            if self.parent and ! self.parent.evaluated?
-                self.parent.evaluate
-            end
-
-            unless evaluated?
-                if defined? @block
-                    instance_eval(&@block)
-                end
-                @evaluated = true
-            end
-        end
-
-        def evaluated?
-            if self.evaluated
-                true
-            else
-                false
-            end
-        end
-
-        def export
-            @resources.dup
-        end
-
-        def initialize(name, options = {}, &block)
-            name = symbolize(name)
-            @name = name
-            if block
-                @block = block
-            end
-            if pname = options[:inherits]
-                if pname.is_a?(self.class)
-                    @parent = pname
-                elsif parent = self.class[pname]
-                    @parent = parent
-                else
-                    raise "Could not find parent aspect %s" % pname
-                end
-            end
-
-            @resources = []
-
-            self.class[name] = self
-        end
-
-        def newresource(type, name, params = {})
-            if self.is_a?(Puppet::DSL::Aspect)
-                source = self
-            else
-                source = Puppet::DSL::Aspect[:main]
-            end
-            unless obj = @@objects[type][name]
-                obj = Resource.new :title => name, :type => type.name,
-                    :source => source, :scope => scope
-                @@objects[type][name] = obj
-
-                @resources << obj
-            end
-
-            params.each do |name, value|
-                param = Resource::Param.new(
-                    :name => name,
-                    :value => value,
-                    :source => source
-                )
-
-                obj.send(:set_parameter, param)
-            end
-
-            obj
-        end
-
-        def scope
-            unless defined?(@scope)
-                # Set the code to something innocuous; we just need the
-                # scopes, not the interpreter.  Hackish, but true.
-                Puppet[:code] = " "
-                @interp = Puppet::Parser::Interpreter.new
-                require 'puppet/node'
-                @node = Puppet::Node.new(Facter.value(:hostname))
-                if env = Puppet[:environment] and env == ""
-                    env = nil
-                end
-                @node.parameters = Facter.to_hash
-                @compile = Puppet::Parser::Compiler.new(@node, @interp.send(:parser, env))
-                @scope = @compile.topscope
-            end
-            @scope
-        end
-
-        def type
-            self.name
-        end
-    end
-end
-
-@aspects = {}
diff --git a/test/other/dsl.rb b/test/other/dsl.rb
deleted file mode 100755
index deafca791..000000000
--- a/test/other/dsl.rb
+++ /dev/null
@@ -1,215 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/dsl'
-require 'puppettest'
-
-class TestDSL < Test::Unit::TestCase
-    include PuppetTest
-    include Puppet::DSL
-
-    def teardown
-        super
-        Puppet::DSL::Aspect.clear
-    end
-
-    def test_aspect
-        a = nil
-        assert_nothing_raised do
-            a = aspect :yaytest do
-            end
-        end
-
-        assert_equal(a, Puppet::DSL::Aspect[:yaytest])
-
-        # Now make a child aspect
-        b = nil
-        assert_nothing_raised do
-            b = aspect :child, :inherits => :yaytest do
-            end
-        end
-
-        assert(b.child_of?(a), "Parentage not set up correctly")
-        assert(b.child_of?(:yaytest), "Parentage not set up for symbols")
-
-        # Now make another subclass
-        c = nil
-        assert_nothing_raised do
-            c = aspect :kid, :inherits => :child do
-            end
-        end
-
-        assert(c.child_of?(b), "Parentage not set up correctly")
-        assert(c.child_of?(a), "Parentage is not inherited")
-
-        # Lastly, make a separate aspect
-        x = nil
-        assert_nothing_raised do
-            x = aspect :other do
-            end
-        end
-
-        assert(! x.child_of?(a), "Parentage came from nowhere")
-        assert(! x.child_of?(b), "Parentage came from nowhere")
-        assert(! x.child_of?(c), "Parentage came from nowhere")
-
-        # Make sure we can specify the name or the aspect
-        y = nil
-        assert_nothing_raised do
-            x = aspect :naming, :inherits => a do
-            end
-        end
-        assert(x.child_of?(a), "Parentage not set up correctly")
-
-        # And make sure the parent must exist
-        z = nil
-        assert_raise(RuntimeError) do
-            z = aspect :noparent, :inherits => :nosuchaspect do
-            end
-        end
-        assert(x.child_of?(a), "Parentage not set up correctly")
-    end
-
-    def test_evaluate
-        parent = child = nil
-        parenteval = childeval = nil
-
-        assert_nothing_raised do
-            parent = aspect :parent do
-                if parenteval
-                    raise "parent already evaluated"
-                end
-                parenteval = true
-            end
-
-            child = aspect :child, :inherits => parent do
-                if childeval
-                    raise "child already evaluated"
-                end
-                childeval = true
-            end
-        end
-
-        assert_nothing_raised do
-            parent.evaluate()
-        end
-
-        assert(parenteval, "Parent was not evaluated")
-        assert(parent.evaluated?, "parent was not considered evaluated")
-
-        # Make sure evaluating twice silently does nothing
-        assert_nothing_raised do
-            parent.evaluate()
-        end
-
-        # Now evaluate the child
-        assert_nothing_raised do
-            child.evaluate
-        end
-
-        assert(childeval, "child was not evaluated")
-        assert(child.evaluated?, "child was not considered evaluated")
-
-        # Now reset them both
-        parenteval = childeval = nil
-        parent.evaluated = false
-        child.evaluated = false
-
-        # evaluate the child
-        assert_nothing_raised do
-            child.evaluate
-        end
-
-        # and make sure both get evaluated
-        assert(parenteval, "Parent was not evaluated")
-        assert(parent.evaluated?, "parent was not considered evaluated")
-        assert(childeval, "child was not evaluated")
-        assert(child.evaluated?, "child was not considered evaluated")
-    end
-
-    def test_acquire
-        evalled = false
-        a = aspect :test do
-            evalled = true
-        end
-
-        assert_nothing_raised do
-            acquire :test
-        end
-
-        assert(evalled, "Did not evaluate aspect")
-
-        assert_nothing_raised do
-            acquire :test
-        end
-    end
-
-    def test_newresource
-        filetype = Puppet::Type.type(:file)
-        path = tempfile()
-
-        a = aspect :testing
-
-        resource = nil
-        assert_nothing_raised do
-            resource = a.newresource filetype, path, :content => "yay", :mode => "640"
-        end
-
-        assert_instance_of(Puppet::Parser::Resource, resource)
-
-        assert_equal("yay", resource[:content])
-        assert_equal("640", resource[:mode])
-        assert_equal(:testing, resource.source.name)
-
-        # Now try exporting our aspect
-        assert_nothing_raised do
-            a.evaluate
-        end
-
-        result = nil
-        assert_nothing_raised do
-            result = a.export
-        end
-
-        assert_equal([resource], result)
-
-        # Then try the DSL export
-        assert_nothing_raised do
-            result = export
-        end
-
-        assert_instance_of(Puppet::TransBucket, result)
-
-        # And just for kicks, test applying everything
-        assert_nothing_raised do
-            apply()
-        end
-
-        assert(FileTest.exists?(path), "File did not get created")
-        assert_equal("yay", File.read(path))
-    end
-
-    def test_typemethods
-        Puppet::Type.loadall
-        filetype = Puppet::Type.type(:file)
-        path = tempfile()
-
-        a = aspect :testing
-
-        Puppet::Type.eachtype do |type|
-            next if type.name.to_s =~ /test/
-            assert(a.respond_to?(type.name),
-                "Aspects do not have a %s method" % type.name)
-        end
-
-        file = nil
-        assert_nothing_raised do
-            file = a.file path,
-                :content => "yay", :mode => "640"
-        end
-
-        assert_instance_of(Puppet::Parser::Resource, file)
-    end
-end