puppet 0.24.1 → 0.24.2

data/lib/puppet/external/gratr/strong_components.rb

@@ -1,127 +0,0 @@
-#--
-# Copyright (c) 2006 Shawn Patrick Garbett
-# 
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-# 
-#     * Redistributions of source code must retain the above copyright notice(s),
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright notice,
-#       this list of conditions and the following disclaimer in the documentation
-#       and/or other materials provided with the distribution.
-#     * Neither the name of the Shawn Garbett nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#++
-
-
-require 'set'
-
-module GRATR
-  module Graph
-    module StrongComponents
-      # strong_components computes the strongly connected components
-      # of a graph using Tarjan's algorithm based on DFS. See: Robert E. Tarjan
-      # _Depth_First_Search_and_Linear_Graph_Algorithms_. SIAM Journal on 
-      # Computing, 1(2):146-160, 1972
-      #
-      # The output of the algorithm is an array of components where is 
-      # component is an array of vertices
-      #
-      # A strongly connected component of a directed graph G=(V,E) is a maximal
-      # set of vertices U which is in V such that for every pair of 
-      # vertices u and v in U, we have both a path from u to v 
-      # and path from v to u. That is to say that u and v are reachable 
-      # from each other.
-      #
-      def strong_components
-
-        dfs_num    = 0
-        stack = []; result = []; root = {}; comp = {}; number = {}
-
-        # Enter vertex callback
-        enter = Proc.new do |v| 
-          root[v] = v
-          comp[v] = :new
-          number[v] = (dfs_num += 1)
-          stack.push(v)
-        end
-
-        # Exit vertex callback
-        exit  = Proc.new do |v|
-          adjacent(v).each do |w|
-            if comp[w] == :new
-              root[v] = (number[root[v]] < number[root[w]] ? root[v] : root[w])
-            end
-          end
-          if root[v] == v
-            component = []
-            begin
-              w = stack.pop
-              comp[w] = :assigned
-              component << w
-            end until w == v
-            result << component
-          end
-        end
-
-        # Execute depth first search
-        dfs({:enter_vertex => enter, :exit_vertex => exit}); result
-
-      end # strong_components
-      
-      # Returns a condensation graph of the strongly connected components
-      # Each node is an array of nodes from the original graph
-      def condensation
-        sc  = strong_components
-        cg  = self.class.new
-        map = sc.inject({}) do |a,c| 
-          c.each {|v| a[v] = c }; a
-        end
-        sc.each do |c|
-          c.each do |v|
-            adjacent(v).each {|v| cg.add_edge!(c, map[v]) unless c == map[v]}
-          end
-        end; cg
-      end
-
-      # Compute transitive closure of a graph. That is any node that is reachable
-      # along a path is added as a directed edge.
-      def transitive_closure!
-        cgtc = condensation.gratr_inner_transitive_closure!
-        cgtc.each do |cgv|
-          cgtc.adjacent(cgv).each do |adj|
-            cgv.each do |u| 
-              adj.each {|v| add_edge!(u,v)}  
-            end
-          end
-        end; self
-      end
-
-      # This returns the transitive closure of a graph. The original graph
-      # is not changed.
-      def transitive_closure() self.class.new(self).transitive_closure!; end
-
-     private
-      def gratr_inner_transitive_closure!  # :nodoc:
-        topsort.reverse.each do |u| 
-          adjacent(u).each do |v|
-            adjacent(v).each {|w| add_edge!(u,w) unless edge?(u,w)}
-          end
-        end; self
-      end
-    end # StrongComponens
-    
-  end # Graph
-end # GRATR

data/lib/puppet/external/gratr/undirected_graph.rb

@@ -1,153 +0,0 @@
-#--
-# Copyright (c) 2006 Shawn Patrick Garbett
-# Copyright (c) 2002,2004,2005 by Horst Duchene
-# 
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-# 
-#     * Redistributions of source code must retain the above copyright notice(s),
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright notice,
-#       this list of conditions and the following disclaimer in the documentation
-#       and/or other materials provided with the distribution.
-#     * Neither the name of the Shawn Garbett nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#++
-
-
-require 'puppet/external/gratr/adjacency_graph'
-require 'puppet/external/gratr/search'
-require 'puppet/external/gratr/biconnected'
-require 'puppet/external/gratr/comparability'
-require 'set'
-
-module GRATR
-  class UndirectedGraph
-    include AdjacencyGraph
-    include Graph::Search
-    include Graph::Biconnected
-    include Graph::Comparability
-    
-    def initialize(*params)
-      raise ArgumentError if params.any? do |p| 
-       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
-      end if self.class == GRATR::UndirectedGraph
-      super(*params)
-    end 
-
-    # UndirectedGraph is by definition undirected, always returns false
-    def directed?()  false; end
-      
-    # Redefine degree (default was sum)
-    def degree(v)    in_degree(v); end
-      
-    # A vertex of an undirected graph is balanced by definition
-    def balanced?(v)  true;  end
-
-    # UndirectedGraph uses UndirectedEdge for the edge class.
-    def edge_class() @parallel_edges ? GRATR::MultiUndirectedEdge : GRATR::UndirectedEdge; end
-
-    def remove_edge!(u, v=nil)
-      unless u.kind_of? GRATR::Edge
-        raise ArgumentError if @parallel_edges 
-        u = edge_class[u,v]
-      end
-      super(u.reverse) unless u.source == u.target
-      super(u)
-    end
-    
-    # A triangulated graph is an undirected perfect graph that every cycle of length greater than
-    # three possesses a chord. They have also been called chordal, rigid circuit, monotone transitive,
-    # and perfect elimination graphs.
-    #
-    # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
-    # Perfect Graphs" pg. 90
-    def triangulated?
-      a = Hash.new {|h,k| h[k]=Set.new}; sigma=lexicograph_bfs
-      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
-      sigma[0..-2].each do |v|
-        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
-        unless x.empty?
-           u = sigma[x.map {|y| inv_sigma[y]}.min]
-           a[u].merge(x - [u])
-        end
-        return false unless a[v].all? {|z| adjacent?(v,z)}
-      end
-      true
-    end
-    
-    def chromatic_number
-      return triangulated_chromatic_number if triangulated?
-      raise NotImplementedError    
-    end
-    
-    # An interval graph can have its vertices into one-to-one
-    # correspondence with a set of intervals F of a linearly ordered
-    # set (like the real line) such that two vertices are connected
-    # by an edge of G if and only if their corresponding intervals
-    # have nonempty intersection.
-    def interval?() triangulated? and complement.comparability?; end
-    
-    # A permutation diagram consists of n points on each of two parallel
-    # lines and n straight line segments matchin the points. The intersection
-    # graph of the line segments is called a permutation graph.
-    def permutation?() comparability? and complement.comparability?; end
-    
-    # An undirected graph is defined to be split if there is a partition
-    # V = S + K of its vertex set into a stable set S and a complete set K.    
-    def split?() triangulated? and complement.triangulated?; end
-    
-   private
-   # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
-   # Perfect Graphs" pg. 99
-    def triangulated_chromatic_number
-      chi = 1; s= Hash.new {|h,k| h[k]=0}
-      sigma=lexicograph_bfs
-      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
-      sigma.each do |v|
-        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
-        unless x.empty?
-          u = sigma[x.map {|y| inv_sigma[y]}.min]
-          s[u] = [s[u], x.size-1].max
-          chi = [chi, x.size+1].max if s[v] < x.size
-        end
-      end; chi
-    end
-   
-  end # UndirectedGraph
-
-  # This is a UndirectedGraph that allows for parallel edges, but does not
-  # allow loops
-  class UndirectedPseudoGraph < UndirectedGraph
-    def initialize(*params)
-      raise ArgumentError if params.any? do |p| 
-       !(p.kind_of? Graph or p.kind_of? Array)
-      end
-      super(:parallel_edges, *params)
-    end 
-  end
-
-  # This is a UndirectedGraph that allows for parallel edges and loops
-  class UndirectedMultiGraph < UndirectedGraph
-    def initialize(*params)
-      raise ArgumentError if params.any? do |p| 
-       !(p.kind_of? Graph or p.kind_of? Array)
-      end
-      super(:parallel_edges, :loops, *params)
-    end 
-  end
-
-
-end # GRATR

data/lib/puppet/rails/external/tagging/acts_as_taggable.rb

@@ -1,62 +0,0 @@
-module ActiveRecord
-  module Acts #:nodoc:
-    module Taggable #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)  
-      end
-      
-      module ClassMethods
-        def acts_as_taggable(options = {})
-          write_inheritable_attribute(:acts_as_taggable_options, {
-            :taggable_type => ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s,
-            :from => options[:from]
-          })
-          
-          class_inheritable_reader :acts_as_taggable_options
-
-          has_many :taggings, :as => :taggable, :dependent => :destroy
-          has_many :tags, :through => :taggings
-
-          include ActiveRecord::Acts::Taggable::InstanceMethods
-          extend ActiveRecord::Acts::Taggable::SingletonMethods          
-        end
-      end
-      
-      module SingletonMethods
-        def find_tagged_with(list)
-          find_by_sql([
-            "SELECT #{table_name}.* FROM #{table_name}, tags, taggings " +
-            "WHERE #{table_name}.#{primary_key} = taggings.taggable_id " +
-            "AND taggings.taggable_type = ? " +
-            "AND taggings.tag_id = tags.id AND tags.name IN (?)",
-            acts_as_taggable_options[:taggable_type], list
-          ])
-        end
-        def tags(options = {})
-          options.merge!(:taggable_type => self.to_s)
-          Tag.tags(options)
-        end
-      end
-      
-      module InstanceMethods
-        def tag_with(list)
-          Tag.transaction do
-            taggings.destroy_all
-
-            Tag.parse(list).each do |name|
-              if acts_as_taggable_options[:from]
-                send(acts_as_taggable_options[:from]).tags.find_or_create_by_name(name).on(self)
-              else
-                Tag.find_or_create_by_name(name).on(self)
-              end
-            end
-          end
-        end
-
-        def tag_list
-          tags.collect { |tag| tag.name.include?(" ") ? "'#{tag.name}'" : tag.name }.join(" ")
-        end
-      end
-    end
-  end
-end

data/lib/puppet/rails/external/tagging/init.rb

@@ -1,5 +0,0 @@
-require 'puppet/rails/external/tagging/acts_as_taggable'
-ActiveRecord::Base.send(:include, ActiveRecord::Acts::Taggable)
-
-require 'puppet/rails/external/tagging/tagging'
-require 'puppet/rails/external/tagging/tag'

data/lib/puppet/rails/external/tagging/tag.rb

@@ -1,50 +0,0 @@
-class Tag < ActiveRecord::Base
-  has_many :taggings
-
-  def self.tags(options = {})
-    query = "select tags.id, name, count(*) as count"
-    query << " from taggings, tags"
-    query << " where tags.id = tag_id"
-    query << " group by tag_id"
-    query << " order by #{options[:order]}" if options[:order] != nil
-    query << " limit #{options[:limit]}" if options[:limit] != nil
-    tags = Tag.find_by_sql(query)
-  end
-
-  def self.parse(list)
-    tag_names = []
-
-    # first, pull out the quoted tags
-    list.gsub!(/\"(.*?)\"\s*/ ) { tag_names << $1; "" }
-
-    # then, replace all commas with a space
-    list.gsub!(/,/, " ")
-
-    # then, get whatever's left
-    tag_names.concat list.split(/\s/)
-
-    # strip whitespace from the names
-    tag_names = tag_names.map { |t| t.strip }
-
-    # delete any blank tag names
-    tag_names = tag_names.delete_if { |t| t.empty? }
-    
-    return tag_names
-  end
-
-  def tagged
-    @tagged ||= taggings.collect { |tagging| tagging.taggable }
-  end
-  
-  def on(taggable)
-    taggings.build :taggable => taggable
-  end
-  
-  def ==(comparison_object)
-    super || name == comparison_object.to_s
-  end
-  
-  def to_s
-    name
-  end
-end

data/lib/puppet/rails/external/tagging/tagging.rb

@@ -1,12 +0,0 @@
-class Tagging < ActiveRecord::Base
-  belongs_to :tag
-  belongs_to :taggable, :polymorphic => true
-
-  def self.tagged_class(taggable)
-    ActiveRecord::Base.send(:class_name_of_active_record_descendant, taggable.class).to_s
-  end
-  
-  def self.find_taggable(tagged_class, tagged_id)
-    tagged_class.constantize.find(tagged_id)
-  end
-end

data/lib/puppet/rails/puppet_class.rb

@@ -1,6 +0,0 @@
-class Puppet::Rails::PuppetClass < ActiveRecord::Base
-    has_many :resources
-    has_many :source_files
-    has_many :hosts
-end
-

data/lib/puppet/reference/node_source.rb

@@ -1,9 +0,0 @@
-require 'puppet/node'
-
-noderef = Puppet::Util::Reference.newreference :node_source, :doc => "Sources of node configuration information" do
-    Puppet::Network::Handler.node.docs
-end
-
-noderef.header = "
-Nodes can be searched for in different locations.  This document describes those different locations.
-"

data/lib/puppet/reference/report.rb

@@ -1,21 +0,0 @@
-report = Puppet::Util::Reference.newreference :report, :doc => "All available transaction reports" do
-    Puppet::Network::Handler.report.reportdocs
-end
-
-report.header = "
-Puppet clients can report back to the server after each transaction.  This
-transaction report is sent as a YAML dump of the
-``Puppet::Transaction::Report`` class and includes every log message that was
-generated during the transaction along with as many metrics as Puppet knows how
-to collect.  See `ReportsAndReporting Reports and Reporting`:trac:
-for more information on how to use reports.
-
-Currently, clients default to not sending in reports; you can enable reporting
-by setting the ``report`` parameter to true.
-
-To use a report, set the ``reports`` parameter on the server; multiple
-reports must be comma-separated.  You can also specify ``none`` to disable
-reports entirely.
-
-Puppet provides multiple report handlers that will process client reports:
-"