buildpack-support 1.0.0

data/lib/buildpack_support/to_b.rb

@@ -0,0 +1,38 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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.
+
+# A mixin that adds the ability to turn a +String+ into a boolean
+class String
+
+  # Converts a +String+ to a boolean
+  #
+  # @return [Boolean] +true+ if +<STRING>.downcase == 'true'+.  +false+ otherwise
+  def to_b
+    downcase == 'true'
+  end
+
+end
+
+# A mixin that adds the ability to turn a +nil+ into a boolean
+class NilClass
+
+  # Converts a +nil+ to a boolean
+  #
+  # @return [Boolean] +false+ always
+  def to_b
+    false
+  end
+
+end

data/lib/buildpack_support/tokenized_version.rb

@@ -0,0 +1,157 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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 'buildpack_support'
+
+module BuildpackSupport
+
+  # A utility for manipulating JRE version numbers.
+  class TokenizedVersion < Array
+    include Comparable
+
+    # The wildcard component.
+    WILDCARD = '+'
+
+    # Create a tokenized version based on the input string.
+    #
+    # @param [String] version a version string
+    # @param [Boolean] allow_wildcards whether or not to allow '+' as the last component to represent a wildcard
+    def initialize(version, allow_wildcards = true)
+      @version = version
+      @version = WILDCARD if !@version && allow_wildcards
+
+      major, tail      = major_or_minor_and_tail @version
+      minor, tail      = major_or_minor_and_tail tail
+      micro, qualifier = micro_and_qualifier tail
+
+      concat [major, minor, micro, qualifier]
+      validate allow_wildcards
+    end
+
+    # Compare this to another array
+    #
+    # @return [Integer] A numerical representation of the comparison between two instances
+    def <=>(other)
+      comparison = 0
+      i          = 0
+      while comparison == 0 && i < 3
+        comparison = self[i].to_i <=> other[i].to_i
+        i          += 1
+      end
+      comparison = qualifier_compare(non_nil_qualifier(self[3]), non_nil_qualifier(other[3])) if comparison == 0
+
+      comparison
+    end
+
+    # Convert this to a string
+    #
+    # @return [String] a string representation of this tokenized version
+    def to_s
+      @version
+    end
+
+    # Check that this version has at most the given number of components.
+    #
+    # @param [Integer] maximum_components the maximum number of components this version is allowed to have
+    # @raise if this version has more than the given number of components
+    def check_size(maximum_components)
+      fail "Malformed version #{self}: too many version components" if self[maximum_components]
+    end
+
+    private
+
+    COLLATING_SEQUENCE = (['-', '.'] + ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a).freeze
+
+    private_constant :COLLATING_SEQUENCE
+
+    def char_compare(c1, c2)
+      COLLATING_SEQUENCE.index(c1) <=> COLLATING_SEQUENCE.index(c2)
+    end
+
+    def major_or_minor_and_tail(s)
+      if s.nil? || s.empty?
+        major_or_minor, tail = nil, nil
+      else
+        fail "Invalid version '#{s}': must not end in '.'" if s[-1] == '.'
+        fail "Invalid version '#{s}': missing component" if s =~ /\.[\._]/
+        tokens = s.match(/^([^\.]+)(?:\.(.*))?/)
+
+        major_or_minor, tail = tokens[1..-1]
+
+        fail "Invalid major or minor version '#{major_or_minor}'" unless valid_major_minor_or_micro major_or_minor
+      end
+
+      [major_or_minor, tail]
+    end
+
+    def micro_and_qualifier(s)
+      if s.nil? || s.empty?
+        micro, qualifier = nil, nil
+      else
+        fail "Invalid version '#{s}': must not end in '_'" if s[-1] == '_'
+        tokens = s.match(/^([^\_]+)(?:_(.*))?/)
+
+        micro, qualifier = tokens[1..-1]
+
+        fail "Invalid micro version '#{micro}'" unless valid_major_minor_or_micro micro
+        fail "Invalid qualifier '#{qualifier}'" unless valid_qualifier qualifier
+      end
+
+      [micro, qualifier]
+    end
+
+    def minimum_qualifier_length(a, b)
+      [a.length, b.length].min
+    end
+
+    def qualifier_compare(a, b)
+      comparison = 0
+
+      i = 0
+      until comparison != 0 || i == minimum_qualifier_length(a, b)
+        comparison = char_compare(a[i], b[i])
+        i          += 1
+      end
+
+      comparison = a.length <=> b.length if comparison == 0
+
+      comparison
+    end
+
+    def non_nil_qualifier(qualifier)
+      qualifier.nil? ? '' : qualifier
+    end
+
+    def validate(allow_wildcards)
+      wildcarded = false
+      each do |value|
+        fail "Invalid version '#{@version}': wildcards are not allowed this context" if value == WILDCARD && !allow_wildcards
+
+        fail "Invalid version '#{@version}': no characters are allowed after a wildcard" if wildcarded && value
+        wildcarded = true if value == WILDCARD
+      end
+      fail "Invalid version '#{@version}': missing component" if !wildcarded && compact.length < 3
+    end
+
+    def valid_major_minor_or_micro(major_minor_or_micro)
+      major_minor_or_micro =~ /^[\d]*$/ || major_minor_or_micro =~ /^\+$/
+    end
+
+    def valid_qualifier(qualifier)
+      qualifier.nil? || qualifier.empty? || qualifier =~ /^[-\.a-zA-Z\d]*$/ || qualifier =~ /^\+$/
+    end
+  end
+
+end

data/lib/buildpack_support/version.rb

@@ -0,0 +1,23 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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 'buildpack_support'
+
+module BuildpackSupport
+
+  # The version of the gem
+  VERSION = '1.0.0'
+
+end

data/spec/buildpack_support/base_buildpack_spec.rb

@@ -0,0 +1,112 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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 'spec_helper'
+require 'buildpack_support/base_buildpack'
+require 'buildpack_support/test/console_helper'
+require 'buildpack_support/test/logging_helper'
+require 'buildpack_support/test/scratch_helper'
+
+describe BuildpackSupport::BaseBuildpack do
+  include_context 'console_helper'
+  include_context 'logging_helper'
+  include_context 'scratch_helper'
+
+  let(:component1) { double 'component1', class: 'Component1Class', detect: nil }
+  let(:component2) { double 'component2', class: 'Component2Class', detect: %w(tag1 tag2) }
+  let(:component3) { double 'component3', class: 'Component3Class', detect: %w(tag3 tag4) }
+
+  let(:buildpack) do
+    buildpack = nil
+    StubBuildpackClass.with_buildpack(scratch_dir, 'Error %s') { |b| buildpack = b }
+    buildpack
+  end
+
+  it 'should fail to detect' do
+    expect { buildpack.detect }.to raise_error("Method 'detect' must be defined")
+  end
+
+  it 'should fail to compile' do
+    expect { buildpack.compile }.to raise_error("Method 'compile' must be defined")
+  end
+
+  it 'should fail to release' do
+    expect { buildpack.release }.to raise_error("Method 'release' must be defined")
+  end
+
+  it 'handles exceptions correctly' do
+    expect { with_buildpack { |_buildpack| fail 'an exception' } }.to raise_error SystemExit
+    expect(stderr.string).to match(/an exception/)
+  end
+
+  it 'should require files needed for components' do
+    expect(buildpack).to receive(:require).with('test_component')
+    buildpack.require_component Pathname.new('spec/fixtures'), 'test-component'
+  end
+
+  it 'should not require files needed for components if they do not exist',
+     log_level: 'debug' do
+    expect(buildpack).not_to receive(:require).with('another_test_component')
+    buildpack.require_component Pathname.new('spec/fixtures'), 'another-test-component'
+    expect(stderr.string).to match('Cannot require another-test-component because spec/fixtures/another_test_component.rb does not exist')
+  end
+
+  it 'should return detected components and their tags' do
+    components, tags = buildpack.detection 'test', [component1, component2, component3], false
+    expect(components).not_to include(component1)
+    expect(components).to include(component2, component3)
+    expect(tags).to include(%w(tag1 tag2), %w(tag3 tag4))
+  end
+
+  it 'should return no components or tags when no components are detected and unique is true' do
+    components, tags = buildpack.detection 'test', [component1], true
+    expect(components).to eq([])
+    expect(tags).to eq([])
+  end
+
+  it 'should return a component and its tags when unique is true' do
+    components, tags = buildpack.detection 'test', [component2], true
+    expect(components).to include(component2)
+    expect(tags).to include(%w(tag1 tag2))
+  end
+
+  it 'should raise an error when more than one component is detected and unique is true' do
+    expect { buildpack.detection 'test', [component1, component2, component3], true }.to raise_error('Application can be run by more than one test: Component2 Class, Component3 Class')
+  end
+
+  it 'should return detected components' do
+    components = buildpack.component_detection 'test', [component1, component2, component3], false
+    expect(components).not_to include(component1)
+    expect(components).to include(component2, component3)
+  end
+
+  it 'should return detected tags' do
+    tags = buildpack.tag_detection 'test', [component1, component2, component3], false
+    expect(tags).to include(%w(tag1 tag2), %w(tag3 tag4))
+  end
+
+  def with_buildpack
+    described_class.with_buildpack(scratch_dir, 'Error %s') do |buildpack|
+      yield buildpack
+    end
+  end
+
+end
+
+class StubBuildpackClass < BuildpackSupport::BaseBuildpack
+
+  public :component_detection, :detection, :require_component, :tag_detection
+
+end

data/spec/buildpack_support/buildpack_version_spec.rb

@@ -0,0 +1,122 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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 'spec_helper'
+require 'buildpack_support/buildpack_version'
+require 'buildpack_support/test/environment_helper'
+require 'buildpack_support/test/logging_helper'
+require 'pathname'
+
+describe BuildpackSupport::BuildpackVersion do
+  include_context 'environment_helper'
+  include_context 'logging_helper'
+
+  let(:buildpack_version) { described_class.new }
+
+  before do |example|
+    configuration = example.metadata[:configuration] || {}
+    allow_any_instance_of(BuildpackSupport::ConfigurationUtils).to receive(:load).with('version')
+                                                                   .and_return(configuration)
+  end
+
+  it 'should create offline version string from config/version.yml',
+     log_level:     'DEBUG',
+     configuration: { 'hash'   => 'test-hash', 'offline' => true,
+                      'remote' => 'test-remote', 'version' => 'test-version' } do
+
+    expect(buildpack_version.to_s).to match(/test-version (offline) | test-remote#test-hash/)
+    expect(buildpack_version.to_s(false)).to match(/test-version-offline-test-remote#test-hash/)
+    expect(stderr.string).to match(/test-version (offline) | test-remote#test-hash/)
+  end
+
+  it 'should create online version string from config/version.yml',
+     log_level:     'DEBUG',
+     configuration: { 'hash'   => 'test-hash', 'offline' => false,
+                      'remote' => 'test-remote', 'version' => 'test-version' } do
+
+    expect(buildpack_version.to_s).to match(/test-version | test-remote#test-hash/)
+    expect(buildpack_version.to_s(false)).to match(/test-version-test-remote#test-hash/)
+    expect(stderr.string).to match(/test-version | test-remote#test-hash/)
+  end
+
+  it 'should create version string from git repository if no config/version.yml exists',
+     log_level: 'DEBUG' do
+
+    git_dir = Pathname.new('.git').expand_path
+
+    allow_any_instance_of(described_class).to receive(:system)
+                                              .with('which git > /dev/null')
+                                              .and_return(true)
+    allow_any_instance_of(described_class).to receive(:`)
+                                              .with("git --git-dir=#{git_dir} rev-parse --short HEAD")
+                                              .and_return('test-hash')
+    allow_any_instance_of(described_class).to receive(:`)
+                                              .with("git --git-dir=#{git_dir} config --get remote.origin.url")
+                                              .and_return('test-remote')
+
+    expect(buildpack_version.to_s).to match(/test-remote#test-hash/)
+    expect(buildpack_version.to_s(false)).to match(/test-remote#test-hash/)
+    expect(stderr.string).to match(/test-remote#test-hash/)
+  end
+
+  it 'should create unknown version string if no config/version.yml exists and it is not in a git repository',
+     log_level: 'DEBUG' do
+
+    allow_any_instance_of(described_class).to receive(:system).with('which git > /dev/null').and_return(false)
+
+    expect(buildpack_version.to_s).to match(/unknown/)
+    expect(buildpack_version.to_s(false)).to match(/unknown/)
+    expect(stderr.string).to match(/unknown/)
+  end
+
+  it 'should create a has from the values',
+     configuration: { 'hash'   => 'test-hash', 'offline' => true,
+                      'remote' => 'test-remote', 'version' => 'test-version' } do |example|
+
+    allow_any_instance_of(described_class).to receive(:system).with('which git > /dev/null').and_return(false)
+
+    expect(buildpack_version.to_hash).to eq(example.metadata[:configuration])
+  end
+
+  it 'should exclude non-populated values from the hash' do
+    allow_any_instance_of(described_class).to receive(:system).with('which git > /dev/null').and_return(false)
+
+    expect(buildpack_version.to_hash).to eq({})
+  end
+
+  context do
+
+    let(:environment) { { 'OFFLINE' => 'true' } }
+
+    it 'should pick up offline from the environment' do
+      allow_any_instance_of(described_class).to receive(:system).with('which git > /dev/null').and_return(false)
+
+      expect(buildpack_version.offline).to be
+    end
+
+  end
+
+  context do
+
+    let(:environment) { { 'VERSION' => 'test-version' } }
+
+    it 'should pick up version from the environment' do
+      allow_any_instance_of(described_class).to receive(:system).with('which git > /dev/null').and_return(false)
+
+      expect(buildpack_version.version).to match(/test-version/)
+    end
+
+  end
+
+end