puppet-module 0.3.0

data/lib/puppet/module/tool/applications/registrar.rb

@@ -0,0 +1,34 @@
+module Puppet::Module::Tool
+  module Applications
+
+    class Registrar < Application
+      # TODO Review whether the 'register' feature should be fixed or deleted.
+=begin
+      def initialize(full_name, options = {})
+        @full_name = full_name
+        @username, @module_name = full_name.split(/[\/\-]/, 2)
+        super(options)
+        validate!
+      end
+
+      def run
+        if confirms?("Register #{@full_name}?")
+          request = Net::HTTP::Post.new("/users/#{@username}/modules.json")
+          request.set_form_data 'mod[name]' => @module_name
+          response = repository.contact(request, :authenticate => true)
+          discuss response, "Registered #{@full_name}", "Could not register #{@full_name}"
+        end
+      end
+
+      private
+
+      def validate!
+        unless @username && @module_name
+          abort "Must provide the full module name (ie, 'username/name') to register."
+        end
+      end
+=end
+    end
+    
+  end
+end

data/lib/puppet/module/tool/applications/releaser.rb

@@ -0,0 +1,48 @@
+require 'net/http/post/multipart'
+
+module Puppet::Module::Tool
+
+  module Applications
+
+    class Releaser < Application
+      # TODO Review whether the 'release' feature should be fixed or deleted.
+=begin
+      def initialize(filename, options = {})
+        @filename = filename
+        parse_filename!
+        super(options)
+      end
+
+      def version
+        @version ||= options[:version]
+      end
+
+      def run
+        upload if confirms?("Release #{File.basename(@filename)} as version #{version} of #{@username}/#{@module_name}?")
+      end
+
+      private
+
+      def upload
+        File.open(@filename) do |file|
+          request = build_request(file)
+          response = repository.contact(request, :authenticate => true)
+          discuss response, "Released #{version}", "Could not release #{version}"
+        end
+      end
+
+      def build_request(file)
+        upload = UploadIO.new(file, 'application/x-gzip', @filename)
+        Net::HTTP::Post::Multipart.new(upload_path,
+                                       'release[version]' => version,
+                                       'release[file]'    => upload)
+      end
+
+      def upload_path
+        "/users/#{@username}/modules/#{@module_name}/releases.json"
+      end
+=end
+    end
+    
+  end
+end

data/lib/puppet/module/tool/applications/searcher.rb

@@ -0,0 +1,34 @@
+module Puppet::Module::Tool
+
+  module Applications
+
+    class Searcher < Application
+
+      def initialize(term, options = {})
+        @term = term
+        super(options)
+      end
+
+      def run
+        header "Searching #{repository}"
+        request = Net::HTTP::Get.new("/modules.json?q=#{URI.escape(@term)}")
+        response = repository.contact(request)
+        case response
+        when Net::HTTPOK
+          matches = PSON.parse(response.body)
+          if matches.empty?
+            subheader "0 found."
+          else
+            subheader "#{matches.size} found."
+          end
+          matches.each do |match|
+            puts "#{match['full_name']} (#{match['version']})"
+          end
+        else
+          say "Could not execute search (HTTP #{response.code})"
+        end
+      end
+      
+    end
+  end
+end

data/lib/puppet/module/tool/applications/unpacker.rb

@@ -0,0 +1,69 @@
+require 'pathname'
+require 'tmpdir'
+
+module Puppet::Module::Tool
+
+  module Applications
+
+    class Unpacker < Application
+
+      def initialize(filename, environment_path, options = {})
+        @filename = Pathname.new(filename)
+        @environment_path = Pathname.new(environment_path)
+        parse_filename!
+        super(options)
+      end
+
+      def force?
+        options[:force]
+      end
+
+      def run
+        check_clobber!
+        build_dir = Puppet::Module::Tool::Cache.base_path + "tmp-unpacker-#{Digest::SHA1.hexdigest(@filename.basename)}"
+        build_dir.mkpath
+        begin
+          FileUtils.cp @filename, build_dir
+          Dir.chdir(build_dir) do
+            unless system "tar xzf #{@filename.basename}"
+              abort "Could not extract contents of module archive."
+            end
+          end
+          # grab the first directory
+          extracted = build_dir.children.detect { |c| c.directory? }
+          if force?
+            FileUtils.rm_rf @full_name rescue nil
+          end
+          FileUtils.cp_r extracted, @full_name
+          tag_revision
+        ensure
+          build_dir.rmtree
+        end
+        say "Installed #{@release_name.inspect} into directory: #{@full_name}"
+      end
+
+      private
+
+      def tag_revision
+        File.open("#{@full_name}/REVISION", 'w') do |f|
+          f.puts "module: #{@username}/#{@module_name}"
+          f.puts "version: #{@version}"
+          f.puts "url: file://#{@filename.realpath}"
+          f.puts "installed: #{Time.now}"
+        end
+      end
+
+      def check_clobber!
+        if File.directory?(@full_name) && !force?
+          header "Existing module '#{@full_name}' found"
+          response = prompt "Overwrite module installed at ./#{@full_name}? [y/N]"
+          unless response =~ /y/i
+            abort "Aborted installation."
+          end
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/puppet/module/tool/applications/unreleaser.rb

@@ -0,0 +1,42 @@
+module Puppet::Module::Tool
+  module Applications
+
+    class Unreleaser < Application
+      # TODO Review whether the 'unrelease' feature should be fixed or deleted.
+=begin
+      def initialize(address, options = {})
+        @address = address
+        @username, @module_name = address.split('/')
+        validate!
+        super(options)
+      end
+
+      def version
+        options[:version]
+      end
+
+      def run
+        if confirms?("Unrelease #{@address} #{version}?")
+          request = Net::HTTP::Delete.new("/users/#{@username}/modules/#{@module_name}/releases/#{version}")
+          response = repository.contact(request, :authenticate => true)
+          discuss response, "Unreleased #{@address} #{version}", "Could not unrelease #{@address} #{version}"
+        end
+      end
+
+      private
+      
+      def validate!
+        unless @username && @module_name
+          abort "Username and Module name not provided"
+        end
+        begin
+          Gem::Version.new(version)
+        rescue ArgumentError => e
+          abort "Invalid version format: #{version}"
+        end
+      end
+=end
+    end
+    
+  end
+end

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

@@ -0,0 +1,56 @@
+module Puppet::Module::Tool
+
+  # = Cache
+  #
+  # Provides methods for reading files from local cache, filesystem or network.
+  class Cache
+    include Puppet::Module::Tool::Utils::URI
+
+    # Instantiate new cahe for the +repositry+ instance.
+    def initialize(repository)
+      @repository = repository
+    end
+
+    # Return filename retrieved from +uri+ instance. Will download this file and
+    # cache it if needed.
+    #
+    # TODO: Add checksum support.
+    # TODO: Add error checking.
+    def retrieve(url)
+      returning(path + File.basename(url.to_s)) do |cached_file|
+        uri = normalize(url)
+        unless cached_file.file?
+          if uri.scheme == 'file'
+            FileUtils.cp(uri.path, cached_file)
+          else
+            # TODO: Handle HTTPS; probably should use repository.contact
+            data = read_retrieve(uri)
+            cached_file.open('wb') { |f| f.write data }
+          end
+        end
+      end
+    end
+
+    # Return contents of file at the given URI's +uri+.
+    def read_retrieve(uri)
+      return uri.read
+    end
+
+    # Return Pathname for repository's cache directory, create it if needed.
+    def path
+      return @path ||= (self.class.base_path + @repository.cache_key).tap{ |o| o.mkpath }
+    end
+
+    # Return the base Pathname for all the caches.
+    def self.base_path
+      return(Puppet::Module::Tool.working_dir + 'cache')
+    end
+
+    # Clean out all the caches.
+    def self.clean
+      base_path.rmtree if base_path.exist?
+    end
+
+  end
+
+end

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

@@ -0,0 +1,52 @@
+require 'digest/md5'
+
+module Puppet::Module::Tool
+
+  # = Checksums
+  #
+  # This class proides methods for generating checksums for data and adding
+  # them to +Metadata+.
+  class Checksums
+    include Enumerable
+
+    # Instantiate object with string +path+ to create checksums from.
+    def initialize(path)
+      @path = Pathname.new(path)
+    end
+
+    # Return checksum for the +Pathname+.
+    def checksum(pathname)
+      return Digest::MD5.hexdigest(pathname.read)
+    end
+
+    # Return checksums for object's +Pathname+, generate if it's needed.
+    # Result is a hash of path strings to checksum strings.
+    def data
+      unless @data
+        @data = {}
+        @path.find do |descendant|
+          if Puppet::Module::Tool.artifact?(descendant)
+            Find.prune
+          elsif descendant.file?
+            path = descendant.relative_path_from(@path)
+            @data[path.to_s] = checksum(descendant)
+          end
+        end
+      end
+      return @data
+    end
+
+    # TODO: Why?
+    def each(&block)
+      data.each(&block)
+    end
+
+    # Update +Metadata+'s checksums with this object's.
+    def annotate(metadata)
+      metadata.checksums.replace(data)
+    end
+    
+    # TODO: Move the Checksummer#run checksum checking to here?
+
+  end
+end

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

@@ -0,0 +1,127 @@
+begin
+  require 'thor'
+rescue LoadError
+  abort "Requires 'thor'"
+end
+
+# = CLI
+#
+# This class is used by the command-line program to dispatch actions.
+class Puppet::Module::Tool::CLI < Thor
+  include Thor::Actions
+  
+  map '-V' => :version
+
+  class_option :config, :aliases => '-c', :default => Puppet.settings[:config], :desc => "Configuration file"
+  
+  def self.method_option_repository
+    method_option :puppet_module_repository, :aliases => '-r', :default => Puppet.settings[:puppet_module_repository], :desc => "Module repository to use"
+  end
+
+  desc "version", "Show the version information for this tool"
+  def version
+    say Puppet::Module::Tool.version
+  end
+
+  desc "generate USERNAME-MODNAME", "Generate boilerplate for a new module"
+  method_option_repository
+  def generate(name)
+    Puppet::Module::Tool::Applications::Generator.run(name, options)
+  end
+
+  # TODO Review whether the 'freeze' feature should be fixed or deleted.
+#  desc "freeze", "Freeze the module skeleton (to customize for `generate`)"
+#  def freeze
+#    Puppet::Module::Tool::Applications::Freezer.run(options)
+#  end
+
+  desc "clean", "Clears module cache for all repositories"
+  def clean
+    Puppet::Module::Tool::Applications::Cleaner.run(options)
+  end
+
+  desc "build [PATH_TO_MODULE]", "Build a module for release"
+  def build(path = nil)
+    Puppet::Module::Tool::Applications::Builder.run(find_module_root(path), options)
+  end
+
+  # TODO Review whether the 'release' feature should be fixed or deleted.
+#  desc "release FILENAME", "Release a module tarball (.tar.gz)"
+#  method_option_repository
+#  def release(filename)
+#    Puppet::Module::Tool::Applications::Releaser.run(filename, options)
+#  end
+
+  # TODO Review whether the 'unrelease' feature should be fixed or deleted.
+#  desc "unrelease MODULE_NAME", "Unrelease a module (eg, 'user-modname')"
+#  method_option :version, :alias => :v, :required => true, :desc => "The version to unrelease"
+#  method_option_repository
+#  def unrelease(module_name)
+#    Puppet::Module::Tool::Applications::Unreleaser.run(module_name,
+#                                                       options)
+#  end
+
+  desc "install MODULE_NAME_OR_FILE [OPTIONS]", "Install a module (eg, 'user-modname') from a repository or file"
+  method_option :version, :alias => :v, :desc => "Version to install (can be a requirement, eg '>= 1.0.3', defaults to latest version)"
+  method_option :force, :alias => :f, :type => :boolean, :desc => "Force overwrite of existing module, if any"
+  method_option_repository
+  def install(name)
+    Puppet::Module::Tool::Applications::Installer.run(name, options)
+  end
+
+  desc "search TERM", "Search the module repository for a module matching TERM"
+  method_option_repository
+  def search(term)
+    Puppet::Module::Tool::Applications::Searcher.run(term, options)
+  end
+
+  # TODO Review whether the 'register' feature should be fixed or deleted.
+#  desc "register MODULE_NAME", "Register a new module (eg, 'user-modname')"
+#  method_option_repository
+#  def register(module_name)
+#    Puppet::Module::Tool::Applications::Registrar.run(module_name, options)
+#  end
+
+  desc "changes [PATH_TO_MODULE]", "Show modified files in an installed module"
+  def changes(path = nil)
+    Puppet::Module::Tool::Applications::Checksummer.run(find_module_root(path), options)
+  end
+
+  desc "repository", "Show currently configured repository"
+  def repository
+    Puppet::Module::Tool.prepare_settings(options)
+    say Puppet.settings[:puppet_module_repository]
+  end
+
+  desc "usage", "Display detailed usage documentation for this tool"
+  def usage
+    Puppet::Module::Tool.prepare_settings(options)
+    if ENV['PAGER']
+      exec ENV['PAGER'], Puppet::Module::Tool.usage_filename
+    else
+      puts File.read(Puppet::Module::Tool.usage_filename)
+    end
+  end
+
+  desc "changelog", "Display the changelog for this tool"
+  def changelog
+    Puppet::Module::Tool.prepare_settings(options)
+    if ENV['PAGER']
+      exec ENV['PAGER'], Puppet::Module::Tool.changelog_filename
+    else
+      puts File.read(Puppet::Module::Tool.changelog_filename)
+    end
+  end
+
+  no_tasks do
+    def find_module_root(path)
+      for dir in [path, Dir.pwd].compact
+        if File.exist?(File.join(dir, 'Modulefile'))
+          return dir
+        end
+      end
+      abort "Could not find a valid module at #{path ? path.inspect : 'current directory'}"
+    end
+  end
+  
+end