puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+HERE = File.dirname(__FILE__) unless defined?(HERE)
+ROOT = File.join(HERE, "..") unless defined?(ROOT)
+
+$LOAD_PATH << File.join(ROOT, "lib")
+$LOAD_PATH << File.join(HERE, "support")
+
+require "yaml"
+if ENV["YAMLER"] && defined?(YAML::ENGINE)
+  YAML::ENGINE.yamler = ENV["YAMLER"]
+  puts "Running specs in Ruby #{RUBY_VERSION} with '#{YAML::ENGINE.yamler}' YAML engine."
+end
+
+require "safe_yaml"
+require "ostruct"
+require "hashie"
+require "heredoc_unindent"
+
+require File.join(HERE, "resolver_specs")

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/support/exploitable_back_door.rb

@@ -0,0 +1,29 @@
+class ExploitableBackDoor
+  def exploited?
+    @exploited_through_setter || @exploited_through_init_with || @exploited_through_ivars
+  end
+
+  def exploited_through_setter?
+    @exploited_through_setter
+  end
+
+  def exploited_through_init_with?
+    @exploited_through_init_with
+  end
+
+  def exploited_through_ivars?
+    self.instance_variables.any?
+  end
+
+  def init_with(command)
+    # Note: this is how bad this COULD be.
+    # system("#{command}")
+    @exploited_through_init_with = true
+  end
+
+  def []=(command, arguments)
+    # Note: this is how bad this COULD be.
+    # system("#{command} #{arguments}")
+    @exploited_through_setter = true
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/syck_resolver_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+if SafeYAML::YAML_ENGINE == "syck"
+  require "safe_yaml/syck_resolver"
+
+  describe SafeYAML::SyckResolver do
+    include ResolverSpecs
+    let(:resolver) { SafeYAML::SyckResolver.new }
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/transform/base64_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform do
+  it "should return the same encoding when decoding Base64" do
+    value = "c3VyZS4="
+    decoded = SafeYAML::Transform.to_proper_type(value, false, "!binary")
+
+    decoded.should == "sure."
+    decoded.encoding.should == value.encoding if decoded.respond_to?(:encoding)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/transform/to_date_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToDate do
+  it "returns true when the value matches a valid Date" do
+    subject.transform?("2013-01-01").should == [true, Date.parse("2013-01-01")]
+  end
+
+  it "returns false when the value does not match a valid Date" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value does not end with a Date" do
+    subject.transform?("2013-01-01\nNOT A DATE").should be_false
+  end
+
+  it "returns false when the value does not begin with a Date" do
+    subject.transform?("NOT A DATE\n2013-01-01").should be_false
+  end
+
+  it "correctly parses the remaining formats of the YAML spec" do
+    equivalent_values = [
+      "2001-12-15T02:59:43.1Z", # canonical
+      "2001-12-14t21:59:43.10-05:00", # iso8601
+      "2001-12-14 21:59:43.10 -5", # space separated
+      "2001-12-15 2:59:43.10" # no time zone (Z)
+    ]
+
+    equivalent_values.each do |value|
+      success, result = subject.transform?(value)
+      success.should be_true
+      result.should == Time.utc(2001, 12, 15, 2, 59, 43, 100000)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/transform/to_float_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToFloat do
+  it "returns true when the value matches a valid Float" do
+    subject.transform?("20.00").should == [true, 20.0]
+  end
+
+  it "returns false when the value does not match a valid Float" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value spans multiple lines" do
+    subject.transform?("20.00\nNOT A FLOAT").should be_false
+  end
+
+  it "correctly parses all formats in the YAML spec" do
+    # canonical
+    subject.transform?("6.8523015e+5").should == [true, 685230.15]
+
+    # exponentioal
+    subject.transform?("685.230_15e+03").should == [true, 685230.15]
+
+    # fixed
+    subject.transform?("685_230.15").should == [true, 685230.15]
+
+    # sexagesimal
+    subject.transform?("190:20:30.15").should == [true, 685230.15]
+
+    # infinity
+    subject.transform?("-.inf").should == [true, (-1.0 / 0.0)]
+
+    # not a number
+    # NOTE: can't use == here since NaN != NaN
+    success, result = subject.transform?(".NaN")
+    success.should be_true; result.should be_nan
+  end
+
+  # issue 29
+  it "returns false for the string '.'" do
+    subject.transform?(".").should be_false
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/transform/to_integer_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToInteger do
+  it "returns true when the value matches a valid Integer" do
+    subject.transform?("10").should == [true, 10]
+  end
+
+  it "returns false when the value does not match a valid Integer" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value spans multiple lines" do
+    subject.transform?("10\nNOT AN INTEGER").should be_false
+  end
+
+  it "allows commas in the number" do
+    subject.transform?("1,000").should == [true, 1000]
+  end
+
+  it "correctly parses numbers in octal format" do
+    subject.transform?("010").should == [true, 8]
+  end
+
+  it "correctly parses numbers in hexadecimal format" do
+    subject.transform?("0x1FF").should == [true, 511]
+  end
+
+  it "defaults to a string for a number that resembles octal format but is not" do
+    subject.transform?("09").should be_false
+  end
+
+  it "correctly parses 0 in decimal" do
+    subject.transform?("0").should == [true, 0]
+  end
+
+  it "defaults to a string for a number that resembles hexadecimal format but is not" do
+    subject.transform?("0x1G").should be_false
+  end
+
+  it "correctly parses all formats in the YAML spec" do
+    # canonical
+    subject.transform?("685230").should == [true, 685230]
+
+    # decimal
+    subject.transform?("+685_230").should == [true, 685230]
+
+    # octal
+    subject.transform?("02472256").should == [true, 685230]
+
+    # hexadecimal:
+    subject.transform?("0x_0A_74_AE").should == [true, 685230]
+
+    # binary
+    subject.transform?("0b1010_0111_0100_1010_1110").should == [true, 685230]
+
+    # sexagesimal
+    subject.transform?("190:20:30").should == [true, 685230]
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml/spec/transform/to_symbol_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToSymbol do
+  def with_symbol_deserialization_value(value)
+    symbol_deserialization_flag = SafeYAML::OPTIONS[:deserialize_symbols]
+    SafeYAML::OPTIONS[:deserialize_symbols] = value
+
+    yield
+
+  ensure
+    SafeYAML::OPTIONS[:deserialize_symbols] = symbol_deserialization_flag
+  end
+
+  def with_symbol_deserialization(&block)
+    with_symbol_deserialization_value(true, &block)
+  end
+
+  def without_symbol_deserialization(&block)
+    with_symbol_deserialization_value(false, &block)
+  end
+
+  it "returns true when the value matches a valid Symbol" do
+    with_symbol_deserialization { subject.transform?(":foo")[0].should be_true }
+  end
+
+  it "returns true when the value matches a valid String+Symbol" do
+    with_symbol_deserialization { subject.transform?(':"foo"')[0].should be_true }
+  end
+
+  it "returns false when symbol deserialization is disabled" do
+    without_symbol_deserialization { subject.transform?(":foo").should be_false }
+  end
+
+  it "returns false when the value does not match a valid Symbol" do
+    with_symbol_deserialization { subject.transform?("foo").should be_false }
+  end
+
+  it "returns false when the symbol does not begin the line" do
+    with_symbol_deserialization do
+      subject.transform?("NOT A SYMBOL\n:foo").should be_false
+    end
+  end
+
+  it "returns false when the symbol does not end the line" do
+    with_symbol_deserialization do
+      subject.transform?(":foo\nNOT A SYMBOL").should be_false
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/safe_yaml_patches.rb

@@ -0,0 +1,9 @@
+module SafeYAML
+  class Parse
+    class Date
+      def self.value(value)
+        Time.parse(value)
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/semantic/Gemfile

@@ -0,0 +1,20 @@
+source "https://rubygems.org"
+
+group :development do
+  gem 'rake'
+  gem 'rubygems-tasks'
+end
+
+group :test do
+  gem 'rspec'
+end
+
+group :metrics do
+  gem 'cane',      :platform => [ :mri_19, :mri_20, :mri_21 ]
+  gem 'simplecov', :platform => [ :mri_19, :mri_20, :mri_21 ]
+end
+
+group :doc do
+  gem 'yard', '~> 0.8', :platform => [ :mri_19, :mri_20, :mri_21 ]
+  gem 'redcarpet',      :platform => [ :mri_19, :mri_20, :mri_21 ]
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/semantic/PUPPET_README.md

@@ -0,0 +1,6 @@
+Semantic
+========
+
+Semantic 0.0.1
+
+Copied from https://github.com/puppetlabs/semantic/tree/6d17d5283e0868cfc3d74d1e9d37b572e1739b6e

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/semantic/Rakefile

@@ -0,0 +1,69 @@
+# RSpec tasks
+begin
+  require 'rspec/core/rake_task'
+
+  # Create the 'spec' task
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.rspec_opts = '--color'
+  end
+
+  namespace :spec do
+    desc "Run the test suite and generate coverage metrics"
+    task :coverage => [ :simplecov, :spec ]
+
+    # Add test coverage to the 'spec' task.
+    task :simplecov do
+      ENV['COVERAGE'] = '1'
+    end
+  end
+
+  task :default => :spec
+rescue LoadError
+  warn "[Warning]: Could not load `rspec`."
+end
+
+# YARD tasks
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+
+  YARD::Rake::YardocTask.new(:doc) do |yardoc|
+    yardoc.files = [ 'lib/**/*.rb', '-', '**/*.md' ]
+  end
+rescue LoadError
+  warn "[Warning]: Could not load `yard`."
+end
+
+# Cane tasks
+begin
+  require 'cane/rake_task'
+
+  Cane::RakeTask.new(:cane) do |cane|
+    cane.add_threshold 'coverage/.last_run.json', :>=, 100
+    cane.abc_max = 15
+  end
+
+  Rake::Task['cane'].prerequisites << Rake::Task['spec:coverage']
+  Rake::Task[:default].clear_prerequisites
+  task :default => :cane
+rescue LoadError
+  warn "[Warning]: Could not load `cane`."
+end
+
+# Gem tasks
+begin
+  require 'rubygems/tasks'
+
+  task :gem => 'gem:build'
+  task :validate => [ 'cane', 'doc', 'gem:validate' ]
+
+  namespace :gem do
+    Gem::Tasks.new(
+      :tag => { :format => 'v%s' },
+      :sign => { :checksum => true, :pgp => true },
+      :build => { :tar => true }
+    )
+  end
+rescue LoadError
+  warn "[Warning]: Could not load `rubygems/tasks`."
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/semantic/lib/semantic.rb

@@ -0,0 +1,7 @@
+module Semantic
+  autoload :Version, 'semantic/version'
+  autoload :VersionRange, 'semantic/version_range'
+  autoload :Dependency, 'semantic/dependency'
+
+  VERSION = '0.0.1'
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/semantic/lib/semantic/dependency.rb

@@ -0,0 +1,181 @@
+require 'semantic'
+
+module Semantic
+  module Dependency
+    extend self
+
+    autoload :Graph,         'semantic/dependency/graph'
+    autoload :GraphNode,     'semantic/dependency/graph_node'
+    autoload :ModuleRelease, 'semantic/dependency/module_release'
+    autoload :Source,        'semantic/dependency/source'
+
+    autoload :UnsatisfiableGraph, 'semantic/dependency/unsatisfiable_graph'
+
+    # @!group Sources
+
+    # @return [Array<Source>] a frozen copy of the {Source} list
+    def sources
+      (@sources ||= []).dup.freeze
+    end
+
+    # Appends a new {Source} to the current list.
+    # @param source [Source] the {Source} to add
+    # @return [void]
+    def add_source(source)
+      sources
+      @sources << source
+      nil
+    end
+
+    # Clears the current list of {Source}s.
+    # @return [void]
+    def clear_sources
+      sources
+      @sources.clear
+      nil
+    end
+
+    # @!endgroup
+
+    # Fetches a graph of modules and their dependencies from the currently
+    # configured list of {Source}s.
+    #
+    # @todo Return a specialized "Graph" object.
+    # @todo Allow for external constraints to be added to the graph.
+    # @see #sources
+    # @see #add_source
+    # @see #clear_sources
+    #
+    # @param modules [{ String => String }]
+    # @return [Graph] the root of a dependency graph
+    def query(modules)
+      constraints = Hash[modules.map { |k, v| [ k, VersionRange.parse(v) ] }]
+
+      graph = Graph.new(constraints)
+      fetch_dependencies(graph)
+      return graph
+    end
+
+    # Given a graph result from {#query}, this method will resolve the graph of
+    # dependencies, if possible, into a flat list of the best suited modules. If
+    # the dependency graph does not have a suitable resolution, this method will
+    # raise an exception to that effect.
+    #
+    # @param graph [Graph] the root of a dependency graph
+    # @return [Array<ModuleRelease>] the list of releases to act on
+    def resolve(graph)
+      catch :next do
+        return walk(graph, graph.dependencies.dup)
+      end
+      raise UnsatisfiableGraph.new(graph)
+    end
+
+    # Fetches all available releases for the given module name.
+    #
+    # @param name [String] the module name to find releases for
+    # @return [Array<ModuleRelease>] the available releases
+    def fetch_releases(name)
+      releases = {}
+
+      sources.each do |source|
+        source.fetch(name).each do |dependency|
+          releases[dependency.version] ||= dependency
+        end
+      end
+
+      return releases.values
+    end
+
+    private
+
+    # Iterates over a changing set of dependencies in search of the best
+    # solution available. Fitness is specified as meeting all the constraints
+    # placed on it, being {ModuleRelease#satisfied? satisfied}, and having the
+    # greatest version number (with stability being preferred over prereleases).
+    #
+    # @todo Traversal order is not presently guaranteed.
+    #
+    # @param graph [Graph] the root of a dependency graph
+    # @param dependencies [{ String => Array<ModuleRelease> }] the dependencies
+    # @param considering [Array<GraphNode>] the set of releases being tested
+    # @return [Array<GraphNode>] the list of releases to use, if successful
+    def walk(graph, dependencies, *considering)
+      return considering if dependencies.empty?
+
+      # Selecting a dependency from the collection...
+      name = dependencies.keys.sort.first
+      deps = dependencies.delete(name)
+
+      # ... (and stepping over it if we've seen it before) ...
+      unless (deps & considering).empty?
+        return walk(graph, dependencies, *considering)
+      end
+
+      # ... we'll iterate through the list of possible versions in order.
+      preferred_releases(deps).reverse_each do |dep|
+
+        # We should skip any releases that violate any module's constraints.
+        unless [graph, *considering].all? { |x| x.satisfies_constraints?(dep) }
+          next
+        end
+
+        # We should skip over any releases that violate graph-level constraints.
+        potential_solution = considering.dup << dep
+        unless graph.satisfies_graph? potential_solution
+          next
+        end
+
+        catch :next do
+          # After adding any new dependencies and imposing our own constraints
+          # on existing dependencies, we'll mark ourselves as "under
+          # consideration" and recurse.
+          merged = dependencies.merge(dep.dependencies) { |_,a,b| a & b }
+
+          # If all subsequent dependencies resolved well, the recursive call
+          # will return a completed dependency list. If there were problems
+          # resolving our dependencies, we'll catch `:next`, which will cause
+          # us to move to the next possibility.
+          return walk(graph, merged, *potential_solution)
+        end
+      end
+
+      # Once we've exhausted all of our possible versions, we know that our
+      # last choice was unusable, so we'll unwind the stack and make a new
+      # choice.
+      throw :next
+    end
+
+    # Given a {ModuleRelease}, this method will iterate through the current
+    # list of {Source}s to find the complete list of versions available for its
+    # dependencies.
+    #
+    # @param node [GraphNode] the node to fetch details for
+    # @return [void]
+    def fetch_dependencies(node, cache = {})
+      node.dependency_names.each do |name|
+        unless cache.key?(name)
+          cache[name] = fetch_releases(name)
+          cache[name].each { |dep| fetch_dependencies(dep, cache) }
+        end
+
+        node << cache[name]
+      end
+    end
+
+    # Given a list of potential releases, this method returns the most suitable
+    # releases for exploration. Only {ModuleRelease#satisfied? satisfied}
+    # releases are considered, and releases with stable versions are preferred.
+    #
+    # @param releases [Array<ModuleRelease>] a list of potential releases
+    # @return [Array<ModuleRelease>] releases open for consideration
+    def preferred_releases(releases)
+      satisfied = releases.select { |x| x.satisfied? }
+
+      if satisfied.any? { |x| x.version.stable? }
+        return satisfied.select { |x| x.version.stable? }
+      else
+        return satisfied
+      end
+    end
+  end
+end