puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/diff.rb

@@ -0,0 +1,77 @@
+require 'tempfile'
+
+# Provide a diff between two strings.
+module Puppet::Util::Diff
+  include Puppet::Util
+  require 'tempfile'
+
+  def diff(old, new)
+    return '' unless diff_cmd = Puppet[:diff] and diff_cmd != ""
+
+    command = [diff_cmd]
+    if args = Puppet[:diff_args] and args != ""
+      command << args
+    end
+    command << old << new
+    execute(command, :failonfail => false)
+  end
+
+  module_function :diff
+
+  # return diff string of two input strings
+  # format defaults to unified
+  # context defaults to 3 lines
+  def lcs_diff(data_old, data_new, format=:unified, context_lines=3)
+    unless Puppet.features.diff?
+      Puppet.warning "Cannot provide diff without the diff/lcs Ruby library"
+      return ""
+    end
+    data_old = data_old.split(/\n/).map! { |e| e.chomp }
+    data_new = data_new.split(/\n/).map! { |e| e.chomp }
+
+    output = ""
+
+    diffs = ::Diff::LCS.diff(data_old, data_new)
+    return output if diffs.empty?
+
+    oldhunk = hunk = nil
+    file_length_difference = 0
+
+    diffs.each do |piece|
+      begin
+
+        hunk = ::Diff::LCS::Hunk.new(
+          data_old, data_new, piece,
+            context_lines,
+
+            file_length_difference)
+        file_length_difference = hunk.file_length_difference
+      next unless oldhunk
+      # Hunks may overlap, which is why we need to be careful when our
+      # diff includes lines of context. Otherwise, we might print
+      # redundant lines.
+      if (context_lines > 0) and hunk.overlaps?(oldhunk)
+        hunk.unshift(oldhunk)
+      else
+        output << oldhunk.diff(format)
+      end
+      ensure
+        oldhunk = hunk
+        output << "\n"
+      end
+    end
+
+    # Handle the last remaining hunk
+    output << oldhunk.diff(format) << "\n"
+  end
+
+  def string_file_diff(path, string)
+    tempfile = Tempfile.new("puppet-diffing")
+    tempfile.open
+    tempfile.print string
+    tempfile.close
+    notice "\n" + diff(path, tempfile.path)
+    tempfile.delete
+  end
+end
+

data/lib/vendor/puppet/util/docs.rb

@@ -0,0 +1,123 @@
+# Some simple methods for helping manage automatic documentation generation.
+module Puppet::Util::Docs
+  # Specify the actual doc string.
+  def desc(str)
+    @doc = str
+  end
+
+  # Add a new autodoc block.  We have to define these as class methods,
+  # rather than just sticking them in a hash, because otherwise they're
+  # too difficult to do inheritance with.
+  def dochook(name, &block)
+    method = "dochook_#{name}"
+
+    meta_def method, &block
+  end
+
+  attr_writer :doc
+
+  # Generate the full doc string.
+  def doc
+    extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
+      self.send(m)
+    }.delete_if {|r| r.nil? }.join("  ")
+
+    if @doc
+      @doc + (extra.empty? ? '' : "\n\n" + extra)
+    else
+      extra
+    end
+  end
+
+  # Build a table
+  def doctable(headers, data)
+    str = "\n\n"
+
+    lengths = []
+    # Figure out the longest field for all columns
+    data.each do |name, values|
+      [name, values].flatten.each_with_index do |value, i|
+        lengths[i] ||= 0
+        lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
+      end
+    end
+
+    # The headers could also be longest
+    headers.each_with_index do |value, i|
+      lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
+    end
+
+    # Add the header names
+    str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
+
+    # And the header row
+    str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
+
+    # Now each data row
+    data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
+      str += [name, rows].flatten.zip(lengths).collect do |value, length|
+        pad(value, length)
+      end.join(" | ") + " |" + "\n"
+    end
+
+    str + "\n"
+  end
+
+  attr_reader :nodoc
+  def nodoc?
+    nodoc
+  end
+
+  # Pad a field with spaces
+  def pad(value, length)
+    value.to_s + (" " * (length - value.to_s.length))
+  end
+
+  HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
+
+  def markdown_header(name, level)
+    "#{HEADER_LEVELS[level]} #{name}\n\n"
+  end
+
+  def markdown_definitionlist(term, definition)
+    lines = scrub(definition).split("\n")
+    str = "#{term}\n: #{lines.shift}\n"
+    lines.each do |line|
+      str << "  " if line =~ /\S/
+      str << "#{line}\n"
+    end
+    str << "\n"
+  end
+
+  # Handle the inline indentation in the docs.
+  def scrub(text)
+    # Stupid markdown
+    #text = text.gsub("<%=", "&lt;%=")
+    # For text with no carriage returns, there's nothing to do.
+    return text if text !~ /\n/
+    indent = nil
+
+    # If we can match an indentation, then just remove that same level of
+    # indent from every line.  However, ignore any indentation on the
+    # first line, since that can be inconsistent.
+    text = text.lstrip
+    text.gsub!(/^([\t]+)/) { |s| " "*8*s.length; } # Expand leading tabs
+    # Find first non-empty line after the first line:
+    line2start = (text =~ /(\n?\s*\n)/)
+    line2start += $1.length
+    if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
+      indent = Regexp.quote($1)
+      begin
+        return text.gsub(/^#{indent}/,'')
+      rescue => detail
+        puts detail.backtrace
+        puts detail
+      end
+    else
+      return text
+    end
+
+  end
+
+  module_function :scrub
+end

data/lib/vendor/puppet/util/errors.rb

@@ -0,0 +1,63 @@
+# Some helper methods for throwing errors.
+module Puppet::Util::Errors
+  # Throw a dev error.
+  def devfail(msg)
+    self.fail(Puppet::DevError, msg)
+  end
+
+  # Add line and file info if available and appropriate.
+  def adderrorcontext(error, other = nil)
+    error.line ||= self.line if self.respond_to?(:line) and self.line
+    error.file ||= self.file if self.respond_to?(:file) and self.file
+
+    error.set_backtrace other.backtrace if other and other.respond_to?(:backtrace)
+
+    error
+  end
+
+  def error_context
+    if file and line
+      " at #{file}:#{line}"
+    elsif line
+      " at line #{line}"
+    elsif file
+      " in #{file}"
+    else
+      ""
+    end
+  end
+
+  # Wrap a call in such a way that we always throw the right exception and keep
+  # as much context as possible.
+  def exceptwrap(options = {})
+    options[:type] ||= Puppet::DevError
+    begin
+      return yield
+    rescue Puppet::Error => detail
+      raise adderrorcontext(detail)
+    rescue => detail
+      message = options[:message] || "#{self.class} failed with error #{detail.class}: #{detail}"
+
+      error = options[:type].new(message)
+      # We can't use self.fail here because it always expects strings,
+      # not exceptions.
+      raise adderrorcontext(error, detail)
+    end
+
+    retval
+  end
+
+  # Throw an error, defaulting to a Puppet::Error.
+  def fail(*args)
+    if args[0].is_a?(Class)
+      type = args.shift
+    else
+      type = Puppet::Error
+    end
+
+    error = adderrorcontext(type.new(args.join(" ")))
+
+    raise error
+  end
+end
+

data/lib/vendor/puppet/util/execution.rb

@@ -0,0 +1,20 @@
+module Puppet::Util::Execution
+  module_function
+
+  # Run some code with a specific environment.  Resets the environment back to
+  # what it was at the end of the code.
+  def withenv(hash)
+    saved = ENV.to_hash
+    hash.each do |name, val|
+      ENV[name.to_s] = val
+    end
+
+    yield
+  ensure
+    ENV.clear
+    saved.each do |name, val|
+      ENV[name] = val
+    end
+  end
+end
+

data/lib/vendor/puppet/util/execution_stub.rb

@@ -0,0 +1,26 @@
+module Puppet::Util
+  class ExecutionStub
+    class << self
+      # Set a stub block that Puppet::Util.execute() should invoke instead
+      # of actually executing commands on the target machine.  Intended
+      # for spec testing.
+      #
+      # The arguments passed to the block are |command, options|, where
+      # command is an array of strings and options is an options hash.
+      def set(&block)
+        @value = block
+      end
+
+      # Uninstall any execution stub, so that calls to
+      # Puppet::Util.execute() behave normally again.
+      def reset
+        @value = nil
+      end
+
+      # Retrieve the current execution stub, or nil if there is no stub.
+      def current_value
+        @value
+      end
+    end
+  end
+end

data/lib/vendor/puppet/util/feature.rb

@@ -0,0 +1,83 @@
+class Puppet::Util::Feature
+  attr_reader :path
+
+  # Create a new feature test.  You have to pass the feature name,
+  # and it must be unique.  You can either provide a block that
+  # will get executed immediately to determine if the feature
+  # is present, or you can pass an option to determine it.
+  # Currently, the only supported option is 'libs' (must be
+  # passed as a symbol), which will make sure that each lib loads
+  # successfully.
+  def add(name, options = {})
+    method = name.to_s + "?"
+    raise ArgumentError, "Feature #{name} is already defined" if self.class.respond_to?(method)
+
+    if block_given?
+      begin
+        result = yield
+      rescue Exception => detail
+        warn "Failed to load feature test for #{name}: #{detail}"
+        result = false
+      end
+      @results[name] = result
+    end
+
+    meta_def(method) do
+      # Positive cache only, except blocks which are executed just once above
+      final = @results[name] || block_given?
+      @results[name] = test(name, options) unless final
+      @results[name]
+    end
+  end
+
+  # Create a new feature collection.
+  def initialize(path)
+    @path = path
+    @results = {}
+    @loader = Puppet::Util::Autoload.new(self, @path)
+  end
+
+  def load
+    @loader.loadall
+  end
+
+  def method_missing(method, *args)
+    return super unless method.to_s =~ /\?$/
+
+    feature = method.to_s.sub(/\?$/, '')
+    @loader.load(feature)
+
+    respond_to?(method) && self.send(method)
+  end
+
+  # Actually test whether the feature is present.  We only want to test when
+  # someone asks for the feature, so we don't unnecessarily load
+  # files.
+  def test(name, options)
+    return true unless ary = options[:libs]
+    ary = [ary] unless ary.is_a?(Array)
+
+    ary.each do |lib|
+      return false unless load_library(lib, name)
+    end
+
+    # We loaded all of the required libraries
+    true
+  end
+
+  private
+
+  def load_library(lib, name)
+    raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
+
+    begin
+      require lib
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception
+      Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
+      return false
+    end
+    true
+  end
+end

data/lib/vendor/puppet/util/file_locking.rb

@@ -0,0 +1,47 @@
+require 'puppet/util'
+
+module Puppet::Util::FileLocking
+  module_function
+
+  # Create a shared lock for reading
+  def readlock(file)
+    raise ArgumentError, "#{file} is not a file" unless !File.exists?(file) or File.file?(file)
+    Puppet::Util.synchronize_on(file,Sync::SH) do
+      File.open(file) { |f|
+        f.lock_shared { |lf| yield lf }
+      }
+    end
+  end
+
+  # Create an exclusive lock for writing, and do the writing in a
+  # tmp file.
+  def writelock(file, mode = nil)
+    raise Puppet::DevError, "Cannot create #{file}; directory #{File.dirname(file)} does not exist" unless FileTest.directory?(File.dirname(file))
+    raise ArgumentError, "#{file} is not a file" unless !File.exists?(file) or File.file?(file)
+    tmpfile = file + ".tmp"
+
+    unless mode
+      # It's far more likely that the file will be there than not, so it's
+      # better to stat once to check for existence and mode.
+      # If we can't stat, it's most likely because the file's not there,
+      # but could also be because the directory isn't readable, in which case
+      # we won't be able to write anyway.
+      begin
+        mode = File.stat(file).mode
+      rescue
+        mode = 0600
+      end
+    end
+
+    Puppet::Util.synchronize_on(file,Sync::EX) do
+      File.open(file, File::Constants::CREAT | File::Constants::WRONLY, mode) do |rf|
+        rf.lock_exclusive do |lrf|
+          # poor's man open(2) O_EXLOCK|O_TRUNC
+          lrf.seek(0, IO::SEEK_SET)
+          lrf.truncate(0)
+          yield lrf
+        end
+      end
+    end
+  end
+end