devstructure 0.1.0 → 0.1.1

data/lib/devstructure/blueprint.rb

@@ -9,11 +9,11 @@ class DevStructure::Blueprint < Hash
   include DevStructure::Puppet
 
   def initialize(name, hash)
-    @name = name
-    self["name"] = name
     super nil
     clear
     hash.each { |k, v| self[k.to_s] = v }
+    @name = name
+    self["name"] = name
   end
 
   attr_accessor :name
@@ -44,7 +44,16 @@ class DevStructure::Blueprint < Hash
     other.walk(
       :package => lambda { |manager, command, package, version|
         return if b.packages[package]
-        b.packages[manager]["_packages"].delete package
+        versions = [b.packages[manager]["_packages"][package]].flatten
+        [version].flatten.each { |v| versions.delete v }
+        case versions.length
+        when 0
+          b.packages[manager]["_packages"].delete package
+        when 1
+          b.packages[manager]["_packages"][package] = versions.to_s
+        else
+          b.packages[manager]["_packages"][package] = versions
+        end
       }
     )
 
@@ -152,69 +161,79 @@ EOF
 
   def puppet
     disclaimer
-    puts "class #{@name} {"
-    puts Exec.defaults(:path => ENV["PATH"].split(":"))
+    manifest = Manifest.new(@name)
+    manifest << Exec.defaults(:path => ENV["PATH"].split(":"))
+
+    # Map managers to their manager.
+    managers = {}
+    walk(:package => lambda { |manager, command, package, version|
+      managers[package] = manager if packages[package] && manager != package
+    })
 
     # Packages.
     walk(
       :before => lambda { |manager, command|
         p = packages[manager]["_packages"]
         return if 0 == p.length || 1 == p.length && p[manager]
-        puts "\n\t# Packages that depend on #{manager}."
-        case manager
-        when /rubygems|rip/
-          puts "\tpackage {"
-        when /ruby|python/
-          puts "\texec {"
-        else
-          puts "\tpackage {"
-        end
       },
       :package => lambda { |manager, command, package, version|
         command =~ /gem(\d+\.\d+) install/
+        ruby_version = $1
         case manager
         when "apt"
           unless manager == package
-            puts Package.partial(package, :ensure => version)
+            manifest[manager] << Package.new(package, :ensure => version)
           end
         when "rubygems-update"
           unless manager == package
-            puts Package.partial(package,
-              :require => [Package["ruby#{$1}-dev"], Exec["update_rubygems"]],
+            manifest[manager] << Package.new(package,
+              :require => [
+                Puppet::Class[managers[manager]],
+                Package["ruby#{ruby_version}-dev"],
+                Exec["update_rubygems"],
+              ],
               :provider => :gem,
               :ensure => version
             )
           end
         when /rubygems|rip/
           options = {
-            :require => Package["rubygems#{$1}", "ruby#{$1}-dev"],
+            :require => [
+              Puppet::Class[managers[manager]],
+              Package["rubygems#{ruby_version}", "ruby#{ruby_version}-dev"],
+            ],
             :provider => :gem,
             :ensure => version
           }
           options[:require] += [Package[manager]] unless manager == package
-          puts Package.partial(package, options)
+          manifest[manager] << Package.new(package, options)
         when /python/
-          puts Exec.partial(sprintf("#{command}\n", package),
-            :require => Package[manager, "python-setuptools"]
+          manifest[manager] << Exec.new(sprintf("#{command}", package),
+            :require => [
+              Puppet::Class[managers[manager]],
+              Package[manager, "python-setuptools"],
+            ]
           )
 
         # TODO Expand Java, Erlang, etc.
 
         else
-          puts Exec.partial(sprintf("#{command}\n", package, version),
-            :require => Package[manager]
+          manifest[manager] << Exec.new(sprintf("#{command}", package,
+            version), :require => [
+              Puppet::Class[managers[manager]],
+              Package[manager],
+            ]
           )
         end
       },
       :after => lambda { |manager, command|
         p = packages[manager]["_packages"]
         return if 0 == p.length || 1 == p.length && manager == p.keys.first
-        puts "\t}"
 
         # Update RubyGems if we're through with gems in Debian's location.
         return unless manager =~ /^rubygems\d+\.\d+$/
         return unless p["rubygems-update"]
-        puts Exec.complete("update_rubygems",
+        manifest[manager] << Exec.new("update_rubygems",
           :subscribe => Package["rubygems-update"],
           :path => %w(/usr/bin /var/lib/gems/1.8/bin),
           :refreshonly => true
@@ -225,31 +244,29 @@ EOF
 
     # System files.
     if 0 < files.length
-      puts "\n\t# System files depend on all packages."
-      puts Package.defaults(
+      manifest << Package.defaults(
         :before => files.sort.map { |pathname, content|
           Puppet::File[pathname]
         }
       )
-      puts "\tfile {"
       files.sort.each do |pathname, content|
         if Hash == content.class
           if content["_target"]
-            puts Puppet::File.partial(pathname, :ensure => content["_target"])
+            manifest << Puppet::File.new(pathname,
+              :ensure => content["_target"])
             next
           elsif content["_base64"]
             content = Base64.decode64(content["_base64"])
           end
         end
-        puts Puppet::File.partial(pathname,
+        manifest << Puppet::File.new(pathname,
           :content => content,
           :ensure => :present
         )
       end
-      puts "\t}"
     end
 
-    puts "\n}"
+    puts manifest
   end
 
   def chef

data/lib/devstructure/puppet.rb

@@ -9,24 +9,58 @@ end
 
 module DevStructure::Puppet
 
-  # A generic Puppet resource to be subclassed.  The name of the class
-  # dictates how the resource will be printed so do not instantiate this
-  # class directly.
-  class Resource
+  # A Puppet manifest that contains a tree of classes that each contain
+  # some resources.
+  class Manifest
 
-    # A resource that will (by default) provide its complete representation.
-    def self.complete(name, options={})
-      self.new name, :complete, options
+    def initialize(name, parent=nil)
+      @name, @parent = name, parent
+      @manifests, @resources = {}, []
     end
 
-    # A resource that will (by default) provide its partial representation.
-    def self.partial(name, options={})
-      self.new name, :partial, options
+    # Return a reference to a sub-manifest of the given name.
+    def [](name)
+      @manifests[name.to_s] ||= self.class.new(name.to_s, @name)
+    end
+    def method_missing(symbol, *args)
+      self[symbol]
     end
 
-    # A resource that will provide defaults for its resource type.
-    def self.defaults(options={})
-      self.new "", :defaults, options
+    # Add a resource to this manifest.
+    def <<(resource)
+      @resources << resource
+    end
+
+    def to_s(tab="")
+      out = []
+      out << "#{tab}class #{@name.gsub(".", "--")} {"
+      @manifests.each_value do |manifest|
+        out << manifest.to_s("#{tab}\t")
+      end
+      @resources.each do |resource|
+        out << resource.to_s("#{tab}\t")
+      end
+      out << "#{tab}}"
+      out << "#{tab}include #{@name.gsub(".", "--")}" if @parent
+      out.join("\n")
+    end
+
+  end
+
+  # A generic Puppet resource to be subclassed.  The name of the class
+  # dictates how the resource will be printed so do not instantiate this
+  # class directly.
+  class Resource < Hash
+    attr_accessor :type, :name, :style
+
+    # A resource.
+    def initialize(name, options={})
+      super nil
+      clear
+      options.each { |k, v| self[k.to_s] = v }
+      @type = self.class.to_s.downcase[/[^:]+$/]
+      @name = name.to_s.downcase
+      @style = :complete
     end
 
     # A resource with only a name, typically being listed as a dependency.
@@ -34,46 +68,52 @@ module DevStructure::Puppet
     # will be generated.
     def self.[](*args)
       if 1 == args.length
-        self.new args[0], :complete
+        self.new args[0]
       else
         args.collect { |arg| self[arg] }
       end
     end
 
+    # A set of defaults for a resource type.
+    def self.defaults(options)
+      resource = self.new(nil, options)
+      resource.style = :defaults
+      resource
+    end
+
     # Return Puppet code for this resource.  Whether a complete, partial,
     # or defaults representation is returned depends on which class method
     # instantiated this resource but can be overridden by passing a Symbol.
-    def to_s(style=nil)
-      style ||= @style
+    def to_s(tab="")
       out = []
 
       # Settle on the indentation level for the rest of the resource.
       # Raise an exception if the style is invalid.
-      tab = case style
+      tab_params = case @style
       when :complete
-        out << "\t#{@type} { \"#{@name}\":"
-        "\t"
+        out << "#{tab}#{@type} { \"#{@name}\":"
+        "#{tab}"
       when :partial
-        out << "\t\t\"#{@name}\":"
-        "\t\t"
+        out << "#{tab}\t\"#{@name}\":"
+        "#{tab}\t"
       when :defaults
-        out << "\t#{@type.capitalize} {"
-        "\t"
+        out << "#{tab}#{@type.capitalize} {"
+        "#{tab}"
       else
         raise ArgumentError
       end
 
       # Handle the options Hash.
-      if 0 < @options.length
+      if 0 < length
 
         # Note the longest option name so we can line up => operators as
         # per the Puppet coding standards.
-        l = @options.collect { |k, v| k.to_s.length }.max
+        l = collect { |k, v| k.to_s.length }.max
 
         # Map options to Puppet code strings.  Symbols become unquoted
         # strings, nils become undefs, and Arrays are flattened.  Unless
         # the value is a Symbol, #inspect is called on the value.
-        out += @options.sort.collect do |k, v|
+        out += sort.collect do |k, v|
           k = "#{k.to_s}#{" " * (l - k.to_s.length)}"
           v = if v.respond_to?(:flatten)
             if 1 == v.length
@@ -86,23 +126,23 @@ module DevStructure::Puppet
           end
           v = :undef if v.nil?
           v = v.inspect.gsub(/\$/, "\\$") unless Symbol == v.class
-          "\t#{tab}#{k} => #{v},"
+          "\t#{tab_params}#{k} => #{v},"
         end
 
         # Close this resource.
-        case style
+        case @style
         when :complete
-          out << "\t}"
+          out << "#{tab}}"
         when :partial
           out << "#{out.pop.chop};"
         when :defaults
-          out << "\t}"
+          out << "#{tab}}"
         end
 
       # Don't bother with an empty options Hash.  Go ahead and close this
       # resource.
       else
-        case style
+        case @style
         when :complete
           out << "#{out.pop} }"
         when :partial
@@ -120,15 +160,9 @@ module DevStructure::Puppet
     def inspect
       "#{@type.capitalize}[\"#{@name}\"]"
     end
-
-    # A resource with a name and default representation.
-    def initialize(name, style, options={})
-      @type = self.class.to_s.downcase[/[^:]+$/]
-      @name = name.to_s.downcase
-      @style = style.to_sym
-      @options = options
+    def pretty_print(pp)
+      pp.text inspect
     end
-    private :initialize
 
   end
 
@@ -140,4 +174,11 @@ module DevStructure::Puppet
   class File < Resource
   end
 
+  # A class resource type for dependencies.
+  class Class < Resource
+    def inspect
+      "#{@type.capitalize}[\"#{@name.gsub(".", "--")}\"]"
+    end
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: devstructure
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Richard Crowley