omnibus 4.0.0 → 4.1.0

data/lib/omnibus/build_version_dsl.rb

@@ -14,6 +14,8 @@
 # limitations under the License.
 #
 
+require 'time'
+
 module Omnibus
   class BuildVersionDSL
     include Logging
@@ -33,7 +35,7 @@ module Omnibus
       @output_method = nil
 
       if version_string
-        @build_version = version_string
+        self.build_version = version_string
       elsif block_given?
         instance_eval(&block)
         construct_build_version unless from_dependency?
@@ -78,7 +80,7 @@ module Omnibus
     # @return [String]
     def explain
       if build_version
-        "Build Version: #{@build_version}"
+        "Build Version: #{build_version}"
       else
         if from_dependency?
           "Build Version will be determined from software '#{version_dependency}'"
@@ -105,6 +107,43 @@ module Omnibus
       source_options[:from_dependency]
     end
 
+    def build_version=(new_version)
+      @build_version = maybe_append_timestamp(new_version)
+    end
+
+    # Append the build_start_time to the given string if
+    # Config.append_timestamp is true
+    #
+    # @param [String] version
+    # @return [String]
+    def maybe_append_timestamp(version)
+      if Config.append_timestamp && !has_timestamp?(version)
+        [version, Omnibus::BuildVersion.build_start_time].join("+")
+      else
+        version
+      end
+    end
+
+    # Returns true if a given version string Looks like it was already
+    # created with a function that added a timestamp. The goal of this
+    # is to avoid breaking all of the people who are currently using
+    # BuildVersion.semver to create dates.
+    #
+    # @param [String] version
+    # @return [Boolean]
+    def has_timestamp?(version)
+      _ver, build_info = version.split('+')
+      return false if build_info.nil?
+      build_info.split('.').any? do |part|
+        begin
+          Time.strptime(part, Omnibus::BuildVersion::TIMESTAMP_FORMAT)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+    end
+
     # Determines the build_version based on source_type, output_method.
     #
     # @param version_source [Omnibus::Software] Software object from which the
@@ -120,10 +159,10 @@ module Omnibus
                   end
 
         output = output_method || :semver
-        @build_version = version.send(output)
+        self.build_version = version.send(output)
       when :version
         if version_source
-          @build_version = version_source.version
+          self.build_version = version_source.version
         else
           raise "Please tell me the source to get the version from"
         end

data/lib/omnibus/builder.rb

@@ -488,10 +488,16 @@ module Omnibus
     # @return (see #command)
     #
     def copy(source, destination, options = {})
-      build_commands << BuildCommand.new("copy `#{source}' to `#{destination}'") do
+      command = "copy `#{source}' to `#{destination}'"
+      build_commands << BuildCommand.new(command) do
         Dir.chdir(software.project_dir) do
-          FileSyncer.glob(source).each do |file|
-            FileUtils.cp_r(file, destination, options)
+          files = FileSyncer.glob(source)
+          if files.empty?
+            log.warn(log_key) {"no matched files for glob #{command}"}
+          else
+            files.each do |file|
+              FileUtils.cp_r(file, destination, options)
+            end
           end
         end
       end
@@ -499,7 +505,7 @@ module Omnibus
     expose :copy
 
     #
-    # Copy the given source to the destination. This method accepts a single
+    # Move the given source to the destination. This method accepts a single
     # file or a file pattern to match
     #
     # @param [String] source
@@ -511,10 +517,16 @@ module Omnibus
     # @return (see #command)
     #
     def move(source, destination, options = {})
-      build_commands << BuildCommand.new("move `#{source}' to `#{destination}'") do
+      command = "move `#{source}' to `#{destination}'"
+      build_commands << BuildCommand.new(command) do
         Dir.chdir(software.project_dir) do
-          FileSyncer.glob(source).each do |file|
-            FileUtils.mv(file, destination, options)
+          files = FileSyncer.glob(source)
+          if files.empty?
+            log.warn(log_key) {"no matched files for glob #{command}"}
+          else
+            files.each do |file|
+              FileUtils.mv(file, destination, options)
+            end
           end
         end
       end
@@ -534,10 +546,16 @@ module Omnibus
     # @return (see #command)
     #
     def link(source, destination, options = {})
-      build_commands << BuildCommand.new("link `#{source}' to `#{destination}'") do
+      command = "link `#{source}' to `#{destination}'"
+      build_commands << BuildCommand.new(command) do
         Dir.chdir(software.project_dir) do
-          FileSyncer.glob(source).each do |file|
-            FileUtils.ln_s(file, destination, options)
+          files = FileSyncer.glob(source)
+          if files.empty?
+            log.warn(log_key) {"no matched files for glob #{command}"}
+          else
+            files.each do |file|
+              FileUtils.ln_s(file, destination, options)
+            end
           end
         end
       end
@@ -580,7 +598,8 @@ module Omnibus
     #
     def build
       log.info(log_key) { 'Starting build' }
-
+      shasum # ensure shashum is calculated before build since the build can alter the shasum
+      log.internal(log_key) { "Cached builder checksum before build: #{shasum}"}
       if software.overridden?
         log.info(log_key) do
           "Version overridden from #{software.default_version} to "\

data/lib/omnibus/changelog.rb

@@ -0,0 +1,52 @@
+require 'omnibus/git_repository'
+
+module Omnibus
+  class ChangeLog
+    CHANGELOG_TAG = "ChangeLog-Entry"
+
+    attr_reader :end_ref
+    def initialize(start_ref=nil, end_ref="HEAD", git_repo=GitRepository.new('./'))
+      @start_ref = start_ref
+      @end_ref = end_ref
+      @git_repo = git_repo
+    end
+
+    def authors
+      git_repo.authors(start_ref, end_ref)
+    end
+
+    def changelog_entries
+      entries = []
+      current_entry = []
+      git_repo.commit_messages(start_ref, end_ref).each do |l|
+        if blank?(l)
+          entries << current_entry
+          current_entry = []
+        elsif tagged?(l)
+          entries << current_entry
+          current_entry = Array(l.sub(/^#{CHANGELOG_TAG}:[\s]*/, ""))
+        elsif !current_entry.empty?
+          current_entry << l
+        end
+      end
+      entries << current_entry
+      entries.reject(&:empty?).map(&:join)
+    end
+
+    def start_ref
+      @start_ref ||= git_repo.latest_tag
+    end
+
+    private
+
+    attr_reader :git_repo
+
+    def blank?(line)
+      line =~ /^[\s]*$/
+    end
+
+    def tagged?(line)
+      line =~ /^#{CHANGELOG_TAG}:/
+    end
+  end
+end

data/lib/omnibus/changelog_printer.rb

@@ -0,0 +1,77 @@
+module Omnibus
+  class ChangeLogPrinter
+
+    def initialize(changelog, diff, source_path="../")
+      @changelog = changelog
+      @diff = diff
+      @source_path = source_path
+    end
+
+    def print(new_version)
+      puts "## #{new_version} (#{Time.now.strftime('%Y-%m-%d')})"
+      print_changelog
+      if !diff.empty?
+        print_components
+        puts ""
+      end
+      print_contributors
+    end
+
+    private
+
+    attr_reader :changelog, :diff, :source_path
+
+    def print_changelog(cl=changelog, indent=0)
+      cl.changelog_entries.each do |entry|
+        puts "#{' ' * indent}* #{entry.sub("\n", "\n  #{' ' * indent}")}\n"
+      end
+    end
+
+    def print_components
+      puts "### Components\n"
+      print_new_components
+      print_updated_components
+      print_removed_components
+    end
+
+    def print_new_components
+      return if diff.added.empty?
+      puts "New Components"
+      diff.added.each do |entry|
+        puts "* #{entry[:name]} (#{entry[:new_version]})"
+      end
+      puts ""
+    end
+
+    def print_updated_components
+      return if diff.updated.empty?
+      puts "Updated Components"
+      diff.updated.each do |entry|
+        puts sprintf("* %s (%.8s -> %.8s)",
+                     entry[:name], entry[:old_version], entry[:new_version])
+        repo_path = ::File.join(source_path, entry[:name])
+        if entry[:source_type] == 'git' && ::File.directory?("#{repo_path}/.git")
+          cl = ChangeLog.new(entry[:old_version], entry[:new_version], GitRepository.new("#{repo_path}"))
+          print_changelog(cl, 2)
+        end
+      end
+      puts ""
+    end
+
+    def print_removed_components
+      return if diff.removed.empty?
+      puts "Removed Components"
+      diff.removed.each do |entry|
+        puts "* #{entry[:name]} (#{entry[:old_version]})"
+      end
+      puts ""
+    end
+
+    def print_contributors
+      puts "### Contributors\n"
+      changelog.authors.each do |author|
+        puts "* #{author}"
+      end
+    end
+  end
+end

data/lib/omnibus/cli.rb

@@ -61,12 +61,47 @@ module Omnibus
     #
     #   $ omnibus build chefdk
     #
+    method_option :output_manifest,
+      desc: "Create version-manifest.json in current directory at the end of the build",
+      type: :boolean,
+      default: true
+    method_option :use_manifest,
+      desc: "Use the given manifest when downloading software sources.",
+      type: :string,
+      default: nil
     desc 'build PROJECT', 'Build the given Omnibus project'
     def build(name)
-      project = Project.load(name)
+      manifest = if @options[:use_manifest]
+                   Omnibus::Manifest.from_file(@options[:use_manifest])
+                 else
+                   nil
+                 end
 
+      project = Project.load(name, manifest)
       say("Building #{project.name} #{project.build_version}...")
-      project.build_me
+      project.download
+      project.build
+
+      if @options[:output_manifest]
+        FileUtils.mkdir_p('pkg')
+        File.open(::File.join('pkg', 'version-manifest.json'), 'w') do |f|
+          f.write(project.built_manifest.to_json)
+        end
+      end
+    end
+
+
+    register(Command::ChangeLog, 'changelog', 'changelog [COMMAND]', 'Create and view changelogs')
+    CLI.tasks['changelog'].options = Command::ChangeLog.class_options
+
+    #
+    # Generate a version manifest for the given project definition
+    #
+    #   $ omnibus manifest PROJECT
+    #
+    desc 'manifest PROJECT', 'Print a manifest for the given Omnibus project'
+    def manifest(name)
+      puts JSON.pretty_generate(Project.load(name).built_manifest.to_hash)
     end
 
     #

data/lib/omnibus/cli/changelog.rb

@@ -0,0 +1,149 @@
+#
+# Copyright 2015 Chef Software, Inc.
+#
+# 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 'omnibus/changelog'
+require 'omnibus/changelog_printer'
+require 'omnibus/manifest_diff'
+require 'omnibus/semantic_version'
+
+module Omnibus
+  class Command::ChangeLog < Command::Base
+    namespace :changelog
+
+    #
+    # Generate a Changelog
+    #
+    #   $ omnibus changelog generate
+    #
+    method_option :source_path,
+    desc: "Path to local checkout of git dependencies",
+    type: :string,
+    default: "../"
+
+    method_option :starting_manifest,
+    desc: "Path to version-manifest from the last version (we attempt to pull it from the git history if not given)",
+    type: :string
+
+    method_option :ending_manifest,
+    desc: "Path to the version-manifest from the current version",
+    type: :string,
+    default: "version-manifest.json"
+
+    method_option :skip_components,
+    desc: "Don't include component changes in the changelog",
+    type: :boolean,
+    default: false
+
+    method_option :major,
+    desc: "Bump the major version",
+    type: :boolean,
+    default: false
+
+    method_option :minor,
+    desc: "Bump the minor version",
+    type: :boolean,
+    default: true
+
+    method_option :patch,
+    desc: "Bump the patch version",
+    type: :boolean,
+    default: false
+
+    method_option :version,
+    desc: "Explicit version for this changelog",
+    type: :string
+
+    desc 'generate [START] [END]', 'Generate a changelog for a new release'
+    def generate(start_ref=nil, end_ref=nil)
+      @start_ref = start_ref
+      @end_ref = end_ref
+      diff = if @options[:skip_components]
+               Omnibus::EmptyManifestDiff.new
+             else
+               Omnibus::ManifestDiff.new(old_manifest, new_manifest)
+             end
+
+      Omnibus::ChangeLogPrinter.new(ChangeLog.new(starting_revision, ending_revision),
+                                    diff,
+                                    @options[:source_path]).print(new_version)
+    end
+
+    private
+
+    def local_git_repo
+      GitRepository.new
+    end
+
+    def old_manifest
+      @old_manifest ||= if @options[:starting_manifest]
+                          Omnibus::Manifest.from_file(@options[:starting_manifest])
+                        else
+                          manifest_for_revision(starting_revision)
+                        end
+    end
+
+    def new_manifest
+      @new_manifest ||= if @options[:ending_manifest]
+                          Omnibus::Manifest.from_file(@options[:ending_manifest])
+                        else
+                          manifest_for_revision(ending_revision)
+                        end
+    end
+
+    def manifest_for_revision(rev)
+      Omnibus::Manifest.from_hash(JSON.parse(local_git_repo.file_at_revision("version-manifest.json", rev)))
+    end
+
+
+    def new_version
+      if @options[:version]
+        @options[:version]
+      elsif @options[:patch]
+        Omnibus::SemanticVersion.new(local_git_repo.latest_tag).next_patch.to_s
+      elsif @options[:minor] && !@options[:major] # minor is the default so it will always be true
+        Omnibus::SemanticVersion.new(local_git_repo.latest_tag).next_minor.to_s
+      elsif @options[:major]
+        Omnibus::SemanticVersion.new(local_git_repo.latest_tag).next_major.to_s
+      elsif @options[:ending_manifest]
+        new_manifest.build_version
+      end
+    end
+
+    # starting_revision is taken from:
+    # - value passed as the first argument
+    # - value found in the starting manifest
+    # - the latest git tag in the local repository
+    def starting_revision
+      @start_ref ||= if @options[:starting_manifest]
+                       old_manifest.build_git_revision
+                     else
+                       local_git_repo.latest_tag
+                     end
+    end
+
+    # ending_revision is taken from:
+    # - value passed as the first argument
+    # - value found in the ending manifest
+    # - HEAD in the current git repository
+    def ending_revision
+      @end_ref ||= if @options[:ending_manifest]
+                     new_manifest.build_git_revision
+                   else
+                     'HEAD'
+                   end
+    end
+  end
+end