(maint) Indent facter_dot_d with 2 spaces

Whitespace only re-flow of facter_dot_d.rb

1 files changed, 125 insertions, 125 deletions

diff --git a/lib/facter/facter_dot_d.rb b/lib/facter/facter_dot_d.rb
index 634a397..e414b20 100644
--- a/lib/facter/facter_dot_d.rb
+++ b/lib/facter/facter_dot_d.rb
@@ -13,172 +13,172 @@
 # fact scripts more often than is needed
 
 class Facter::Util::DotD
-    require 'yaml'
+  require 'yaml'
 
-    def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml")
-        @dir = dir
-        @cache_file = cache_file
-        @cache = nil
-        @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
-    end
+  def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml")
+    @dir = dir
+    @cache_file = cache_file
+    @cache = nil
+    @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
+  end
 
-    def entries
-        Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) }
-    rescue
-        []
-    end
+  def entries
+    Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) }
+  rescue
+    []
+  end
 
-    def fact_type(file)
-        extension = File.extname(file)
+  def fact_type(file)
+    extension = File.extname(file)
 
-        type = @types[extension] || :unknown
+    type = @types[extension] || :unknown
 
-        type = :script if type == :unknown && File.executable?(file)
+    type = :script if type == :unknown && File.executable?(file)
 
-        return type
-    end
+    return type
+  end
 
-    def txt_parser(file)
-        File.readlines(file).each do |line|
-            if line =~ /^(.+)=(.+)$/
-                var = $1; val = $2
+  def txt_parser(file)
+    File.readlines(file).each do |line|
+      if line =~ /^(.+)=(.+)$/
+        var = $1; val = $2
 
-                Facter.add(var) do
-                    setcode { val }
-                end
-            end
+        Facter.add(var) do
+          setcode { val }
         end
-    rescue Exception => e
-        Facter.warn("Failed to handle #{file} as text facts: #{e.class}: #{e}")
+      end
     end
+  rescue Exception => e
+    Facter.warn("Failed to handle #{file} as text facts: #{e.class}: #{e}")
+  end
 
-    def json_parser(file)
-        begin
-            require 'json'
-        rescue LoadError
-            retry if require 'rubygems'
-            raise
-        end
+  def json_parser(file)
+    begin
+      require 'json'
+    rescue LoadError
+      retry if require 'rubygems'
+      raise
+    end
 
-        JSON.load(File.read(file)).each_pair do |f, v|
-            Facter.add(f) do
-                setcode { v }
-            end
-        end
-    rescue Exception => e
-        Facter.warn("Failed to handle #{file} as json facts: #{e.class}: #{e}")
+    JSON.load(File.read(file)).each_pair do |f, v|
+      Facter.add(f) do
+        setcode { v }
+      end
     end
+  rescue Exception => e
+    Facter.warn("Failed to handle #{file} as json facts: #{e.class}: #{e}")
+  end
 
-    def yaml_parser(file)
-        require 'yaml'
+  def yaml_parser(file)
+    require 'yaml'
 
-        YAML.load_file(file).each_pair do |f, v|
-            Facter.add(f) do
-                setcode { v }
-            end
-        end
-    rescue Exception => e
-        Facter.warn("Failed to handle #{file} as yaml facts: #{e.class}: #{e}")
+    YAML.load_file(file).each_pair do |f, v|
+      Facter.add(f) do
+        setcode { v }
+      end
     end
+  rescue Exception => e
+    Facter.warn("Failed to handle #{file} as yaml facts: #{e.class}: #{e}")
+  end
 
-    def script_parser(file)
-        result = cache_lookup(file)
-        ttl = cache_time(file)
+  def script_parser(file)
+    result = cache_lookup(file)
+    ttl = cache_time(file)
 
-        unless result
-            result = Facter::Util::Resolution.exec(file)
+    unless result
+      result = Facter::Util::Resolution.exec(file)
 
-            if ttl > 0
-                Facter.debug("Updating cache for #{file}")
-                cache_store(file, result)
-                cache_save!
-            end
-        else
-            Facter.debug("Using cached data for #{file}")
-        end
+      if ttl > 0
+        Facter.debug("Updating cache for #{file}")
+        cache_store(file, result)
+        cache_save!
+      end
+    else
+      Facter.debug("Using cached data for #{file}")
+    end
 
-        result.split("\n").each do |line|
-            if line =~ /^(.+)=(.+)$/
-                var = $1; val = $2
+    result.split("\n").each do |line|
+      if line =~ /^(.+)=(.+)$/
+        var = $1; val = $2
 
-                Facter.add(var) do
-                    setcode { val }
-                end
-            end
+        Facter.add(var) do
+          setcode { val }
         end
-    rescue Exception => e
-        Facter.warn("Failed to handle #{file} as script facts: #{e.class}: #{e}")
-        Facter.debug(e.backtrace.join("\n\t"))
+      end
     end
+  rescue Exception => e
+    Facter.warn("Failed to handle #{file} as script facts: #{e.class}: #{e}")
+    Facter.debug(e.backtrace.join("\n\t"))
+  end
 
-    def cache_save!
-        cache = load_cache
-        File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) }
-    rescue
-    end
+  def cache_save!
+    cache = load_cache
+    File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) }
+  rescue
+  end
 
-    def cache_store(file, data)
-        load_cache
+  def cache_store(file, data)
+    load_cache
 
-        @cache[file] = {:data => data, :stored => Time.now.to_i}
-    rescue
-    end
+    @cache[file] = {:data => data, :stored => Time.now.to_i}
+  rescue
+  end
 
-    def cache_lookup(file)
-        cache = load_cache
+  def cache_lookup(file)
+    cache = load_cache
 
-        return nil if cache.empty?
+    return nil if cache.empty?
 
-        ttl = cache_time(file)
+    ttl = cache_time(file)
 
-        if cache[file]
-            now = Time.now.to_i
+    if cache[file]
+      now = Time.now.to_i
 
-            return cache[file][:data] if ttl == -1
-            return cache[file][:data] if (now - cache[file][:stored]) <= ttl
-            return nil
-        else
-            return nil
-        end
-    rescue
-        return nil
+      return cache[file][:data] if ttl == -1
+      return cache[file][:data] if (now - cache[file][:stored]) <= ttl
+      return nil
+    else
+      return nil
     end
+  rescue
+    return nil
+  end
 
-    def cache_time(file)
-        meta = file + ".ttl"
+  def cache_time(file)
+    meta = file + ".ttl"
 
-        return File.read(meta).chomp.to_i
-    rescue
-        return 0
-    end
-
-    def load_cache
-        unless @cache
-            if File.exist?(@cache_file)
-                @cache = YAML.load_file(@cache_file)
-            else
-                @cache = {}
-            end
-        end
+    return File.read(meta).chomp.to_i
+  rescue
+    return 0
+  end
 
-        return @cache
-    rescue
+  def load_cache
+    unless @cache
+      if File.exist?(@cache_file)
+        @cache = YAML.load_file(@cache_file)
+      else
         @cache = {}
-        return @cache
+      end
     end
 
-    def create
-        entries.each do |fact|
-            type = fact_type(fact)
-            parser = "#{type}_parser"
+    return @cache
+  rescue
+    @cache = {}
+    return @cache
+  end
 
-            if respond_to?("#{type}_parser")
-                Facter.debug("Parsing #{fact} using #{parser}")
+  def create
+    entries.each do |fact|
+      type = fact_type(fact)
+      parser = "#{type}_parser"
 
-                send(parser, fact)
-            end
-        end
+      if respond_to?("#{type}_parser")
+        Facter.debug("Parsing #{fact} using #{parser}")
+
+        send(parser, fact)
+      end
     end
+  end
 end