puppet-module 0.3.0

data/lib/puppet/module/tool/contents_description.rb

@@ -0,0 +1,84 @@
+module Puppet::Module::Tool
+
+  # = ContentsDescription
+  #
+  # This class populates +Metadata+'s Puppet type information.
+  class ContentsDescription
+
+    # Instantiate object for string +module_path+.
+    def initialize(module_path)
+      @module_path = module_path
+    end
+
+    # Update +Metadata+'s Puppet type information.
+    def annotate(metadata)
+      metadata.types.replace data.clone
+    end
+
+    # Return types for this module. Result is an array of hashes, each of which
+    # describes a Puppet type. The type description hash structure is:
+    # * :name => Name of this Puppet type.
+    # * :doc => Documentation for this type.
+    # * :properties => Array of hashes representing the type's properties, each
+    #   containing :name and :doc.
+    # * :parameters => Array of hashes representing the type's parameters, each
+    #   containing :name and :doc.
+    # * :providers => Array of hashes representing the types providers, each
+    #   containing :name and :doc.
+    # TODO Write a TypeDescription to encapsulate these structures and logic?
+    def data
+      unless @data
+        @data = []
+        type_names = []
+        for module_filename in Dir[File.join(@module_path, "lib/puppet/type/*.rb")]
+          require module_filename
+          type_name = File.basename(module_filename, ".rb")
+          type_names << type_name
+
+          for provider_filename in Dir[File.join(@module_path, "lib/puppet/provider/#{type_name}/*.rb")]
+            require provider_filename
+          end
+        end
+
+        type_names.each do |type_name|
+          if type = Puppet::Type.type(type_name.to_sym)
+            type_hash = {:name => type_name, :doc => type.doc}
+            type_hash[:properties] = attr_doc(type, :property)
+            type_hash[:parameters] = attr_doc(type, :param)
+            if type.providers.size > 0
+              type_hash[:providers] = provider_doc(type)
+            end
+            @data << type_hash
+          else
+            puts "Could not find/load type: #{type_name}"
+          end
+        end
+      end
+      @data
+    end
+
+    # Return an array of hashes representing this +type+'s attrs of +kind+
+    # (e.g. :param or :property), each containing :name and :doc.
+    def attr_doc(type, kind)
+      returning([]) do |attrs|
+        type.allattrs.each do |name|
+          if type.attrtype(name) == kind && name != :provider
+            attrs.push(:name => name, :doc => type.attrclass(name).doc)
+          end
+        end
+      end
+    end
+
+    # Return an array of hashes representing this +type+'s providers, each
+    # containing :name and :doc.
+    def provider_doc(type)
+      returning([]) do |providers|
+        type.providers.sort_by{ |o| o.to_s }.each do |prov|
+          providers.push(:name => prov, :doc => type.provider(prov).doc)
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/puppet/module/tool/dependency.rb

@@ -0,0 +1,26 @@
+module Puppet::Module::Tool
+
+  class Dependency
+
+    # Instantiates a new module dependency with a +full_name+ (e.g.
+    # "myuser-mymodule"), and optional +version_requirement+ (e.g. "0.0.1") and
+    # optional repository (a URL string).
+    def initialize(full_name, version_requirement = nil, repository = nil)
+      @full_name = full_name
+      # TODO: add error checking, the next line raises ArgumentError when +full_name+ is invalid
+      @username, @name = Puppet::Module::Tool.username_and_modname_from(full_name)
+      @version_requirement = version_requirement
+      @repository = repository ? Repository.new(repository) : nil
+    end
+
+    # Return PSON representation of this data.
+    def to_pson(*args)
+      result = { :name => @full_name }
+      result[:version_requirement] = @version_requirement if @version_requirement && ! @version_requirement.nil?
+      result[:repository] = @repository.to_s if @repository && ! @repository.nil?
+      result.to_pson(*args)
+    end
+    
+  end
+  
+end

data/lib/puppet/module/tool/metadata.rb

@@ -0,0 +1,80 @@
+module Puppet::Module::Tool
+
+  # = Metadata
+  #
+  # This class provides a data structure representing a module's metadata.
+  # It provides some basic parsing, but other data is injected into it using
+  # +annotate+ methods in other classes.
+  class Metadata
+
+    # The full name of the module, which is a dash-separated combination of the
+    # +username+ and module +name+.
+    attr_reader :full_name
+
+    # The name of the user that owns this module.
+    attr_reader :username
+
+    # The name of this module. See also +full_name+.
+    attr_reader :name
+
+    # The version of this module, a string like '0.1.0'.
+    attr_accessor :version
+
+    # Instantiate from a hash, whose keys are setters in this class.
+    def initialize(settings={})
+      settings.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    # Set the full name of this module, and from it, the +username+ and
+    # module +name+.
+    def full_name=(full_name)
+      @full_name = full_name
+      @username, @name = Puppet::Module::Tool::username_and_modname_from(full_name)
+    end
+
+    # Return an array of the module's Dependency objects.
+    def dependencies
+      return @dependencies ||= []
+    end
+
+    # Return an array of the module's Puppet types, each one is a hash
+    # containing :name and :doc.
+    # TODO Shouldn't this be it's own class?
+    def types
+      return @types ||= []
+    end
+
+    # Return module's file checksums.
+    def checksums
+      return @checksums ||= {}
+    end
+
+    # Return the dashed name of the module, which may either be the
+    # dash-separated combination of the +username+ and module +name+, or just
+    # the module +name+.
+    def dashed_name
+      return [@username, @name].compact.join('-')
+    end
+
+    # Return the release name, which is the combination of the +dashed_name+
+    # of the module and its +version+ number.
+    def release_name
+      return [dashed_name, @version].join('-')
+    end
+
+    # Return the PSON record representing this instance.
+    def to_pson(*args)
+      return {
+        :name         => @full_name,
+        :version      => @version,
+        :dependencies => dependencies,
+        :types        => types,
+        :checksums    => checksums
+      }.to_pson(*args)
+    end
+
+  end
+  
+end

data/lib/puppet/module/tool/modulefile.rb

@@ -0,0 +1,47 @@
+module Puppet::Module::Tool
+
+  # = Modulefile
+  #
+  # This class provides the DSL used for evaluating the module's 'Modulefile'.
+  # These methods are used to concisely define this module's attributes, which
+  # are later rendered as PSON into a 'metadata.json' file.
+  class Modulefile
+
+    # Read the +filename+ and eval its Ruby code to set values in the Metadata
+    # +metadata+ instance.
+    def self.evaluate(metadata, filename)
+      returning(new(metadata)) do |builder|
+        if File.file?(filename)
+          builder.instance_eval(File.read(filename.to_s), filename.to_s, 1)
+        else
+          puts "No Modulefile: #{filename}"
+        end
+      end
+    end
+
+    # Instantiate with the Metadata +metadata+ instance.
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    # Set the +full_name+ (e.g. "myuser-mymodule"), which will also set the
+    # +username+ and module +name+. Required.
+    def name(name)
+      @metadata.full_name = name
+    end
+
+    # Set the module +version+ (e.g., "0.0.1"). Required.
+    def version(version)
+      @metadata.version = version
+    end
+
+    # Add a dependency with the full_name +name+ (e.g. "myuser-mymodule"), an
+    # optional +version_requirement+ (e.g. "0.0.1") and +repository+ (a URL
+    # string). Optional. Can be called multiple times to add many dependencies.
+    def dependency(name, version_requirement = nil, repository = nil)
+      @metadata.dependencies << Dependency.new(name, version_requirement, repository)
+    end
+
+  end
+
+end

data/lib/puppet/module/tool/repository.rb

@@ -0,0 +1,74 @@
+require 'net/http'
+require 'digest/sha1'
+
+module Puppet::Module::Tool
+
+  # = Repository
+  #
+  # This class is a file for accessing remote repositories with modules.
+  class Repository
+    include Utils::URI
+    include Utils::Interrogation
+
+    attr_reader :uri, :cache
+
+    # Instantiate a new repository instance rooted at the optional string
+    # +url+, else an instance of the default Puppet modules repository.
+    def initialize(url=Puppet::Module::Tool::REPOSITORY_URL)
+      @uri = normalize(url)
+      @cache = Cache.new(self)
+    end
+
+    # Return a Net::HTTPResponse read for this +request+.
+    #
+    # Options:
+    # * :authenticate => Request authentication on the terminal. Defaults to false.
+    def contact(request, options = {})
+      if options[:authenticate]
+        authenticate(request)
+      end
+      if ! @uri.user.nil? && ! @uri.password.nil?
+        request.basic_auth(@uri.user, @uri.password)
+      end
+      return read_contact(request)
+    end
+
+    # Return a Net::HTTPResponse read from this HTTPRequest +request+.
+    def read_contact(request)
+      Net::HTTP.start(@uri.host, @uri.port) do |http|
+        http.request(request)
+      end
+    end
+
+    # Set the HTTP Basic Authentication parameters for the Net::HTTPRequest
+    # +request+ by asking the user for input on the console.
+    def authenticate(request)
+      header "Authenticating for #{@uri}"
+      email = prompt('Email Address')
+      password = prompt('Password', true)
+      request.basic_auth(email, password)
+    end
+
+    # Return the local file name containing the data downloaded from the
+    # repository at +release+ (e.g. "myuser-mymodule").
+    def retrieve(release)
+      return cache.retrieve(@uri + release)
+    end
+
+    # Return the URI string for this repository.
+    def to_s
+      return @uri.to_s
+    end
+
+    # Return the cache key for this repository, this a hashed string based on
+    # the URI.
+    def cache_key
+      return @cache_key ||= [
+        @uri.to_s.gsub(/[^[:alnum:]]+/, '_').sub(/_$/, ''),
+        Digest::SHA1.hexdigest(@uri.to_s)
+      ].join('-')
+    end
+
+  end
+
+end

data/lib/puppet/module/tool/skeleton.rb

@@ -0,0 +1,39 @@
+module Puppet::Module::Tool
+
+  # = Skeleton
+  #
+  # This class provides methods for finding templates for the 'generate' action.
+  class Skeleton
+
+    # TODO Review whether the 'freeze' feature should be fixed or deleted.
+    # def freeze!
+    #   FileUtils.rm_fr custom_path rescue nil
+    #   FileUtils.cp_r default_path, custom_path
+    # end
+
+    # Return Pathname with 'generate' templates.
+    def path 
+      paths.detect { |path| path.directory? }
+    end
+
+    # Return Pathnames to look for 'generate' templates.
+    def paths
+      @paths ||= [
+                  custom_path,
+                  default_path
+                 ]
+    end
+
+    # Return Pathname of custom templates directory.
+    def custom_path
+      Puppet::Module::Tool.working_dir + 'skeleton'
+    end
+
+    # Return Pathname of default template directory.
+    def default_path
+      Puppet::Module::Tool.root + 'templates' + 'generator'
+    end
+
+  end
+
+end

data/lib/puppet/module/tool/utils.rb

@@ -0,0 +1,9 @@
+module Puppet::Module::Tool
+  module Utils
+
+    require 'puppet/module/tool/utils/uri'
+    require 'puppet/module/tool/utils/interrogation'
+    require 'puppet/module/tool/utils/settings'
+
+  end
+end

data/lib/puppet/module/tool/utils/interrogation.rb

@@ -0,0 +1,39 @@
+module Puppet::Module::Tool
+  module Utils
+
+    # = Interrogation
+    #
+    # This module contains methods to emit text to the console, such as headers.
+    module Interrogation
+
+      def header(text)
+        $stderr.puts('=' * text.size, text, "-" * text.size)
+      end
+
+      def say(*args)
+        $stderr.puts(*args)
+      end
+
+      def subheader(line)
+        say line, ('-' * line.size)
+      end
+
+      def confirms?(question)
+        $stderr.print "#{question} [y/N]: "
+        $stdin.gets =~ /y/i
+      end
+
+      def prompt(question, quiet = false)
+        $stderr.print "#{question}: "
+        system 'stty -echo' if quiet
+        $stdin.gets.strip
+      ensure
+        if quiet
+          system 'stty echo'
+          say "\n---------"
+        end
+      end
+
+    end
+  end
+end

data/lib/puppet/module/tool/utils/settings.rb

@@ -0,0 +1,36 @@
+module Puppet::Module::Tool::Utils
+
+  # = Settings
+  #
+  # This module contains methods for interacting with Puppet's settings files.
+  module Settings
+
+    def prepare_settings(options = {})
+      return if @settings_prepared
+
+      if options[:config]
+        Puppet.settings.send(:set_value, :config, options[:config], :cli)
+      end
+
+      Puppet.setdefaults(:puppet_module,
+        :puppet_module_repository => [Puppet::Module::Tool::REPOSITORY_URL, "The module repository"],
+        :puppet_module_working_dir => ['$vardir/puppet-module', "The directory in which module tool data is stored"])
+
+      Puppet::Module::Tool.working_dir.mkpath
+
+      Puppet.settings.use(:puppet_module)
+
+      Puppet.settings.parse
+
+      [:puppet_module_repository].each do |key|
+        if options[key]
+          Puppet.settings.send(:set_value, key, options[key], :cli)
+        end
+      end
+
+      @settings_prepared = true
+    end
+
+  end
+  
+end

data/lib/puppet/module/tool/utils/uri.rb

@@ -0,0 +1,16 @@
+require 'uri'
+
+module Puppet::Module::Tool
+  module Utils
+    module URI
+
+      # Return a URI instance for the +uri+, a a string or URI object.
+      def normalize(url)
+        return url.is_a?(::URI) ?
+          url :
+          ::URI.parse(url)
+      end
+
+    end
+  end
+end