semantic_puppet 0.1.0

data/semantic_puppet.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "semantic_puppet"
+
+spec = Gem::Specification.new do |s|
+  # Metadata
+  s.name        = "semantic_puppet"
+  s.version     = SemanticPuppet::VERSION
+  s.authors     = ["Puppet Labs"]
+  s.email       = ["info@puppetlabs.com"]
+  s.homepage    = "https://github.com/puppetlabs/semantic_puppet-gem"
+  s.summary     = "Useful tools for working with Semantic Versions."
+  s.description = %q{Tools used by Puppet to parse, validate, and compare Semantic Versions and Version Ranges and to query and resolve module dependencies.}
+
+  # Manifest
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*_spec.rb`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Dependencies
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "cane"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "redcarpet"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+PROJECT_ROOT = File.join(File.dirname(__FILE__), '..')
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before do
+    SemanticPuppet::Dependency.instance_variable_set(:@sources, nil)
+  end
+end

data/spec/unit/semantic_puppet/dependency/graph_node_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'semantic_puppet/dependency/graph_node'
+
+describe SemanticPuppet::Dependency::GraphNode do
+  let(:klass) do
+    Class.new do
+      include SemanticPuppet::Dependency::GraphNode
+
+      attr_accessor :name
+
+      def initialize(name, *satisfying)
+        @name = name
+        @satisfying = satisfying
+        @satisfying.each { |x| add_dependency(x.name) }
+      end
+
+      # @override
+      def satisfies_dependency?(node)
+        @satisfying.include?(node)
+      end
+    end
+  end
+
+  def instance(*args)
+    name = args.first.name unless args.empty?
+    klass.new(name || 'unnamed', *args)
+  end
+
+  context 'dependencies' do
+    subject { instance() }
+
+    example 'are added by #add_dependency' do
+      subject.add_dependency('foo')
+      subject.add_dependency('bar')
+      subject.add_dependency('baz')
+      expect(subject.dependency_names).to match_array %w[ foo bar baz ]
+    end
+
+    example 'are maintained in the #dependencies Hash' do
+      expect(subject.dependencies).to be_empty
+      subject.add_dependency('foo')
+      expect(subject.dependencies).to have_key 'foo'
+      expect(subject.dependencies).to respond_to :to_a
+    end
+  end
+
+  describe '#<<' do
+    let(:foo) { double('Node', :name => 'foo') }
+    let(:bar1) { double('Node', :name => 'bar', :'<=>' => 0) }
+    let(:bar2) { double('Node', :name => 'bar', :'<=>' => 0) }
+    let(:bar3) { double('Node', :name => 'bar') }
+    let(:baz) { double('Node', :name => 'baz') }
+
+    subject { instance(foo, bar1, bar2) }
+
+    it 'appends satisfying nodes to the dependencies' do
+      subject << foo << bar1 << bar2
+      expect(Array(subject.dependencies['foo'])).to match_array [ foo ]
+      expect(Array(subject.dependencies['bar'])).to match_array [ bar1, bar2 ]
+    end
+
+    it 'does not append nodes with unknown names' do
+      subject << baz
+      expect(Array(subject.dependencies['baz'])).to be_empty
+    end
+
+    it 'does not append unsatisfying nodes' do
+      subject << bar3
+      expect(Array(subject.dependencies['bar'])).to be_empty
+    end
+  end
+
+  describe '#satisfied' do
+    let(:foo) { double('Node', :name => 'foo') }
+    let(:bar) { double('Node', :name => 'bar') }
+
+    subject { instance(foo, bar) }
+
+    it 'is unsatisfied when no nodes have been appended' do
+      expect(subject).to_not be_satisfied
+    end
+
+    it 'is unsatisfied when any dependencies are missing' do
+      subject << foo
+      expect(subject).to_not be_satisfied
+    end
+
+    it 'is satisfied when all dependencies are fulfilled' do
+      subject << foo << bar
+      expect(subject).to be_satisfied
+    end
+  end
+
+  describe '#populate_children' do
+    let(:foo) { double('Node', :name => 'foo') }
+    let(:bar1) { double('Node', :name => 'bar', :'<=>' => 0) }
+    let(:bar2) { double('Node', :name => 'bar', :'<=>' => 0) }
+    let(:baz1) { double('Node', :name => 'baz', :'<=>' => 0) }
+    let(:baz2) { double('Node', :name => 'baz', :'<=>' => 0) }
+    let(:quxx) { double('Node', :name => 'quxx') }
+
+    subject do
+      graph = instance(foo, bar1, bar2, baz1, baz2)
+      graph << foo << bar1 << bar2 << baz1 << baz2
+    end
+
+    it 'saves all relevant nodes as its children' do
+      nodes = [ foo, bar2, baz1, quxx ]
+      nodes.each do |node|
+        allow(node).to receive(:populate_children)
+      end
+
+      subject.populate_children(nodes)
+
+      expected = { 'foo' => foo, 'bar' => bar2, 'baz' => baz1 }
+      expect(subject.children).to eql expected
+    end
+
+    it 'accepts a graph solution and populates it across all nodes' do
+      nodes = [ foo, bar2, baz1 ]
+      nodes.each do |node|
+        expect(node).to receive(:populate_children).with(nodes)
+      end
+
+      subject.populate_children(nodes)
+    end
+  end
+
+  describe '#<=>' do
+    it 'can be compared' do
+      a = instance(double('Node', :name => 'a'))
+      b = instance(double('Node', :name => 'b'))
+
+      expect(a).to be < b
+      expect(b).to be > a
+      expect([b, a].sort).to eql [a, b]
+      expect([a, b].sort).to eql [a, b]
+    end
+  end
+
+end

data/spec/unit/semantic_puppet/dependency/graph_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'semantic_puppet/dependency/graph'
+
+describe SemanticPuppet::Dependency::Graph do
+  Graph         = SemanticPuppet::Dependency::Graph
+  GraphNode     = SemanticPuppet::Dependency::GraphNode
+  ModuleRelease = SemanticPuppet::Dependency::ModuleRelease
+  Version       = SemanticPuppet::Version
+  VersionRange  = SemanticPuppet::VersionRange
+
+  describe '#initialize' do
+    it 'can be called without arguments' do
+      expect { Graph.new }.to_not raise_error
+    end
+
+    it 'implements the GraphNode protocol' do
+      expect(Graph.new).to be_a GraphNode
+    end
+
+    it 'adds constraints for every key in the passed hash' do
+      graph = Graph.new('foo' => 1, 'bar' => 2, 'baz' => 3)
+      expect(graph.constraints.keys).to match_array %w[ foo bar baz ]
+    end
+
+    it 'adds the named dependencies for every key in the passed hash' do
+      graph = Graph.new('foo' => 1, 'bar' => 2, 'baz' => 3)
+      expect(graph.dependency_names).to match_array %w[ foo bar baz ]
+    end
+  end
+
+  describe '#add_constraint' do
+    let(:graph) { Graph.new }
+
+    it 'can create a new constraint on a module' do
+      expect(graph.constraints.keys).to be_empty
+
+      graph.add_constraint('test', 'module-name', 'nil') { }
+      expect(graph.constraints.keys).to match_array %w[ module-name ]
+    end
+
+    it 'permits multiple constraints against the same module name' do
+      expect(graph.constraints.keys).to be_empty
+
+      graph.add_constraint('test', 'module-name', 'nil') { }
+      graph.add_constraint('test', 'module-name', 'nil') { }
+
+      expect(graph.constraints.keys).to match_array %w[ module-name ]
+    end
+  end
+
+  describe '#satisfies_dependency?' do
+    it 'is not satisfied by modules it does not depend on' do
+      graph = Graph.new('foo' => VersionRange.parse('1.x'))
+      release = ModuleRelease.new(nil, 'bar', Version.parse('1.0.0'))
+
+      expect(graph.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'is not satisfied by modules that do not fulfill the constraint' do
+      graph = Graph.new('foo' => VersionRange.parse('1.x'))
+      release = ModuleRelease.new(nil, 'foo', Version.parse('2.3.1'))
+
+      expect(graph.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'is not satisfied by modules that do not fulfill all the constraints' do
+      graph = Graph.new('foo' => VersionRange.parse('1.x'))
+      graph.add_constraint('me', 'foo', '1.2.3') do |node|
+        node.version.to_s == '1.2.3'
+      end
+
+      release = ModuleRelease.new(nil, 'foo', Version.parse('1.2.1'))
+
+      expect(graph.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'is satisfied by modules that do fulfill all the constraints' do
+      graph = Graph.new('foo' => VersionRange.parse('1.x'))
+      graph.add_constraint('me', 'foo', '1.2.3') do |node|
+        node.version.to_s == '1.2.3'
+      end
+
+      release = ModuleRelease.new(nil, 'foo', Version.parse('1.2.3'))
+
+      expect(graph.satisfies_dependency?(release)).to be true
+    end
+  end
+
+  describe '#add_graph_constraint' do
+    let(:graph) { Graph.new }
+
+    it 'can create a new constraint on a graph' do
+      expect(graph.constraints.keys).to be_empty
+
+      graph.add_graph_constraint('test') { }
+      expect(graph.constraints.keys).to match_array [ :graph ]
+    end
+
+    it 'permits multiple graph constraints' do
+      expect(graph.constraints.keys).to be_empty
+
+      graph.add_graph_constraint('test') { }
+      graph.add_graph_constraint('test') { }
+
+      expect(graph.constraints.keys).to match_array [ :graph ]
+    end
+  end
+
+  describe '#satisfies_graph?' do
+    it 'returns false if the solution violates a graph constraint' do
+      graph = Graph.new
+      graph.add_graph_constraint('me') do |nodes|
+        nodes.none? { |node| node.name =~ /z/ }
+      end
+
+      releases = [
+        double('Node', :name => 'foo'),
+        double('Node', :name => 'bar'),
+        double('Node', :name => 'baz'),
+      ]
+
+      expect(graph.satisfies_graph?(releases)).to_not be true
+    end
+
+    it 'returns false if the solution violates any graph constraint' do
+      graph = Graph.new
+      graph.add_graph_constraint('me') do |nodes|
+        nodes.all? { |node| node.name.length < 5 }
+      end
+      graph.add_graph_constraint('me') do |nodes|
+        nodes.none? { |node| node.name =~ /z/ }
+      end
+
+      releases = [
+        double('Node', :name => 'foo'),
+        double('Node', :name => 'bar'),
+        double('Node', :name => 'bangerang'),
+      ]
+
+      expect(graph.satisfies_graph?(releases)).to_not be true
+    end
+
+    it 'returns true if the solution violates no graph constraints' do
+      graph = Graph.new
+      graph.add_graph_constraint('me') do |nodes|
+        nodes.all? { |node| node.name.length < 5 }
+      end
+      graph.add_graph_constraint('me') do |nodes|
+        nodes.none? { |node| node.name =~ /z/ }
+      end
+
+      releases = [
+        double('Node', :name => 'foo'),
+        double('Node', :name => 'bar'),
+        double('Node', :name => 'boom'),
+      ]
+
+      expect(graph.satisfies_graph?(releases)).to be true
+    end
+  end
+
+end

data/spec/unit/semantic_puppet/dependency/module_release_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'semantic_puppet/dependency/module_release'
+
+describe SemanticPuppet::Dependency::ModuleRelease do
+  def source
+    @source ||= SemanticPuppet::Dependency::Source.new
+  end
+
+  def make_release(name, version, deps = {})
+    source.create_release(name, version, deps)
+  end
+
+  let(:no_dependencies) do
+    make_release('module', '1.2.3')
+  end
+
+  let(:one_dependency) do
+    make_release('module', '1.2.3', 'foo' => '1.0.0')
+  end
+
+  let(:three_dependencies) do
+    dependencies = { 'foo' => '1.0.0', 'bar' => '2.0.0', 'baz' => '3.0.0' }
+    make_release('module', '1.2.3', dependencies)
+  end
+
+  describe '#dependency_names' do
+
+    it "lists the names of all the release's dependencies" do
+      expect(no_dependencies.dependency_names).to    match_array %w[]
+      expect(one_dependency.dependency_names).to     match_array %w[foo]
+      expect(three_dependencies.dependency_names).to match_array %w[foo bar baz]
+    end
+
+  end
+
+  describe '#to_s' do
+
+    let(:name) { 'foobarbaz' }
+    let(:version) { '1.2.3' }
+
+    subject { make_release(name, version).to_s }
+
+    it { should =~ /#{name}/ }
+    it { should =~ /#{version}/ }
+
+  end
+
+  describe '#<<' do
+
+    it 'marks matching dependencies as satisfied' do
+      one_dependency << make_release('foo', '1.0.0')
+      expect(one_dependency).to be_satisfied
+    end
+
+    it 'does not mark mis-matching dependency names as satisfied' do
+      one_dependency << make_release('WAT', '1.0.0')
+      expect(one_dependency).to_not be_satisfied
+    end
+
+    it 'does not mark mis-matching dependency versions as satisfied' do
+      one_dependency << make_release('foo', '0.0.1')
+      expect(one_dependency).to_not be_satisfied
+    end
+
+  end
+
+  describe '#<=>' do
+
+    it 'considers releases with greater version numbers greater' do
+      expect(make_release('foo', '1.0.0')).to be > make_release('foo', '0.1.0')
+    end
+
+    it 'considers releases with lesser version numbers lesser' do
+      expect(make_release('foo', '0.1.0')).to be < make_release('foo', '1.0.0')
+    end
+
+    it 'orders releases with different names lexographically' do
+      expect(make_release('bar', '1.0.0')).to be < make_release('foo', '1.0.0')
+    end
+
+    it 'orders releases by name first' do
+      expect(make_release('bar', '2.0.0')).to be < make_release('foo', '1.0.0')
+    end
+
+  end
+
+  describe '#satisfied?' do
+
+    it 'returns true when there are no dependencies to satisfy' do
+      expect(no_dependencies).to be_satisfied
+    end
+
+    it 'returns false when no dependencies have been satisified' do
+      expect(one_dependency).to_not be_satisfied
+    end
+
+    it 'returns false when not all dependencies have been satisified' do
+      releases = %w[ 0.9.0 1.0.0 1.0.1 ].map { |ver| make_release('foo', ver) }
+      three_dependencies << releases
+
+      expect(three_dependencies).to_not be_satisfied
+    end
+
+    it 'returns false when not all dependency versions have been satisified' do
+      releases = %w[ 0.9.0 1.0.1 ].map { |ver| make_release('foo', ver) }
+      one_dependency << releases
+
+      expect(one_dependency).to_not be_satisfied
+    end
+
+    it 'returns true when all dependencies have been satisified' do
+      releases = %w[ 0.9.0 1.0.0 1.0.1 ].map { |ver| make_release('foo', ver) }
+      one_dependency << releases
+
+      expect(one_dependency).to be_satisfied
+    end
+
+  end
+
+  describe '#satisfies_dependency?' do
+
+    it 'returns false when there are no dependencies to satisfy' do
+      release = make_release('foo', '1.0.0')
+      expect(no_dependencies.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'returns false when the release does not match the dependency name' do
+      release = make_release('bar', '1.0.0')
+      expect(one_dependency.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'returns false when the release does not match the dependency version' do
+      release = make_release('foo', '4.0.0')
+      expect(one_dependency.satisfies_dependency?(release)).to_not be true
+    end
+
+    it 'returns true when the release matches the dependency' do
+      release = make_release('foo', '1.0.0')
+      expect(one_dependency.satisfies_dependency?(release)).to be true
+    end
+
+  end
+end