runa-chef 0.8.0.1

data/lib/chef/config.rb

@@ -0,0 +1,195 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'chef/log'
+require 'mixlib/config'
+
+class Chef
+  class Config
+
+    extend Mixlib::Config
+
+    # Manages the chef secret session key
+    # === Returns
+    # <newkey>:: A new or retrieved session key
+    #
+    def self.manage_secret_key
+      newkey = nil
+      if Chef::FileCache.has_key?("chef_server_cookie_id")
+        newkey = Chef::FileCache.load("chef_server_cookie_id")
+      else
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        newkey = ""
+        40.times { |i| newkey << chars[rand(chars.size-1)] }
+        Chef::FileCache.store("chef_server_cookie_id", newkey)
+      end
+      newkey
+    end
+
+
+    # Override the config dispatch to set the value of multiple server options simultaneously
+    # 
+    # === Parameters
+    # url<String>:: String to be set for all of the chef-server-api URL's
+    #
+    config_attr_writer :chef_server_url do |url|
+      configure do |c|
+        [ :registration_url,
+          :openid_url,
+          :template_url,
+          :remotefile_url,
+          :search_url,
+          :chef_server_url,
+          :role_url ].each do |u| 
+            c[u] = url
+        end
+      end
+      url
+    end
+
+    # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel.  
+    # So while this is basically identical to what method_missing would do, we pull
+    # it up here and get a real method written so that things get dispatched 
+    # properly.
+    config_attr_writer :daemonize do |v|
+      configure do |c|
+        c[:daemonize] = v
+      end
+    end
+
+    # Override the config dispatch to set the value of log_location configuration option
+    #
+    # === Parameters
+    # location<IO||String>:: Logging location as either an IO stream or string representing log file path
+    #
+    config_attr_writer :log_location do |location|
+      if location.respond_to? :sync=
+        location
+      elsif location.respond_to? :to_str
+        File.new(location.to_str, "a")
+      end
+    end
+
+    # Override the config dispatch to set the value of authorized_openid_providers when openid_providers (deprecated) is used
+    #
+    # === Parameters
+    # providers<Array>:: An array of openid providers that are authorized to login to the chef server
+    #
+    config_attr_writer :openid_providers do |providers|
+      configure { |c| c[:authorized_openid_providers] = providers }
+      providers
+    end
+
+    authorized_openid_identifiers nil
+    authorized_openid_providers nil
+    cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
+    cookbook_tarball_path "/var/chef/cookbook-tarballs"
+    couchdb_database "chef"
+    couchdb_url "http://localhost:5984"
+    couchdb_version nil
+    delay 0
+    executable_path ENV['PATH'] ? ENV['PATH'].split(File::PATH_SEPARATOR) : []
+    file_cache_path "/var/chef/cache"
+    file_backup_path nil
+    group nil
+    http_retry_count 5
+    http_retry_delay 5
+    interval nil
+    json_attribs nil
+    log_level :info
+    log_location STDOUT
+    node_name nil
+    node_path "/var/chef/node"
+    openid_cstore_couchdb false
+    openid_cstore_path "/var/chef/openid/cstore"    
+    openid_providers nil
+    openid_store_couchdb false
+    openid_store_path "/var/chef/openid/db"
+    openid_url "http://localhost:4001"
+    pid_file nil
+    queue_host "localhost"
+    queue_password ""
+    queue_port 61613
+    queue_retry_count 5
+    queue_retry_delay 5
+    queue_user ""
+    chef_server_url "http://localhost:4000"
+    registration_url "http://localhost:4000"
+    client_url "http://localhost:4042"
+    remotefile_url "http://localhost:4000"
+    rest_timeout 60
+    run_command_stderr_timeout 120
+    run_command_stdout_timeout 120
+    search_index_path "/var/chef/search_index"
+    search_url "http://localhost:4000"
+    solo  false
+    splay nil
+    ssl_client_cert ""
+    ssl_client_key ""
+    ssl_verify_mode :verify_none
+    ssl_ca_path nil
+    ssl_ca_file nil
+    template_url "http://localhost:4000"
+    umask 0022
+    user nil
+    validation_token nil
+    role_path "/var/chef/roles"
+    role_url "http://localhost:4000"
+    recipe_url nil
+    solr_url "http://localhost:8983"
+    solr_jetty_path "/var/chef/solr-jetty"
+    solr_data_path "/var/chef/solr/data"
+    solr_home_path "/var/chef/solr"
+    solr_heap_size "256M"
+    solr_java_opts nil
+    nanite_host '0.0.0.0'
+    nanite_port '5672'
+    nanite_user 'nanite'
+    nanite_pass 'testing'
+    nanite_vhost '/nanite'
+    nanite_identity nil
+    nanite_persistent_mapper false
+
+    client_key "/etc/chef/client.pem"
+    validation_key "/etc/chef/validation.pem"
+    validation_client_name "chef-validator"
+    web_ui_client_name "chef-webui"
+    web_ui_key "/etc/chef/webui.pem"
+    web_ui_admin_user_name  "admin"
+    web_ui_admin_default_password "p@ssw0rd1"
+
+    # Server Signing CA
+    #
+    # In truth, these don't even have to change
+    signing_ca_cert "/var/chef/ca/cert.pem"
+    signing_ca_key "/var/chef/ca/key.pem"
+    signing_ca_country "US"
+    signing_ca_state "Washington"
+    signing_ca_location "Seattle"
+    signing_ca_org "Chef User"
+    signing_ca_domain "opensource.opscode.com"
+    signing_ca_email "opensource-cert@opscode.com"
+
+    # Checksum Cache
+    # Uses Moneta on the back-end
+    cache_type "BasicFile"
+    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+
+  end
+end

data/lib/chef/cookbook.rb

@@ -0,0 +1,198 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'chef/log'
+require 'chef/node'
+require 'chef/resource_definition'
+require 'chef/recipe'
+require 'chef/mixin/convert_to_class_name'
+
+class Chef
+  class Cookbook
+    include Chef::Mixin::ConvertToClassName
+    
+    attr_accessor :definition_files, :template_files, :remote_files, 
+                  :lib_files, :resource_files, :provider_files, :name
+    attr_reader :recipe_files, :attribute_files
+    
+    # Creates a new Chef::Cookbook object.  
+    #
+    # === Returns
+    # object<Chef::Cookbook>:: Duh. :)
+    def initialize(name)
+      @name = name
+      @attribute_files = Array.new
+      @attribute_names = Hash.new
+      @definition_files = Array.new
+      @template_files = Array.new
+      @remote_files = Array.new
+      @recipe_files = Array.new
+      @recipe_names = Hash.new
+      @lib_files = Array.new
+      @resource_files = Array.new
+      @provider_files = Array.new
+    end
+    
+    # Loads all the library files in this cookbook via require.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_libraries
+      @lib_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name} library file: #{file}")
+        require file
+      end
+      true
+    end
+    
+    # Loads all the attribute files in this cookbook within a particular <Chef::Node>.
+    #
+    # === Parameters
+    # node<Chef::Node>:: The Chef::Node to apply the attributes to
+    #
+    # === Returns
+    # node<Chef::Node>:: The updated Chef::Node object
+    #
+    # === Raises
+    # <ArgumentError>:: If the argument is not a kind_of? <Chef::Node>
+    def load_attributes(node)
+      @attribute_files.each do |file|
+        load_attribute_file(file, node)
+      end
+      node
+    end
+
+    def load_attribute_file(file, node)
+      Chef::Log.debug("Loading attributes from #{file}")
+      node.from_file(file)
+    end
+
+    def load_attribute(name, node)
+      attr_name = shorten_name(name)
+      file = @attribute_files[@attribute_names[attr_name]]
+      load_attribute_file(file, node)
+      node
+    end
+    
+    # Loads all the resource definitions in this cookbook.
+    #
+    # === Returns
+    # definitions<Hash>: A hash of <Chef::ResourceDefinition> objects, keyed by name.
+    def load_definitions
+      results = Hash.new
+      @definition_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s definitions from #{file}")
+        resourcedef = Chef::ResourceDefinition.new
+        resourcedef.from_file(file)
+        results[resourcedef.name] = resourcedef
+      end
+      results
+    end
+
+    # Loads all the resources in this cookbook.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_resources
+      @resource_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s resources from #{file}")
+        Chef::Resource.build_from_file(name, file)
+      end
+    end
+    
+    # Loads all the providers in this cookbook.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_providers
+      @provider_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s providers from #{file}")
+        Chef::Provider.build_from_file(name, file)
+      end
+    end
+    
+    def recipe_files=(*args)
+      @recipe_files, @recipe_names = set_with_names(args.flatten)
+      @recipe_files
+    end
+
+    def attribute_files=(*args)
+      @attribute_files, @attribute_names = set_with_names(args.flatten)
+      @attribute_files
+    end
+    
+    def recipe?(name)
+      lookup_name = name
+      if name =~ /(.+)::(.+)/
+        cookbook_name = $1
+        lookup_name = $2
+        return false unless cookbook_name == @name
+      end
+      @recipe_names.has_key?(lookup_name)
+    end
+    
+    def recipes
+      results = Array.new
+      @recipe_names.each_key do |rname|
+        results << "#{@name}::#{rname}"
+      end
+      results
+    end
+    
+    def load_recipe(name, node, collection=nil, definitions=nil, cookbook_loader=nil)
+      cookbook_name = @name
+      recipe_name = shorten_name(name) 
+      
+      unless @recipe_names.has_key?(recipe_name)
+        raise ArgumentError, "Cannot find a recipe matching #{recipe_name} in cookbook #{@name}"
+      end
+      Chef::Log.debug("Found recipe #{recipe_name} in cookbook #{cookbook_name}") if Chef::Log.debug?
+      recipe = Chef::Recipe.new(cookbook_name, recipe_name, node, 
+                                collection, definitions, cookbook_loader)
+      recipe.from_file(@recipe_files[@recipe_names[recipe_name]])
+      recipe
+    end
+
+    private
+
+      def shorten_name(name)
+        short_name = nil
+        nmatch = name.match(/^(.+?)::(.+)$/)
+        short_name = nmatch ? nmatch[2] : name
+      end
+
+      def set_with_names(file_list)
+        files = file_list
+        names = Hash.new
+        files.each_index do |i|
+          file = files[i]
+          case file
+          when /(.+\/)(.+).rb$/
+            names[$2] = i
+          when /(.+).rb$/
+            names[$1] = i
+          else  
+            names[file] = i
+          end
+        end
+        [ files, names ]
+      end
+    
+  end
+end

data/lib/chef/cookbook/metadata.rb

@@ -0,0 +1,487 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: AJ Christensen (<aj@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/mixin/from_file'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/check_helper'
+require 'chef/log'
+require 'chef/cookbook/metadata/version'
+
+class Chef
+  class Cookbook
+    class Metadata
+    
+      include Chef::Mixin::CheckHelper
+      include Chef::Mixin::ParamsValidate
+      include Chef::Mixin::FromFile
+
+      attr_accessor :cookbook, 
+                    :platforms,
+                    :dependencies,
+                    :recommendations,
+                    :suggestions,
+                    :conflicting,
+                    :providing,
+                    :replacing,
+                    :attributes,
+                    :groupings,
+                    :recipes,
+                    :version
+
+      # Builds a new Chef::Cookbook::Metadata object.
+      # 
+      # === Parameters
+      # cookbook<String>:: An optional cookbook object
+      # maintainer<String>:: An optional maintainer
+      # maintainer_email<String>:: An optional maintainer email
+      # license<String>::An optional license. Default is Apache v2.0
+      #
+      # === Returns
+      # metadata<Chef::Cookbook::Metadata>
+      def initialize(cookbook=nil, maintainer='Your Name', maintainer_email='youremail@example.com', license='Apache v2.0')
+        @cookbook = cookbook
+        @name = cookbook ? cookbook.name : "" 
+        @long_description = ""
+        self.maintainer(maintainer)
+        self.maintainer_email(maintainer_email)
+        self.license(license)
+        self.description('A fabulous new cookbook')
+        @platforms = Mash.new
+        @dependencies = Mash.new
+        @recommendations = Mash.new
+        @suggestions = Mash.new
+        @conflicting = Mash.new
+        @providing = Mash.new
+        @replacing = Mash.new
+        @attributes = Mash.new
+        @groupings = Mash.new
+        @recipes = Mash.new
+        @version = Version.new "0.0.0"
+        if cookbook
+          @recipes = cookbook.recipes.inject({}) do |r, e| 
+            e = self.name if e =~ /::default$/ 
+            r[e] = ""
+            self.provides e
+            r
+          end
+        end
+      end
+
+      # Sets the cookbooks maintainer, or returns it.
+      #
+      # === Parameters
+      # maintainer<String>:: The maintainers name
+      #
+      # === Returns
+      # maintainer<String>:: Returns the current maintainer.
+      def maintainer(arg=nil)
+        set_or_return(
+          :maintainer,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Sets the maintainers email address, or returns it.
+      #
+      # === Parameters
+      # maintainer_email<String>:: The maintainers email address 
+      #
+      # === Returns
+      # maintainer_email<String>:: Returns the current maintainer email.
+      def maintainer_email(arg=nil)
+        set_or_return(
+          :maintainer_email,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Sets the current license, or returns it.
+      #
+      # === Parameters
+      # license<String>:: The current license.
+      #
+      # === Returns
+      # license<String>:: Returns the current license 
+      def license(arg=nil)
+        set_or_return(
+          :license,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Sets the current description, or returns it. Should be short - one line only!
+      #
+      # === Parameters
+      # description<String>:: The new description 
+      #
+      # === Returns
+      # description<String>:: Returns the description 
+      def description(arg=nil)
+        set_or_return(
+          :description,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Sets the current long description, or returns it. Might come from a README, say. 
+      #
+      # === Parameters
+      # long_description<String>:: The new long description
+      #
+      # === Returns
+      # long_description<String>:: Returns the long description 
+      def long_description(arg=nil)
+        set_or_return(
+          :long_description,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Sets the current cookbook version, or returns it.  Can be two or three digits, seperated
+      # by dots.  ie: '2.1', '1.5.4' or '0.9'.
+      #
+      # === Parameters
+      # version<String>:: The curent version, as a string
+      #
+      # === Returns
+      # version<String>:: Returns the current version 
+      def version(arg=nil)
+        if arg
+          @version = Version.new(arg)
+        end
+
+        @version.to_s
+      end
+
+      # Sets the name of the cookbook, or returns it.
+      #
+      # === Parameters
+      # name<String>:: The curent cookbook name. 
+      #
+      # === Returns
+      # name<String>:: Returns the current cookbook name. 
+      def name(arg=nil)
+        set_or_return(
+          :name,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      # Adds a supported platform, with version checking strings. 
+      #
+      # === Parameters
+      # platform<String>,<Symbol>:: The platform (like :ubuntu or :mac_os_x)
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def supports(platform, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @platforms[platform] = versions
+        @platforms[platform]
+      end
+
+      # Adds a dependency on another cookbook, with version checking strings.
+      #
+      # === Parameters
+      # cookbook<String>:: The cookbook 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def depends(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @dependencies[cookbook] = versions
+        @dependencies[cookbook]
+      end
+
+      # Adds a recommendation for another cookbook, with version checking strings.
+      #
+      # === Parameters
+      # cookbook<String>:: The cookbook 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def recommends(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @recommendations[cookbook] = versions
+        @recommendations[cookbook]
+      end
+
+      # Adds a suggestion for another cookbook, with version checking strings.
+      #
+      # === Parameters
+      # cookbook<String>:: The cookbook 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def suggests(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @suggestions[cookbook] = versions
+        @suggestions[cookbook] 
+      end
+
+      # Adds a conflict for another cookbook, with version checking strings.
+      #
+      # === Parameters
+      # cookbook<String>:: The cookbook 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def conflicts(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @conflicting[cookbook] = versions
+        @conflicting[cookbook] 
+      end
+
+      # Adds a recipe, definition, or resource provided by this cookbook. 
+      #
+      # Recipes are specified as normal
+      # Definitions are followed by (), and can include :params for prototyping
+      # Resources are the stringified version (service[apache2])
+      #
+      # === Parameters
+      # recipe, definition, resource<String>:: The thing we provide 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def provides(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @providing[cookbook] = versions
+        @providing[cookbook] 
+      end
+
+      # Adds a cookbook that is replaced by this one, with version checking strings.
+      #
+      # === Parameters
+      # cookbook<String>:: The cookbook we replace 
+      # *versions<String>:: A list of versions matching << <= = >= >> followed by a version. 
+      #
+      # === Returns
+      # versions<Array>:: Returns the list of versions for the platform 
+      def replaces(cookbook, *versions)
+        versions.each { |v| _check_version_expression(v) }
+        @replacing[cookbook] = versions
+        @replacing[cookbook] 
+      end
+
+      # Adds a description for a recipe. 
+      #
+      # === Parameters
+      # recipe<String>:: The recipe
+      # description<String>:: The description of the recipe
+      #
+      # === Returns
+      # description<String>:: Returns the current description 
+      def recipe(name, description)
+        @recipes[name] = description 
+      end
+
+      # Adds an attribute that a user needs to configure for this cookbook. Takes
+      # a name (with the / notation for a nested attribute), followed by any of
+      # these options
+      #
+      #   display_name<String>:: What a UI should show for this attribute
+      #   description<String>:: A hint as to what this attr is for
+      #   choice<Array>:: An array of choices to present to the user.
+      #   calculated<Boolean>:: If true, the default value is calculated by the recipe and cannot be displayed.
+      #   type<String>:: "string" or "array" - default is "string"  ("hash" is supported for backwards compatibility)
+      #   required<String>:: Whether this attr is 'required', 'recommended' or 'optional' - default 'optional' (true/false values also supported for backwards compatibility)
+      #   recipes<Array>:: An array of recipes which need this attr set.
+      #   default<String>,<Array>,<Hash>:: The default value
+      #
+      # === Parameters
+      # name<String>:: The name of the attribute ('foo', or 'apache2/log_dir') 
+      # options<Hash>:: The description of the options 
+      #
+      # === Returns
+      # options<Hash>:: Returns the current options hash 
+      def attribute(name, options)
+        validate(
+          options,
+          {
+            :display_name => { :kind_of => String },
+            :description => { :kind_of => String },
+            :choice => { :kind_of => [ Array ], :default => [] },
+            :calculated => { :equal_to => [ true, false ], :default => false },
+            :type => { :equal_to => [ "string", "array", "hash" ], :default => "string" },
+            :required => { :equal_to => [ "required", "recommended", "optional", true, false ], :default => "optional" },
+            :recipes => { :kind_of => [ Array ], :default => [] },
+            :default => { :kind_of => [ String, Array, Hash ] }
+          }
+        )
+        options[:required] = remap_required_attribute(options[:required]) unless options[:required].nil?
+        validate_string_array(options[:choice])
+        validate_calculated_default_rule(options)
+        validate_choice_default_rule(options)
+
+        @attributes[name] = options 
+        @attributes[name]
+      end
+
+      def grouping(name, options)
+        validate(
+          options,
+          {
+            :title => { :kind_of => String },
+            :description => { :kind_of => String }
+          }
+        )
+        @groupings[name] = options 
+        @groupings[name]
+      end
+
+      def _check_version_expression(version_string)
+        if version_string =~ /^(>>|>=|=|<=|<<) (.+)$/
+          [ $1, $2 ]
+        else
+          raise ArgumentError, "Version expression #{version_string} is invalid!"
+        end
+      end
+
+      def to_json(*a)
+        result = {
+          :name => self.name,
+          :description => self.description,
+          :long_description => self.long_description,
+          :maintainer => self.maintainer,
+          :maintainer_email => self.maintainer_email,
+          :license => self.license,
+          :platforms => self.platforms,
+          :dependencies => self.dependencies,
+          :recommendations => self.recommendations,
+          :suggestions => self.suggestions,
+          :conflicting => self.conflicting,
+          :providing => self.providing,
+          :replacing => self.replacing,
+          :attributes => self.attributes,
+          :groupings => self.groupings,
+          :recipes => self.recipes,
+          :version => self.version
+        }
+        result.to_json(*a)
+      end
+
+      def self.from_hash(o)
+        cm = self.new() 
+        cm.from_hash(o)
+        cm
+      end
+
+      def from_hash(o)
+        self.name o['name'] if o.has_key?('name')
+        self.description o['description'] if o.has_key?('description')
+        self.long_description o['long_description'] if o.has_key?('long_description')
+        self.maintainer o['maintainer'] if o.has_key?('maintainer')
+        self.maintainer_email o['maintainer_email'] if o.has_key?('maintainer_email')
+        self.license o['license'] if o.has_key?('license')
+        self.version o['version'] if o.has_key?('version')
+        self.platforms = o['platforms'] if o.has_key?('platforms')
+        self.dependencies = o['dependencies'] if o.has_key?('dependencies')
+        self.recommendations = o['recommendations'] if o.has_key?('recommendations')
+        self.suggestions = o['suggestions'] if o.has_key?('suggestions')
+        self.conflicting = o['conflicting'] if o.has_key?('conflicting')
+        self.providing = o['providing'] if o.has_key?('providing')
+        self.replacing = o['replacing'] if o.has_key?('replacing')
+        self.attributes = o['attributes'] if o.has_key?('attributes')
+        self.groupings = o['groupings'] if o.has_key?('groupings')
+        self.recipes = o['recipes'] if o.has_key?('recipes')
+        self.version = o['version'] if o.has_key?('version')
+        self
+      end
+
+      def self.from_json(string)
+        o = JSON.parse(string)
+        self.from_hash(o)
+      end
+
+      def from_json(string)
+        o = JSON.parse(string)
+        from_hash(o)
+      end
+
+    private
+
+      # Verify that the given array is an array of strings
+      #
+      # Raise an exception if the members of the array are not Strings
+      #
+      # === Parameters
+      # arry<Array>:: An array to be validated
+      def validate_string_array(arry)
+        if arry.kind_of?(Array)
+          arry.each do |choice|
+            validate( {:choice => choice}, {:choice => {:kind_of => String}} )
+          end
+        end
+      end
+
+      # For backwards compatibility, remap Boolean values to String
+      #   true is mapped to "required"
+      #   false is mapped to "optional"
+      #
+      # === Parameters
+      # required_attr<String><Boolean>:: The value of options[:required]
+      #
+      # === Returns
+      # required_attr<String>:: "required", "recommended", or "optional"
+      def remap_required_attribute(value)
+        case value
+        when true
+          value = "required"
+        when false
+          value = "optional"
+        end
+        value
+      end
+
+      def validate_calculated_default_rule(options)
+        calculated_conflict = ((options[:default].is_a?(Array) && !options[:default].empty?) ||
+                               (options[:default].is_a?(String) && !options[:default] != "")) &&
+                              options[:calculated] == true
+        raise ArgumentError, "Default cannot be specified if calculated is true!" if calculated_conflict
+      end
+
+      def validate_choice_default_rule(options)
+        return if !options[:choice].is_a?(Array) || options[:choice].empty?
+
+        if options[:default].is_a?(String) && options[:default] != ""
+          raise ArgumentError, "Default must be one of your choice values!" if options[:choice].index(options[:default]) == nil
+        end
+
+        if options[:default].is_a?(Array) && !options[:default].empty?
+          options[:default].each do |val|
+            raise ArgumentError, "Default values must be a subset of your choice values!" if options[:choice].index(val) == nil
+          end
+        end
+      end
+
+    end
+  end
+end