facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/ext/solaris/pkginfo

@@ -1,7 +0,0 @@
-PKG=CSWfacter
-NAME=facter - System Fact Gatherer
-VERSION=1.6.3rc1
-CATEGORY=application
-VENDOR=http://www.puppetlabs.com/puppet/related-projects/facter
-HOTLINE=http://puppetlabs.com/cgi-bin/facter.cgi
-EMAIL=luke@madstop.com

data/install.rb

@@ -1,380 +0,0 @@
-#! /usr/bin/env ruby
-#--
-# Copyright 2004 Austin Ziegler <ruby-install@halostatue.ca>
-#   Install utility. Based on the original installation script for rdoc by the
-#   Pragmatic Programmers.
-#
-# This program is free software. It may be redistributed and/or modified under
-# the terms of the GPL version 2 (or later) or the Ruby licence.
-#
-# Usage
-# -----
-# In most cases, if you have a typical project layout, you will need to do
-# absolutely nothing to make this work for you. This layout is:
-#
-#   bin/  # executable files -- "commands"
-#   lib/  # the source of the library
-#
-# The default behaviour:
-# 1) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd),
-#  all .rb files in lib/, ./README, ./ChangeLog, and ./Install.
-# 2) Build ri documentation from all files in bin/ (excluding .bat and .cmd),
-#  and all .rb files in lib/. This is disabled by default on Win32.
-# 3) Install commands from bin/ into the Ruby bin directory. On Windows, if a
-#  if a corresponding batch file (.bat or .cmd) exists in the bin directory,
-#  it will be copied over as well. Otherwise, a batch file (always .bat) will
-#  be created to run the specified command.
-# 4) Install all library files ending in .rb from lib/ into Ruby's
-#  site_lib/version directory.
-#
-#++
-
-require 'rbconfig'
-require 'find'
-require 'fileutils'
-require 'optparse'
-require 'ostruct'
-require 'tempfile'
-
-begin
-  require 'rdoc/rdoc'
-  $haverdoc = true
-rescue LoadError
-  puts "Missing rdoc; skipping documentation"
-  $haverdoc = false
-end
-
-begin
-  if $haverdoc
-     rst2man = %x{which rst2man.py}
-     $haveman = true
-  else
-     $haveman = false
-  end
-rescue
-  puts "Missing rst2man; skipping man page creation"
-  $haveman = false
-end
-
-$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
-require 'facter'
-@operatingsystem = Facter[:operatingsystem].value
-
-PREREQS = %w{cgi}
-
-InstallOptions = OpenStruct.new
-
-def glob(list)
-  g = list.map { |i| Dir.glob(i) }
-  g.flatten!
-  g.compact!
-  g
-end
-
-def do_bins(bins, target, strip = 's?bin/')
-  bins.each do |bf|
-    obf = bf.gsub(/#{strip}/, '')
-      install_binfile(bf, obf, target)
-  end
-end
-
-def do_libs(libs, strip = 'lib/')
-  libs.each do |lf|
-    olf = File.join(InstallOptions.site_dir, lf.gsub(/^#{strip}/, ''))
-    op = File.dirname(olf)
-    FileUtils.makedirs(op, {:mode => 0755, :verbose => true})
-    FileUtils.chmod(0755, op)
-    FileUtils.install(lf, olf, {:mode => 0644, :preserve => true, :verbose => true})
-  end
-end
-
-def do_man(man, strip = 'man/')
-  if (InstallOptions.man == true)
-  man.each do |mf|
-    omf = File.join(InstallOptions.man_dir, mf.gsub(/#{strip}/, ''))
-    om = File.dirname(omf)
-    FileUtils.makedirs(om, {:mode => 0755, :verbose => true})
-    FileUtils.chmod(0755, om)
-    FileUtils.install(mf, omf, {:mode => 0644, :preserve => true, :verbose => true})
-    gzip = %x{which gzip}
-    gzip.chomp!
-    %x{#{gzip} -f #{omf}}
-  end
-  else
-  puts "Skipping Man Page Generation"
-  end
-end
-
-# Verify that all of the prereqs are installed
-def check_prereqs
-  PREREQS.each { |pre|
-    begin
-      require pre
-    rescue LoadError
-      puts "Could not load #{pre} Ruby library; cannot install"
-      exit -1
-    end
-  }
-end
-
-def is_windows?
-  @operatingsystem == 'windows'
-end
-
-##
-# Prepare the file installation.
-#
-def prepare_installation
-  # Only try to do docs if we're sure they have rdoc
-  if $haverdoc
-    InstallOptions.rdoc  = true
-    if is_windows?
-      InstallOptions.ri  = false
-    else
-      InstallOptions.ri  = true
-    end
-  else
-    InstallOptions.rdoc  = false
-    InstallOptions.ri  = false
-  end
-
-
-  if $haveman
-    InstallOptions.man = true
-    if is_windows?
-      InstallOptions.man  = false
-    end
-  else
-    InstallOptions.man = false
-  end
-
-  ARGV.options do |opts|
-    opts.banner = "Usage: #{File.basename($0)} [options]"
-    opts.separator ""
-    opts.on('--[no-]rdoc', 'Prevents the creation of RDoc output.', 'Default on.') do |onrdoc|
-      InstallOptions.rdoc = onrdoc
-    end
-    opts.on('--[no-]ri', 'Prevents the creation of RI output.', 'Default off on mswin32.') do |onri|
-      InstallOptions.ri = onri
-    end
-    opts.on('--[no-]man', 'Presents the creation of man pages.', 'Default on.') do |onman|
-    InstallOptions.man = onman
-    end
-    opts.on('--destdir[=OPTIONAL]', 'Installation prefix for all targets', 'Default essentially /') do |destdir|
-      InstallOptions.destdir = destdir
-    end
-    opts.on('--bindir[=OPTIONAL]', 'Installation directory for binaries', 'overrides RbConfig::CONFIG["bindir"]') do |bindir|
-      InstallOptions.bindir = bindir
-    end
-    opts.on('--ruby[=OPTIONAL]', 'Ruby interpreter to use with installation', 'overrides ruby used to call install.rb') do |ruby|
-      InstallOptions.ruby = ruby
-    end
-    opts.on('--sitelibdir[=OPTIONAL]', 'Installation directory for libraries', 'overrides RbConfig::CONFIG["sitelibdir"]') do |sitelibdir|
-      InstallOptions.sitelibdir = sitelibdir
-    end
-    opts.on('--mandir[=OPTIONAL]', 'Installation directory for man pages', 'overrides RbConfig::CONFIG["mandir"]') do |mandir|
-      InstallOptions.mandir = mandir
-    end
-    opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick|
-      InstallOptions.rdoc   = false
-      InstallOptions.ri   = false
-    end
-    opts.on('--full', 'Performs a full installation. All', 'optional installation steps are run.') do |full|
-      InstallOptions.rdoc   = true
-      InstallOptions.ri   = true
-    end
-    opts.separator("")
-    opts.on_tail('--help', "Shows this help text.") do
-      $stderr.puts opts
-      exit
-    end
-
-    opts.parse!
-  end
-
-  version = [RbConfig::CONFIG["MAJOR"], RbConfig::CONFIG["MINOR"]].join(".")
-  libdir = File.join(RbConfig::CONFIG["libdir"], "ruby", version)
-
-  # Mac OS X 10.5 and higher declare bindir
-  # /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin
-  # which is not generally where people expect executables to be installed
-  # These settings are appropriate defaults for all OS X versions.
-  if RUBY_PLATFORM =~ /^universal-darwin[\d\.]+$/
-    RbConfig::CONFIG['bindir'] = "/usr/bin"
-  end
-
-  if not InstallOptions.bindir.nil?
-    bindir = InstallOptions.bindir
-  else
-    bindir = RbConfig::CONFIG['bindir']
-  end
-
-  if not InstallOptions.sitelibdir.nil?
-    sitelibdir = InstallOptions.sitelibdir
-  else
-    sitelibdir = RbConfig::CONFIG["sitelibdir"]
-    if sitelibdir.nil?
-      sitelibdir = $:.find { |x| x =~ /site_ruby/ }
-      if sitelibdir.nil?
-        sitelibdir = File.join(libdir, "site_ruby")
-      elsif sitelibdir !~ Regexp.quote(version)
-        sitelibdir = File.join(sitelibdir, version)
-      end
-    end
-  end
-
-  if not InstallOptions.mandir.nil?
-    mandir = InstallOptions.mandir
-  else
-    mandir = RbConfig::CONFIG['mandir']
-  end
-
-  if (destdir = InstallOptions.destdir)
-    bindir = join(destdir, bindir)
-    mandir = join(destdir, mandir)
-    sitelibdir = join(destdir, sitelibdir)
-
-    FileUtils.makedirs(bindir)
-    FileUtils.makedirs(mandir)
-    FileUtils.makedirs(sitelibdir)
-  end
-
-  InstallOptions.site_dir = sitelibdir
-  InstallOptions.bin_dir  = bindir
-  InstallOptions.lib_dir  = libdir
-  InstallOptions.man_dir  = mandir
-end
-
-##
-# Join two paths. On Windows, dir must be converted to a relative path,
-# by stripping the drive letter, but only if the basedir is not empty.
-#
-def join(basedir, dir)
-  return "#{basedir}#{dir[2..-1]}" if is_windows? and basedir.length > 0 and dir.length > 2
-
-  "#{basedir}#{dir}"
-end
-
-##
-# Build the rdoc documentation. Also, try to build the RI documentation.
-#
-def build_rdoc(files)
-  return unless $haverdoc
-  begin
-    r = RDoc::RDoc.new
-    r.document(["--main", "README", "--title",
-      "Puppet -- Site Configuration Management", "--line-numbers"] + files)
-  rescue RDoc::RDocError => e
-    $stderr.puts e.message
-  rescue Exception => e
-    $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
-  end
-end
-
-def build_ri(files)
-  return unless $haverdoc
-  begin
-    ri = RDoc::RDoc.new
-    #ri.document(["--ri-site", "--merge"] + files)
-    ri.document(["--ri-site"] + files)
-  rescue RDoc::RDocError => e
-    $stderr.puts e.message
-  rescue Exception => e
-    $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
-    $stderr.puts "Continuing with install..."
-  end
-end
-
-def build_man(bins)
-  return unless $haveman
-  begin
-    # Locate rst2man
-    rst2man = %x{which rst2man.py}
-    rst2man.chomp!
-    bins.each do |bin|
-      b = bin.gsub( "bin/", "")
-      %x{#{bin} --help > ./#{b}.rst}
-      %x{#{rst2man} ./#{b}.rst ./man/man8/#{b}.8}
-      File.unlink("./#{b}.rst")
-    end
-  rescue SystemCallError
-    $stderr.puts "Couldn't build man pages: " + $!
-    $stderr.puts "Continuing with install..."
-  end
-end
-
-##
-# Install file(s) from ./bin to RbConfig::CONFIG['bindir']. Patch it on the way
-# to insert a #! line; on a Unix install, the command is named as expected
-# (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under
-# windows, we add an '.rb' extension and let file associations do their stuff.
-def install_binfile(from, op_file, target)
-  tmp_file = Tempfile.new('facter-binfile')
-
-  if not InstallOptions.ruby.nil?
-    ruby = InstallOptions.ruby
-  else
-    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-  end
-
-  File.open(from) do |ip|
-    File.open(tmp_file.path, "w") do |op|
-      op.puts "#!#{ruby}"
-      contents = ip.readlines
-      contents.shift if contents[0] =~ /^#!/
-      op.write contents.join
-    end
-  end
-
-  if is_windows?
-    installed_wrapper = false
-
-    if File.exists?("#{from}.bat")
-      FileUtils.install("#{from}.bat", File.join(target, "#{op_file}.bat"), :mode => 0755, :preserve => true, :verbose => true)
-      installed_wrapper = true
-    end
-
-    if File.exists?("#{from}.cmd")
-      FileUtils.install("#{from}.cmd", File.join(target, "#{op_file}.cmd"), :mode => 0755, :preserve => true, :verbose => true)
-      installed_wrapper = true
-    end
-
-    if not installed_wrapper
-      tmp_file2 = Tempfile.new('facter-wrapper')
-      cwv = <<-EOS
-@echo off
-setlocal
-set RUBY_BIN=%~dp0
-set RUBY_BIN=%RUBY_BIN:\\=/%
-"%RUBY_BIN%ruby.exe" -x "%RUBY_BIN%facter" %*
-EOS
-      File.open(tmp_file2.path, "w") { |cw| cw.puts cwv }
-      FileUtils.install(tmp_file2.path, File.join(target, "#{op_file}.bat"), :mode => 0755, :preserve => true, :verbose => true)
-
-      tmp_file2.unlink
-      installed_wrapper = true
-    end
-  end
-  FileUtils.install(tmp_file.path, File.join(target, op_file), :mode => 0755, :preserve => true, :verbose => true)
-  tmp_file.unlink
-end
-
-# Change directory into the facter root so we don't get the wrong files for install.
-FileUtils.cd File.dirname(__FILE__) do
-  # Set these values to what you want installed.
-  bins  = glob(%w{bin/*})
-  rdoc  = glob(%w{bin/* lib/**/*.rb README* }).reject { |e| e=~ /\.(bat|cmd)$/ }
-  ri  = glob(%w(bin/*.rb lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
-  man   = glob(%w{man/man8/*})
-  libs  = glob(%w{lib/**/*.rb lib/**/*.py lib/**/LICENSE})
-
-  check_prereqs
-  prepare_installation
-
-  #build_rdoc(rdoc) if InstallOptions.rdoc
-  #build_ri(ri) if InstallOptions.ri
-  #build_man(bins) if InstallOptions.man
-  do_bins(bins, InstallOptions.bin_dir)
-  do_libs(libs)
-  do_man(man)
-end

data/lib/facter/Cfkey.rb

@@ -1,42 +0,0 @@
-# Fact: cfkey
-#
-# Purpose: Return the public key(s) for CFengine.
-#
-# Resolution:
-#   Tries each file of standard `localhost.pub` and `cfkey.pub` locations,
-#   checks if they appear to be a public key, and then join them all together.
-#
-# Caveats:
-#
-
-## Cfkey.rb
-## Facts related to cfengine
-##
-
-Facter.add(:Cfkey) do
-  setcode do
-    value = nil
-    ["/usr/local/etc/cfkey.pub",
-      "/etc/cfkey.pub",
-      "/var/cfng/keys/localhost.pub",
-      "/var/cfengine/ppkeys/localhost.pub",
-      "/var/lib/cfengine/ppkeys/localhost.pub",
-      "/var/lib/cfengine2/ppkeys/localhost.pub"
-    ].each do |file|
-      if FileTest.file?(file)
-        File.open(file) { |openfile|
-          value = openfile.readlines.reject { |line|
-            line =~ /PUBLIC KEY/
-          }.collect { |line|
-            line.chomp
-          }.join("")
-        }
-      end
-      if value
-        break
-      end
-    end
-
-    value
-  end
-end

data/lib/facter/application.rb

@@ -1,206 +0,0 @@
-require 'optparse'
-require 'facter'
-require 'facter/util/formatter'
-
-module Facter
-  module Application
-
-    require 'facter/util/nothing_loader'
-
-    def self.create_directory_loader(dir)
-      begin
-        Facter::Util::Config.ext_fact_loader = Facter::Util::DirectoryLoader.loader_for(dir)
-      rescue Facter::Util::DirectoryLoader::NoSuchDirectoryError => error
-        Facter.log_exception(error, "Specified external facts directory #{dir} does not exist.")
-        exit(1)
-      end
-    end
-
-    def self.create_nothing_loader
-      Facter::Util::Config.ext_fact_loader = Facter::Util::NothingLoader.new
-    end
-
-    def self.run(argv)
-      options = parse(argv)
-
-      # Accept fact names to return from the command line
-      names = argv
-
-      # Change location of external facts dir
-      # Check here for valid ext_dir and exit program
-
-      # Create the facts hash that is printed to standard out.
-      unless names.empty?
-        facts = {}
-        names.each do |name|
-          begin
-            facts[name] = Facter.value(name)
-          rescue => error
-            Facter.log_exception(error, "Could not retrieve #{name}: #{error.message}")
-            exit(10)
-          end
-        end
-      end
-
-      # Print everything if they didn't ask for specific facts.
-      facts ||= Facter.to_hash
-
-      output = nil
-
-      if options[:yaml]
-        output = Facter::Util::Formatter.format_yaml(facts)
-      elsif options[:json]
-        output = Facter::Util::Formatter.format_json(facts)
-      elsif options[:plaintext]
-        output = Facter::Util::Formatter.format_plaintext(facts)
-      else
-        output = Facter::Util::Formatter.format_plaintext(facts)
-      end
-
-      puts output
-      exit(0)
-
-    rescue => e
-      Facter.log_exception(e)
-      exit(12)
-    end
-
-    private
-
-    # Parses the given argument array destructively to return an options hash
-    # (and possibly perform side effects such as changing settings).
-    #
-    # @param [Array<String>] argv command line arguments
-    # @return [Hash] options hash
-    def self.parse(argv)
-      options = {}
-      parser = OptionParser.new do |opts|
-        opts.banner = <<-BANNER
-facter(8) -- Gather system information
-======
-
-SYNOPSIS
---------
-
-Collect and display facts about the system.
-
-USAGE
------
-
-    facter [-h|--help] [-t|--timing] [-d|--debug] [-p|--puppet] [-v|--version]
-      [-y|--yaml] [-j|--json] [--plaintext] [--external-dir DIR] [--no-external-dir]
-      [fact] [fact] [...]
-
-DESCRIPTION
------------
-
-Collect and display facts about the current system.  The library behind
-Facter is easy to expand, making Facter an easy way to collect information
-about a system from within the shell or within Ruby.
-
-If no facts are specifically asked for, then all facts will be returned.
-
-EXAMPLE
--------
-
-Display all facts:
-
-    $ facter
-    architecture => amd64
-    blockdevices => sda,sr0
-    domain => example.com
-    fqdn => puppet.example.com
-    hardwaremodel => x86_64
-    [...]
-
-Display a single fact:
-
-    $ facter kernel
-    Linux
-
-Format facts as JSON:
-
-    $ facter --json architecture kernel hardwaremodel
-    {
-      "architecture": "amd64",
-      "kernel": "Linux",
-      "hardwaremodel": "x86_64"
-    }
-
-AUTHOR
-------
-  Luke Kanies
-
-COPYRIGHT
----------
-  Copyright (c) 2011-2014 Puppet Labs, Inc Licensed under the Apache 2.0 license
-
-OPTIONS
--------
-        BANNER
-        opts.on("-y",
-                "--yaml",
-                "Emit facts in YAML format.")   { |v| options[:yaml]   = v }
-        opts.on("-j",
-                "--json",
-                "Emit facts in JSON format.")   { |v| options[:json]   = v }
-        opts.on("--plaintext",
-                "Emit facts in plaintext format.") { |v| options[:plaintext] = v }
-        opts.on("--trace",
-                "Enable backtraces.")  { |v| Facter.trace(true) }
-        opts.on("--external-dir DIR",
-                "The directory to use for external facts.") { |v| create_directory_loader(v) }
-        opts.on("--no-external-dir",
-                "Turn off external facts.") { |v| create_nothing_loader }
-        opts.on("-d",
-                "--debug",
-                "Enable debugging.")  { |v| Facter.debugging(1) }
-        opts.on("-t",
-                "--timing",
-                "Enable timing.") { |v| Facter.timing(1) }
-        opts.on("-p",
-                "--puppet",
-                "(Deprecated: use `puppet facts` instead) Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.") do |v|
-          load_puppet
-        end
-
-        opts.on_tail("-v",
-                     "--version",
-                     "Print the version and exit.") do
-          puts Facter.version
-          exit(0)
-        end
-
-        opts.on_tail("-h",
-                     "--help",
-                     "Print this help message.") do
-          puts parser
-          exit(0)
-        end
-      end
-
-      parser.parse!(argv)
-
-      options
-    rescue OptionParser::InvalidOption => e
-      $stderr.puts e.message
-      exit(12)
-    end
-
-    def self.load_puppet
-      require 'puppet'
-      Puppet.initialize_settings
-
-      # If you've set 'vardir' but not 'libdir' in your
-      # puppet.conf, then the hook to add libdir to $:
-      # won't get triggered.  This makes sure that it's setup
-      # correctly.
-      unless $LOAD_PATH.include?(Puppet[:libdir])
-        $LOAD_PATH << Puppet[:libdir]
-      end
-    rescue LoadError => detail
-      $stderr.puts "Could not load Puppet: #{detail}"
-    end
-
-  end
-end