puppet-module 0.3.0

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

@@ -0,0 +1,18 @@
+module Puppet::Module::Tool
+  module Applications
+
+    require 'puppet/module/tool/applications/application'
+    require 'puppet/module/tool/applications/builder'
+    require 'puppet/module/tool/applications/checksummer'
+    require 'puppet/module/tool/applications/cleaner'
+    require 'puppet/module/tool/applications/freezer'
+    require 'puppet/module/tool/applications/generator'
+    require 'puppet/module/tool/applications/installer'
+    require 'puppet/module/tool/applications/registrar'
+    require 'puppet/module/tool/applications/releaser'
+    require 'puppet/module/tool/applications/searcher'
+    require 'puppet/module/tool/applications/unpacker'
+    require 'puppet/module/tool/applications/unreleaser'
+    
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'net/http'
+
+module Puppet::Module::Tool
+  module Applications
+
+    class Application
+      include Utils::Interrogation
+
+      def self.run(*args)
+        new(*args).run
+      end
+
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+        Puppet::Module::Tool.prepare_settings(options)
+      end
+
+      def repository
+        @repository ||= Repository.new(Puppet.settings[:puppet_module_repository])
+      end
+
+      def run
+        raise NotImplementedError, "Should be implemented in child classes."
+      end
+
+      def discuss(response, success, failure)
+        case response
+        when Net::HTTPOK, Net::HTTPCreated
+          say success
+        else
+          errors = PSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
+          say "#{failure} (#{errors})"
+        end
+      end
+
+      def metadata(require_modulefile = false)
+        unless @metadata
+          unless @path
+            abort "Could not determine module path"
+          end
+          @metadata = Metadata.new
+          contents = ContentsDescription.new(@path)
+          contents.annotate(@metadata)
+          checksums = Checksums.new(@path)
+          checksums.annotate(@metadata)
+          modulefile_path = File.join(@path, 'Modulefile')
+          if File.file?(modulefile_path)
+            Modulefile.evaluate(@metadata, modulefile_path)
+          elsif require_modulefile
+            abort "No Modulefile found."
+          end
+        end
+        @metadata
+      end
+
+      def load_modulefile!
+        @metadata = nil
+        metadata(true)
+      end
+
+      # Use to extract and validate a module name and version from a
+      #filename
+      # Note: Must have @filename set to use this
+      def parse_filename!
+        @release_name = File.basename(@filename,'.tar.gz')
+        @username, @module_name, @version = @release_name.split('-', 3)
+        @full_name = [@username, @module_name].join('-')
+        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

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

@@ -0,0 +1,88 @@
+require 'fileutils'
+
+module Puppet::Module::Tool
+
+  module Applications
+
+    class Builder < Application
+
+      def initialize(path, options)
+        @path = File.expand_path(path)
+        @pkg_path = File.join(@path, 'pkg')
+        super(options)
+      end
+
+      def run
+        load_modulefile!
+        create_directory
+        copy_contents
+        add_metadata
+        header "Building #{@path} for release"
+        tar
+        gzip
+        relative = Pathname.new(File.join(@pkg_path, filename('tar.gz'))).relative_path_from(Pathname.new(Dir.pwd))
+        # TODO Implement "release" feature.
+        ### say "Done. Now you probably want to:\n  $ puppet-module release #{relative}"
+        say "Done. Built: #{relative}"
+      end
+
+      private
+
+      def filename(ext)
+        ext.sub!(/^\./, '')
+        "#{metadata.release_name}.#{ext}"
+      end
+
+      def tar
+        tar_name = filename('tar')
+        Dir.chdir(@pkg_path) do
+          FileUtils.rm tar_name rescue nil
+          unless system "tar -cf #{tar_name} #{metadata.release_name}"
+            abort "Could not create #{tar_name}"
+          end
+        end
+      end
+
+      def gzip
+        Dir.chdir(@pkg_path) do
+          FileUtils.rm filename('tar.gz') rescue nil
+          unless system "gzip #{filename('tar')}"
+            abort "Could not compress #{filename('tar')}"
+          end
+        end
+      end
+
+      def create_directory
+        FileUtils.mkdir(@pkg_path) rescue nil
+        if File.directory?(build_path)
+          FileUtils.rm_rf(build_path)
+        end
+        FileUtils.mkdir(build_path)
+      end
+
+      def copy_contents
+        Dir[File.join(@path, '*')].each do |path|
+          case File.basename(path)
+          when *Puppet::Module::Tool::ARTIFACTS
+            next
+          else
+            FileUtils.cp_r path, build_path
+          end
+        end
+      end
+
+      def add_metadata
+        File.open(File.join(build_path, 'metadata.json'), 'w') do |f|
+          f.write(PSON.pretty_generate(metadata))
+        end
+      end
+
+      def build_path
+        @build_path ||= File.join(@pkg_path, metadata.release_name)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+module Puppet::Module::Tool
+  module Applications
+
+    class Checksummer < Application
+
+      def initialize(path, options = {})
+        @path = Pathname.new(path)
+        super(options)
+      end
+      
+      def run
+        if metadata_file.exist?
+          sums = Checksums.new(@path)
+          (metadata['checksums'] || {}).each do |child_path, canonical_checksum|
+            path = @path + child_path
+            if canonical_checksum != sums.checksum(path)
+              say child_path
+            end
+          end
+        else
+          abort "No metadata.json found."
+        end
+      end
+
+      private
+
+      def metadata
+        PSON.parse(metadata_file.read)
+      end
+
+      def metadata_file
+        (@path + 'metadata.json')
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+module Puppet::Module::Tool
+  module Applications
+
+    class Cleaner < Application
+      
+      def run
+        Puppet::Module::Tool::Cache.clean
+        puts "Cleaned module cache."
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+module Puppet::Module::Tool
+  module Applications
+
+    class Freezer < Application
+      # TODO Review whether the 'freeze' feature should be fixed or deleted.
+=begin
+      def skeleton
+        @skeleton ||= Skeleton.new
+      end
+        
+      def run
+        header "Freezing in #{skeleton.custom_path}"
+        skeleton.freeze!
+        say "Done.  Modify these files for the `generate` task."
+      end
+=end
+    end
+    
+  end
+end

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

@@ -0,0 +1,117 @@
+require 'pathname'
+require 'fileutils'
+require 'erb'
+
+module Puppet::Module::Tool
+  module Applications
+
+    class Generator < Application
+
+      def initialize(full_name, options)
+        begin
+          @metadata = Metadata.new(:full_name => full_name)
+        rescue ArgumentError
+          abort "Could not generate directory #{full_name.inspect}, you must specify a dash-separated username and module name."
+        end
+        super(options)
+      end
+
+      def skeleton
+        @skeleton ||= Skeleton.new
+      end
+      
+      def run
+        if destination.directory?
+          abort "#{destination} already exists."
+        end
+        header "Generating module at #{Dir.pwd}/#{@metadata.dashed_name}"
+        skeleton.path.find do |path|
+          if path == skeleton
+            destination.mkpath
+          else
+            node = Node.on(path, self)
+            if node
+              node.install!
+              say node.target
+            else
+              say "Could not generate from #{path}"
+            end
+          end
+        end
+      end
+      
+      def destination
+        @destination ||= Pathname.new(@metadata.dashed_name)
+      end
+
+      class Node
+        def self.types
+          @types ||= []
+        end
+        def self.inherited(klass)
+          types << klass
+        end
+        def self.on(path, generator)
+          klass = types.detect { |t| t.matches?(path) }
+          if klass
+            klass.new(path, generator)
+          end
+        end
+        def initialize(source, generator)
+          @generator = generator
+          @source = source
+        end
+        def read
+          @source.read
+        end
+        def target
+          target = @generator.destination + @source.relative_path_from(@generator.skeleton.path)
+          components = target.to_s.split(File::SEPARATOR).map do |part|
+            part == 'NAME' ? @generator.metadata.name : part
+          end
+          Pathname.new(components.join(File::SEPARATOR))
+        end
+        def install!
+          raise NotImplementedError, "Abstract"
+        end
+      end
+
+      class DirectoryNode < Node
+        def self.matches?(path)
+          path.directory?
+        end
+        def install!
+          target.mkpath
+        end
+      end
+
+      class ParsedFileNode < Node
+        def self.matches?(path)
+          path.file? && path.extname == '.erb'
+        end
+        def target
+          path = super
+          path.parent + path.basename('.erb')
+        end
+        def contents
+          template = ERB.new(read)
+          template.result(@generator.send(:binding))
+        end
+        def install!
+          target.open('w') { |f| f.write contents }
+        end
+      end
+
+      class FileNode < Node
+        def self.matches?(path)
+          path.file?
+        end
+        def install!
+          FileUtils.cp(@source, target)
+        end
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'open-uri'
+require 'pathname'
+require 'tmpdir'
+
+module Puppet::Module::Tool
+
+  module Applications
+
+    class Installer < Application
+
+      def initialize(name, options = {})
+        if File.exist?(name)
+          if File.directory?(name)
+            # TODO Unify this handling with that of Unpacker#check_clobber!
+            abort "Module already installed: #{name}"
+          end
+          @source = :filesystem
+          @filename = File.expand_path(name)
+          parse_filename!
+        else
+          @source = :repository
+          begin
+            @username, @module_name = Puppet::Module::Tool::username_and_modname_from(name)
+          rescue ArgumentError
+            abort "Could not install module with invalid name: #{name}"
+          end
+          @version_requirement = options[:version]
+        end
+        super(options)
+      end
+
+      def force?
+        options[:force]
+      end
+
+      def run
+        case @source
+        when :repository
+          if match['file']
+            begin
+              cache_path = repository.retrieve(match['file'])
+            rescue OpenURI::HTTPError => e
+              abort "Could not install module: #{e.message}"
+            end
+            Unpacker.run(cache_path, Dir.pwd, options)
+          else
+            abort "Malformed response from module repository."
+          end
+        when :filesystem
+          repository = Repository.new('file:///')
+          uri = URI.parse("file://#{File.expand_path(@filename)}")
+          cache_path = repository.retrieve(uri)
+          Unpacker.run(cache_path, Dir.pwd, options)
+        else
+          abort "Could not determine installation source"
+        end
+      end
+
+      private
+
+      def match
+        return @match ||= begin
+          url = repository.uri + "/users/#{@username}/modules/#{@module_name}/releases/find.json"
+          if @version_requirement
+            url.query = "version=#{URI.escape(@version_requirement)}"
+          end
+          begin
+            raw_result = read_match(url)
+          rescue => e
+            abort "Could not request version match (#{e.message})"
+          end
+          @match = PSON.parse(raw_result)
+        end
+      end
+
+      def read_match(url)
+        return url.read
+      end
+
+    end
+    
+  end
+end