builderator 0.3.15 → 1.0.0.pre.rc.1

data/lib/builderator/control/version/auto.rb

@@ -0,0 +1,48 @@
+module Builderator
+  module Control
+    class Version
+      ##
+      # Search through commits since current version for #TYPE tags
+      #
+      # Included in Version
+      ##
+      module Auto
+        DEFAULT_TYPE = 'patch'.freeze
+        MESSAGE_KEYWORDS = /#(?<type>build|prerelease|release|patch\-prerelease|patch|minor\-prerelease|minor|major\-prerelease|major)(?:=(?<prerelease>[a-zA-Z0-9\-_]+))?/
+
+        def auto_type
+          fail 'Version-bump type `auto` is unsuppoeted for this SCM. Version does not'\
+               ' have a valid `ref` value' if ref.nil?
+
+          ## Get commits since self.ref (e.g. commits since this tag)
+          history_since_current = SCM.history.take_while do |commit|
+            commit.id != ref
+          end
+
+          ## Search for the highest-precedence #TAG in those commit messages
+          ## Search from oldest-to-newest. Newer #TAGs of equal precedence win
+          result = history_since_current.reverse.reduce(nil) do |highest, commit|
+            ## Not going to bother parsing multiple matches. If you're
+            ## putting more than one #TYPE in your commit message, you
+            ## deserve what you get...
+            found_type = commit.message.scan(MESSAGE_KEYWORDS).first
+
+            ## No #TYPE in message
+            next highest if found_type.nil?
+
+            ## First match
+            next found_type if highest.nil?
+
+            ## Retrun higher precedence release type
+            RELEASE_TYPES[found_type.first.to_s] <= RELEASE_TYPES[highest.first.to_s] ? found_type : highest
+          end
+
+          return ['prerelease', nil] if result.nil? && is_prerelease
+          return [DEFAULT_TYPE, nil] if result.nil?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/version/bump.rb

@@ -0,0 +1,82 @@
+module Builderator
+  module Control
+    class Version
+      ##
+      # Increment version's parameters by specified steps
+      #
+      # Included in Version
+      ##
+      module Bump
+        def bump(type = 'auto', prerelease_name = nil) # rubocop:disable Metrics/PerceivedComplexity
+          ## Grok commits since current for a #TYPE string
+          type, prerelease_name = auto_type if type.to_s == 'auto'
+
+          fail "Unrecognized release type #{type}" unless RELEASE_TYPES.include?(type.to_s)
+          type_num = RELEASE_TYPES[type.to_s]
+
+          ##
+          # Reset lower-precendence parameters to nil/0
+          ##
+          self.build = nil if type_num < RELEASE_TYPES['build']
+
+          ## Clear pre-release flags
+          if type_num < RELEASE_TYPES['prerelease']
+            self.is_prerelease = false
+            self.prerelease_name = nil
+            self.prerelease_iteration = nil
+          end
+
+          self.patch = 0 if type_num < RELEASE_TYPES['patch']
+          self.minor = 0 if type_num < RELEASE_TYPES['minor']
+          self.major = 0 if type_num < RELEASE_TYPES['major']
+
+          ## Set new version's ref
+          self.ref = SCM.history.first.id
+
+          ##
+          # Increment specified parameters
+          ##
+          case type.to_s
+          when 'build'
+            if build.nil?
+              self.build = 0
+            else
+              self.build += 1
+            end
+
+          when 'prerelease'
+            ## Start a prerelease train from a new patch version
+            ## if it doesn't already exist
+            self.patch += 1 unless is_prerelease
+            prerelease(prerelease_name)
+
+          when 'release'
+            ## Remove pre-release parameters from the current patch
+            ## (already done above ^^)
+
+          when 'patch-prerelease'
+            ## Force a new pre-release train from a new patch version
+            self.patch += 1
+            prerelease(prerelease_name)
+
+          when 'patch' then self.patch += 1
+
+          when 'minor-prerelease'
+            self.minor += 1
+            prerelease(prerelease_name)
+
+          when 'minor' then self.minor += 1
+
+          when 'major-prerelease'
+            self.major += 1
+            prerelease(prerelease_name)
+
+          when 'major' then self.major += 1
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/version/comparable.rb

@@ -0,0 +1,77 @@
+module Builderator
+  module Control
+    class Version
+      ##
+      # Sort earliest -> latest
+      # (Array.last -> latest (e.g. 1.0.0), Array.first -> earliest(e.g. 0.0.1))
+      ##
+      module Comparable
+        include ::Comparable
+
+        def <=>(other)
+          ## Simple version comparison
+          return major <=> other.major unless same?(:major, other)
+          return minor <=> other.minor unless same?(:minor, other)
+          return patch <=> other.patch unless same?(:patch, other)
+
+          ## Prereleases: prerelease < non-prerelease
+          return compare(:is_prerelease, other) if one?(:is_prerelease, other)
+
+          if both?(:is_prerelease, other)
+            ## This is a little sketchy... We're assuming that pre-releases
+            ## have a lexicological order.
+            return prerelease_name <=> other.prerelease_name unless same?(:prerelease_name, other)
+            return prerelease_iteration <=> other.prerelease_iteration unless same?(:prerelease_iteration, other)
+          end
+
+          ## Build number. With build number > without build number
+          compare(:build, other)
+        end
+
+        private
+
+        ## this == that
+        def same?(parameter, other)
+          send(parameter) == other.send(parameter)
+        end
+
+        ## this && that
+        def both?(parameter, other)
+          send(parameter) && other.send(parameter)
+        end
+
+        ## this ^ that (XOR)
+        def one?(parameter, other)
+          (send(parameter)) ^ (other.send(parameter))
+        end
+
+        ## this || that
+        def either?(parameter, other)
+          send(parameter) || other.send(parameter)
+        end
+
+        ## !(this || that)
+        def neither?(parameter, other)
+          !either?(parameter, other)
+        end
+
+        ## Compare with support for `nil` values
+        def compare(parameter, other)
+          a = send(parameter)
+          b = other.send(parameter)
+
+          ## NilClass, TrueClass, and FalseClass' <=> operators return nil
+          return a <=> b unless a.nil? || b.nil? ||
+                                a.is_a?(TrueClass) || b.is_a?(TrueClass) ||
+                                a.is_a?(FalseClass) || b.is_a?(FalseClass)
+
+          return 1 if a && !b
+          return -1 if !a && b
+
+          ## a && b || !a && !b
+          0
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/version/git.rb

@@ -0,0 +1,45 @@
+require_relative './scm'
+require_relative '../../util'
+
+module Builderator
+  module Control
+    # :nodoc:
+    class Version
+      ##
+      # SCM implementation for Git
+      ##
+      module Git
+        extend SCM
+
+        COMMIT_FORMAT = /^(?<hash>[a-f0-9]+)(?:\s+\((?<tags>.+?)\))?\s+(?<message>.+)$/
+        TAG_FORMAT = %r{tag: ([a-zA-Z0-9\.\-\+/_]+)}
+
+        ## Is there a .git repo in the project root?
+        def self.supported?
+          Util.relative_path('.git').exist?
+        end
+
+        def self._history
+          `git log --pretty='format:%H %d %s' HEAD`.chomp
+            .split("\n")
+            .map { |string| string.match(COMMIT_FORMAT) }
+            .reject(&:nil?)
+            .map do |commit|
+              {
+                :id => commit[:hash],
+                :message => commit[:message]
+              }.tap do |c|
+                tag_match = commit[:tags].scan(TAG_FORMAT)
+                            .flatten
+                            .reject(&:nil?) unless commit[:tags].nil?
+
+                c[:tags] = tag_match unless tag_match.nil? || tag_match.empty?
+              end
+            end
+        end
+      end
+
+      SCM.register(Git)
+    end
+  end
+end

data/lib/builderator/control/version/scm.rb

@@ -0,0 +1,92 @@
+module Builderator
+  module Control
+    class Version
+      ##
+      # Generic SCM interface
+      ##
+      module SCM
+        ## Fetch and cache history for the current HEAD/TIP
+        def history
+          @history ||= _history.map { |commit| Commit.new(commit) }
+        end
+
+        ## Find all tags in the branch's history
+        def tags
+          @tags ||= _tags
+                    .map { |tag, ref| Version.from_string(tag, :ref => ref) }
+                    .sort
+        end
+
+        ##
+        # OVERRIDE: Return true if this provider will work for `path`
+        ##
+        def supported?
+          fail 'Method `supported?` must be implemented in SCM providers!'
+        end
+
+        ##
+        # OVERRIDE: Return an array of hashes with keys
+        # - id -> SCM commit identity
+        # - message -> SCM commit message
+        # - tags -> nil or an array of strings
+        ##
+        def _history
+          fail 'Method `_history` must be implemented in SCM providers!'
+        end
+
+        ##
+        # OVERRIDE: Return an array of [tag, commit-id] tuples
+        ##
+        def _tags
+          history.reject { |commit| commit.tags.empty? }
+            .map { |commit| commit.tags.map { |tag| [tag, commit.id] } }
+            .each_with_object([]) { |commit, tags| tags.push(*commit) }
+        end
+
+        class << self
+          def history
+            provider.history
+          end
+
+          def tags
+            provider.tags
+          end
+
+          def register(klass)
+            fail 'Provider module must extend '\
+                 'Builderator::Control::Version::SCM' unless
+                 klass.singleton_class.include?(SCM)
+
+            ## Make newer providers override those with the same capability
+            providers.unshift(klass)
+          end
+
+          def providers
+            @providers ||= []
+          end
+
+          ## Find a version provider for this build
+          def provider
+            providers.find(&:supported?).tap do |found|
+              fail 'Builderator::Control::Version: '\
+                   'Unsupported SCM' if found.nil?
+            end
+          end
+        end
+
+        ## An SCM commit entity
+        class Commit
+          attr_reader :id
+          attr_reader :message
+          attr_reader :tags
+
+          def initialize(match)
+            @id = match[:id]
+            @message = match[:message]
+            @tags = match.fetch(:tags, [])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/builderator/interface.rb

@@ -0,0 +1,67 @@
+require 'erb'
+require 'fileutils'
+require 'securerandom'
+
+require_relative './config/attributes'
+require_relative './config/rash'
+require_relative './util'
+
+module Builderator
+  ##
+  # Base class for integration interfaces
+  ##
+  class Interface
+    class << self
+      def command(arg = nil)
+        @command = arg unless arg.nil?
+        @command
+      end
+
+      def from_gem(arg = nil)
+        @from_gem = arg unless arg.nil?
+        @from_gem || @command
+      end
+
+      def template(arg = nil)
+        @template = arg unless arg.nil?
+        @template
+      end
+    end
+
+    ## Is vagrant in this bundle?
+    def bundled?
+      Gem.loaded_specs.key?(self.class.from_gem)
+    end
+
+    def which
+      return self.class.command if bundled?
+
+      ## Not in the bundle. Use system path
+      `which #{self.class.command}`.chomp.tap { |path| fail "Unable to locate a #{self.class.command} executable" if path.empty? }
+    end
+    alias_method :command, :which
+
+    def directory
+      Util.workspace
+    end
+
+    def render
+      ERB.new(Util.source_path(self.class.template).binread,
+              nil, '-', '@output_buffer').result(Config.instance_eval('binding'))
+    end
+
+    def source
+      fail 'Interface does not provide a source!'
+    end
+
+    def write
+      directory.mkpath
+      source.write(render)
+      self
+    end
+
+    def clean
+      source.unlink
+    end
+  end
+end

data/lib/builderator/interface/berkshelf.rb

@@ -0,0 +1,38 @@
+require_relative '../interface'
+require_relative '../util'
+
+module Builderator
+  # :nodoc:
+  class Interface
+    class << self
+      def berkshelf
+        @berkshelf ||= Berkshelf.new
+      end
+    end
+
+    ##
+    # Render an updated Berksfile
+    ##
+    class Berkshelf < Interface
+      from_gem 'berkshelf'
+      command 'berks'
+      template 'template/Berksfile.erb'
+
+      def vendor
+        Config.local.cookbook_path
+      end
+
+      def lockfile
+        Util.workspace('Berksfile.lock')
+      end
+
+      def berkshelf_config
+        Config.cookbook.berkshelf_config
+      end
+
+      def source
+        directory.join('Berksfile')
+      end
+    end
+  end
+end