fqdn_facts 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df9ca38b346ae900a649ac39a6815d26643ff556
-  data.tar.gz: 1f629c750963efc5f7020baaa237f359e51ad7ae
+  metadata.gz: 37772163234e2641a79f0961962983973d326c04
+  data.tar.gz: 2c232820195afc81d2b6635d38b681389c30822f
 SHA512:
-  metadata.gz: 2b39dc3811576c37969b974bf723578d99bce42897e9f79f4ae2d9f3f4fb5d1ac6426f66c65bdb28c57295a64048eaccf62cb0abc383324ddde1212bafaf9433
-  data.tar.gz: 2218beac65bf4292abde592da849aece27ee2926715317af70cf5351919315ea7cd1c17d6508335ada84d6f1304ba99e1c3363c9b07522e1586d51bb775d54f9
+  metadata.gz: 02d5404556ad9b9ca9e13ad6952da6c6baaf276797c9fa0739a3d545be8b264f9e0b41118443864bb6b48182899da561b4e7da7fac2483a40408d5414db46c06
+  data.tar.gz: 6de0e4d9597ec6b5ee6677727d9d0e9f970c33f3026974b4b79ecd4e34a1d85c725e5d2cedd254320cb5d406b0fb4a59bb7def57b8bd3bbc6b37a4e8c57b1b1c

data/README.md

@@ -2,6 +2,10 @@
 
 FqdnFacts allows you to create fact handlers for different FQDN formats. This is primarily intended for use with Puppet/Facter to facilitate dynamic fact generation based on FQDNs.
 
+## Status
+
+<img src="https://travis-ci.org/rabbitt/fqdn_facts.svg?branch=master" />
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/fqdn_facts/core_ext.rb

@@ -21,10 +21,32 @@ class Object
   # provides an empty? check for all objects
   # unless an object already has an empty? check
   #
-  # @return false
+  # @return [false]
   def empty?
     return false
   end
+
+  # returns true if the object "contains" data
+  # (object dependant)
+  # @return [Boolean]
+  def present?
+    !empty?
+  end
+
+  # attempts to call a public method
+  #
+  # @param method <Symbol> the method to attempt to call
+  # @param args [Array] optional arguments to pass to the method
+  # @param block [Block] optional block to pass to the method
+  #
+  # @return the result of the method call, if the method exists, or nil if it doesn't
+  def try(method, *args, &block)
+    begin
+      self.public_send(method, *args, &block)
+    rescue NoMethodError
+      nil
+    end
+  end
 end
 
 # @see NilClass
@@ -38,6 +60,10 @@ end
 
 # @see String
 class String
+  def empty?
+    !!(self !~ /\S/)
+  end
+
   # converts a camelized string to underscored
   # @return String
   def underscore
@@ -49,7 +75,39 @@ class String
   def camelize
     self.split('_').collect(&:capitalize).join
   end
+
+  # Attempts to transform string into a class constant
+  def constantize(base=Object)
+    self.split('/')
+        .collect(&:camelize)
+        .inject(base) { |obj,klass| obj.const_get(klass) }
+  end
+end
+
+class Proc
+  # @see http://stackoverflow.com/a/10059209/988225
+  def call_with_vars(vars, *args)
+    begin
+      Struct.new(*vars.keys).new(*vars.values).instance_exec(*args, &self)
+    rescue NameError => e
+      # don't error out - just warn
+      file, line = e.backtrace.first.split(':')
+      name = e.message.split(/[`']/)[1]
+      warn "Couldn't find value for key '#{name}' at #{file}:#{line}"
+    end
+  end
 end
 
+class Symbol
+  def include?(needle)
+    to_s.include? needle
+  end
 
+  def constantize(*args)
+    to_s.constantize(*args)
+  end
 
+  def split(*args)
+    to_s.split(*args)
+  end
+end

data/lib/fqdn_facts/handler.rb

@@ -0,0 +1,377 @@
+=begin
+    Copyright (C) 2015  Carl P. Corliss <rabbitt@gmail.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+=end
+
+require_relative 'core_ext'
+require_relative 'errors'
+
+module FqdnFacts
+  #
+  # base class for all handlers.
+  #
+  class Handler
+    class << self
+      # Creates a new instance of this object using the internal state
+      # of another handler object
+      #
+      # @param other <Handler> the handler to copy
+      # @return <Handler>
+      def copy_from(other)
+        new(other.export)
+      end
+    end
+
+    attr_accessor :priority, :fqdn, :facts
+
+    # default validation hash of FQDN components
+    DEFAULT_COMPONENTS = {
+      host: %r'(.+)',
+      sub: %r:(.+):,
+      tld: %r'(.+)'
+    } unless defined? DEFAULT_COMPONENTS
+    private_constant :DEFAULT_COMPONENTS
+
+    # initilalizer
+    #
+    # @param data [Hash] seeds the handler with base data
+    # @option data [Integer] :priority sets the initial priority level
+    # @option data [Hash] :conversions sets the initial set of conversions
+    # @option data [Hash] :components sets the initial component validations
+    # @option data [Array] :order sets the initial order of components
+    # @option data [Hash] :facts sets the initial set of facts
+    def initialize(data = {})
+      @priority        = data.delete(:priority)        || 1
+      @conversions     = data.delete(:conversions)     || {}
+      @components      = data.delete(:components)      || DEFAULT_COMPONENTS.dup
+      @order           = data.delete(:order)           || DEFAULT_COMPONENTS.keys
+      @facts           = data.delete(:facts)           || {}
+      @fqdn            = ''
+
+      add_fact(:fqdn) { fqdn }
+      add_fact(:handler_class, self.class.to_s)
+      add_fact(:handler_name) { handler_class.split('::').last.underscore }
+    end
+
+    ## DSL Methods
+    # @!group DSL
+
+    # The priority of the registered Fqdn Fact handler
+    #
+    # Lower priority fqdn fact handlers win out over
+    # higer priority handlers.
+    #
+    # @overload priority(value)
+    #   Sets the priority level
+    #   @param value [Integer] higher numbers denote lower priority, lower numbers denote higher
+    # @overload priority()
+    #   Retrieves the current priority level
+    # @return Integer
+    def priority(value = nil)
+      return @priority if value.nil?
+      @priority = value.to_i
+    end
+
+    # Defines the order of the defined components
+    # that make up the FQDN.
+    #
+    # This defaults to: host, :sub, :tld
+    #
+    # @param args <Array<Symbol>> list of ordered components
+    # @raise [ArgumentError] if args is empty
+    def order(*args)
+      raise ArgumentError, 'empty list of components' unless args.present?
+      @order = args
+    end
+    alias_method :components, :order
+
+    # Define a component's validation rule.
+    #
+    # Validation rules can be one of the following
+    #   * :any (the same as /.+/)
+    #   * A Hash of sub_component => regexp
+    #   * An array of valid values
+    #   * A scalar for exact matching
+    #
+    # @param component <Symbol> the name of the component to set validation for
+    # @param validate [Hash{Symbol=>Symbol,Hash,Array,Scalar}] validation to perform for component
+    def component(component, validate=:any)
+      v = case validate
+        when :any then %r:(.+):
+        when Hash then
+          if @components[component.to_sym].is_a?(Hash)
+            basis = @components[component.to_sym]
+          else
+            basis = {}
+          end
+
+          basis.merge(
+            Hash[validate.keys.zip(
+              validate.values.collect {|v|
+                case v
+                  when :any then %r:(.+):
+                  when Regexp then v
+                  else Regexp.new(v)
+                end
+              }
+            )]
+          )
+        when Array then
+          %r:(#{validate.join('|')}):
+        else validate
+      end
+
+      if @components[component.to_sym]
+        # if their not the same class, then remove any conversions
+        unless @components[component.to_sym].is_a?(v.class)
+          @conversions.delete(component.to_sym)
+        end
+      end
+
+      @components[component.to_sym]  = v
+    end
+
+    # Defines a conversion rule for a given component.
+    # The conversion must be a Proc/Lambda
+    #
+    # @param component <Symbol> the name of the component to set validation for
+    # @param conversion [Hash,Proc] optional conversion hash, proc/lambda
+    # @param block [Proc] optional block
+    # @raise [ArgumentError] if conversion isn't Hash, Proc or Block
+    def convert(component, conversion=nil, &block)
+      unless [Proc, Hash].any? { |klass| conversion.is_a?(klass) } || block_given?
+        raise ArgumentError, 'expected Hash, Proc or Block'
+      end
+
+      component  = component.to_sym
+      conversion = conversion || block
+
+      conversion = if conversion.is_a? Hash
+        (@conversions[component]||={}).merge(conversion)
+      else
+        conversion
+      end
+
+      @conversions[component] = conversion
+    end
+
+    # Returns the value of a fact
+    #
+    # @param name <String,Symbol> name of the fact to retrieve
+    def get_fact(name)
+      retrieve_facts[name.to_sym]
+    end
+
+    # Adds a fact, either using a static value, or a Proc/Lambda
+    # for runtime determination of the value.
+    #
+    # @param name <String> Symbol name of the fact to add
+    # @param value <Scalar,Array,Hash,Proc> value of the fact
+    def add_fact(name, value=nil, &block)
+      value = block if block_given?
+      facts[name.to_sym] = value
+    end
+
+    # Removes a fact from the list of facts.
+    # @param name <String,Symbol> name of the fact to remove
+    def remove_fact(name)
+      facts.delete(name.to_sym)
+    end
+
+    ### End of DSL Methods
+    # @!endgroup
+
+    # retrieve aggregated facts
+    #
+    # @param options [Hash] options to use when retrieving facts
+    # @option options [String] :prefix a string to prefix every fact name with
+    # @option options [Array<Symbol>] :only a list of specific facts to retrieve
+    #
+    # @return [Hash{Symbol=><Scalar,Hash,Array>}]
+    def retrieve(options={})
+      prefix = options.delete(:prefix)
+      only   = (o = options.delete(:only)).empty? ? nil : o.collect(&:to_sym)
+
+      assemble.dup.tap do |facts|
+        facts.replace(
+          Hash[facts.inject({}) do |hash, (fact, value)|
+            next hash unless only.empty? || only.include?(fact)
+            key = prefix.empty? ? fact : "#{prefix}_#{fact}"
+            hash[key] = value
+            hash
+          end.sort]
+        )
+      end
+    end
+
+    # Retrieve all facts, possibly prefixing their names (@see #retrieve)
+    # @param prefix <String> a string to prefix every fact name with
+    # @return [Hash{Symbol=><Scalar,Hash,Array>}]
+    def all(prefix = nil)
+      retrieve prefix: prefix
+    end
+
+    # legacy support method
+    alias_method :retrieve_facts, :all
+
+    # @return Hash all aggregate facts
+    def to_h
+      merge_facts.dup
+    end
+
+    # Checks to see if the fqdn matches this particular FQDN Fact Handler
+    # @api private
+    def match?(fqdn)
+      parts = fqdn.split('.', @order.size)
+      return unless parts.size == @order.size
+
+      debug "Validating #{self.class}:"
+
+      test_data = @order.zip(parts)
+      debug "  test data -> #{test_data.inspect}"
+
+      test_data.all? do |name, value|
+        debug "  validating component '#{name}'"
+        validation = case @components[name]
+          when Hash then Regexp.new(@components[name].values.join)
+          when nil then %r:.+:
+          else @components[name]
+        end
+
+        case validation
+          when Regexp then
+            (value =~ validation).tap { |r|
+              debug "    Regexp -> #{value.inspect} =~ #{validation.inspect} == #{r.inspect}"
+            }
+          when Array  then
+            validation.include?(value).tap { |r|
+              debug "    Array -> #{validation.inspect}.include?(#{value.inspect}) == #{r.inspect}"
+            }
+          else
+            (value == validation).tap { |r|
+              debug "    #{validation.class} -> #{value.inspect} == #{validation.inspect} == #{r.inspect}"
+            }
+        end
+      end.tap { |r| debug " ---> validation #{r ? 'successful' : 'failed'} for #{self.class}"}
+    end
+
+    # Compares the priority of this handler to another handler
+    #
+    # @param other <Handler> the handler to compare against
+    # @return [-1, 0, 1] if other is <=, =, or >= self
+    def <=>(other)
+      self.priority <=> other.priority
+    end
+
+    # Exports the internal state as a hash
+    # @api private
+    def export
+      instance_variables.inject({}) do |exports, name|
+        varname = name.to_s.tr('@', '').to_sym
+        exports[varname] = begin
+          Marshal.load(Marshal.dump(instance_variable_get(name)))
+        rescue TypeError
+          instance_variable_get(name).dup
+        end
+        exports
+      end
+    end
+
+    private
+
+    # Assemble facts from gathered data
+    # @return [self]
+    # @api private
+    def assemble
+      { }.tap do |data|
+        data.merge!(facts.merge(Hash[fqdn_components]))
+
+        # expand subtypes
+        @components.each do |name, value|
+          # components are converted explicitly during expansino, and solely
+          # based on their value
+          conversion = @conversions[name]
+
+          if value.is_a? Hash
+            subdata = data[name].scan(Regexp.new(value.values.join)).flatten
+            value.keys.zip(subdata).each do |subkey, subvalue|
+              conversion = @conversions[name].try(:[], subkey)
+              data[:"#{name}_#{subkey}"] = convert_value(subvalue, conversion)
+            end
+          else
+            data[name] = convert_value(data[name], conversion)
+          end
+        end
+
+        # handle any remaining runtime generated facts
+        data.each do |fact, value|
+          case value
+            when Proc then value = convert_value(data, value)
+            when Symbol then value
+            else next
+          end
+          data[fact] = value.is_a?(Symbol) ? value.to_s : value
+        end
+
+        data.reject! { |fact, value| value.empty? }
+      end
+    end
+
+    def convert_value(value, converter)
+      case converter
+        when Proc then
+          bind_data = value.is_a?(Hash) ? value.dup : { value: value }
+          bind_data.merge!({
+            fqdn:          fqdn,
+            components:    Hash[fqdn_components],
+            priority:      priority,
+            handler_class: self.class.name
+          })
+
+          value = if converter.arity == 1
+            converter.call_with_vars(bind_data, value)
+          else
+            converter.call_with_vars(bind_data)
+          end
+          value.is_a?(Symbol) ? value.to_s : value
+
+        when :symbol then value.to_sym
+        when :integer, Integer then value.to_i
+        when :float, Float then value.to_f
+        when :string, String then value.to_s
+        when :array, Array then Array(value)
+        else value
+      end
+    end
+
+    # @api private
+    def fqdn_data
+      fqdn.split('.', @order.size)
+    end
+
+    # @api private
+    def fqdn_components
+      @order.zip(fqdn_data)
+    end
+
+    # @api private
+    def debug(message)
+      if ENV.keys.collect(&:downcase).include? 'debug'
+        STDERR.puts message
+      end
+    end
+  end
+end

data/lib/fqdn_facts/version.rb

@@ -18,5 +18,5 @@
 
 module FqdnFacts
   # The current FqdnFacts version
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/lib/fqdn_facts.rb

@@ -26,7 +26,7 @@ require 'fqdn_facts/core_ext'
 module FqdnFacts
   @registry = {}
 
-  autoload :BaseHandler, 'fqdn_facts/base_handler'
+  autoload :Handler, 'fqdn_facts/handler'
   autoload :Error, 'fqdn_facts/errors'
 
   class << self
@@ -34,25 +34,29 @@ module FqdnFacts
 
     # Registers a FQDN Fact Handler
     #
-    # @param klass   Symbol name of handler to register
-    # @param options Hash   options to pass
-    # @param block   Block  block of DSL code
+    # @param klass    <Symbol> name of handler to register
+    # @param options  [Hash]   options to pass
+    # @option options [Symbol] :copy existing handler to copy definition from
+    # @param block    [Block]  block of DSL code
     #
-    # @return FqdnFacts::BaseHandler derived class
-    #
-    def register(klass, options={}, &block)
+    # @raise [Error::HandlerNotFound] if the requested copy handler doesn't exist
+    # @return <Handler>
+    def register(klass, options = {}, &block)
+      parent_name  = (v = options.delete(:copy)).nil? ? :handler : v.to_sym
+      parent_class = parent_name == :handler ? Handler : parent_name.constantize(Handler)
+
       klass_const = klass.to_s.camelize
-      unless BaseHandler.const_defined? klass_const
-        BaseHandler.const_set(klass_const, Class.new(BaseHandler))
+      unless Handler.const_defined? klass_const
+        Handler.const_set(klass_const, Class.new(parent_class))
       end
 
-      if other = options.delete(:copy)
-        unless other = @registry[other.to_sym]
+      if parent_name != :handler
+        unless parent = @registry[parent_name]
           fail Error::HandlerNotFound, other
         end
-        @registry[klass.to_sym] = BaseHandler.const_get(klass_const).copy_from(other)
+        @registry[klass.to_sym] = Handler.const_get(klass_const).copy_from(parent)
       else
-        @registry[klass.to_sym] = BaseHandler.const_get(klass_const).new
+        @registry[klass.to_sym] = Handler.const_get(klass_const).new
       end
 
 
@@ -68,9 +72,10 @@ module FqdnFacts
     # Retrieves a handler that is capable of generating facts
     # for the given FQDN
     #
-    # @param fqdn String Fully qualified domain name to resolve into a handler
+    # @param fqdn <String> Fully qualified domain name to resolve into a handler
     #
-    # @return FqdnFacts::BaseHandler derived class
+    # @raise [Error::UnresolveableHandler] if unable to find a handler for the given fqdn
+    # @return <Handler>
     def handler(fqdn)
       if (handlers = @registry.values.select { |klass| klass.match?(fqdn) }).empty?
         fail Error::UnresolveableHandler, "unable to find a handler for FQDN:#{fqdn}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fqdn_facts
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Carl P. Corliss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-19 00:00:00.000000000 Z
+date: 2015-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,9 +70,9 @@ files:
 - Rakefile
 - fqdn_facts.gemspec
 - lib/fqdn_facts.rb
-- lib/fqdn_facts/base_handler.rb
 - lib/fqdn_facts/core_ext.rb
 - lib/fqdn_facts/errors.rb
+- lib/fqdn_facts/handler.rb
 - lib/fqdn_facts/version.rb
 - spec/fqdn_facts_spec.rb
 - spec/spec_helper.rb

data/lib/fqdn_facts/base_handler.rb

@@ -1,279 +0,0 @@
-=begin
-    Copyright (C) 2015  Carl P. Corliss <rabbitt@gmail.com>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-=end
-
-require_relative 'core_ext'
-require_relative 'errors'
-
-module FqdnFacts
-  #
-  # base class for all handlers.
-  #
-  class BaseHandler
-    class << self
-      # Creates a new instance of this object using the internal state
-      # of another handler object
-      def copy_from(other)
-        new(other.export)
-      end
-    end
-
-    attr_accessor :priority, :fqdn
-
-    # default validation hash of FQDN components
-    DEFAULT_COMPONENTS = {
-      host: %r'(.+)',
-      sub: %r:(.+):,
-      tld: %r'(.+)'
-    } unless defined? DEFAULT_COMPONENTS
-    private_constant :DEFAULT_COMPONENTS
-
-    # initilalizer
-    def initialize(data = {})
-      @priority        = data.delete(:priority)        || 1
-      @conversions     = data.delete(:conversions)     || {}
-      @components      = data.delete(:components)      || DEFAULT_COMPONENTS.dup
-      @component_order = data.delete(:component_order) || DEFAULT_COMPONENTS.keys
-      @facts           = data.delete(:facts)           || {}
-      @fqdn            = ''
-
-      add_fact :fqdn, ->() { @fqdn }
-      add_fact :handler_name, self.class.to_s.split('::').last.underscore
-    end
-
-    ## DSL Methods
-    # @!group DSL
-
-    # The priority of the registered Fqdn Fact handler
-    #
-    # Lower priority fqdn fact handlers win out over
-    # higer priority handlers.
-    #
-    # @return Integer
-    def priority(value = nil)
-      return @priority if value.nil?
-      @priority = value.to_i
-    end
-
-    # Defines the order of the defined components
-    # that make up the FQDN.
-    #
-    # This defaults to: host, :sub, :tld
-    def components(*args)
-      @component_order = args
-    end
-
-    # Define a validation rule for a component.
-    #
-    # Validation rules can be one of the following
-    #   * :any (the same as /.+/), Hash
-    #   * A Hash of sub_component/regexs
-    #   * An array of valid values
-    #   * a scalar for exact matching
-    #
-    # @param component Symbol the name of the component to set validation for
-    # @param validate Hash{Symbol=>Symbol,Hash,Array,Scalar}
-    def component(component, validate=:any)
-      v = case validate
-        when :any then %r:(.+):
-        when Hash then
-          if @components[component.to_sym].is_a?(Hash)
-            basis = @components[component.to_sym]
-          else
-            basis = {}
-          end
-
-          basis.merge(
-            Hash[validate.keys.zip(
-              validate.values.collect {|v|
-                case v
-                  when :any then %r:(.+):
-                  when Regexp then v
-                  else Regexp.new(v)
-                end
-              }
-            )]
-          )
-        when Array then
-          %r:(#{validate.join('|')}):
-        else validate
-      end
-
-      if @components[component.to_sym]
-        # if their not the same class, then remove any conversions
-        unless @components[component.to_sym].is_a?(v.class)
-          @conversions.delete(component.to_sym)
-        end
-      end
-
-      @components[component.to_sym]  = v
-    end
-
-    # Defines a conversion rule for a given component.
-    # The conversion must be a Proc/Lambda
-    #
-    # @param component Symbol the name of the component to set validation for
-    # @param conversion Proc the conversion proc/lambda
-    def convert(component, conversion)
-      conversion = case conversion
-        when Hash then
-          @conversions[component.to_sym] ||= {}
-          @conversions[component.to_sym].merge(conversion)
-        else conversion
-      end
-      @conversions[component.to_sym] = conversion
-    end
-
-    # Returns the value of a fact
-    #
-    # @param name String, Symbol name of the fact to retrieve
-    def get_fact(name)
-      retrieve_facts[name.to_sym]
-    end
-
-    # Adds a fact, either using a static value, or a Proc/Lambda
-    # for runtime determination of the value.
-    #
-    # @param name String, Symbol name of the fact to add
-    # @param value
-    def add_fact(name, value)
-      @facts[name.to_sym] = value
-    end
-
-    # Removes a fact from the list of facts.
-    def remove_fact(name)
-      @facts.delete(name.to_sym)
-    end
-
-    ### End of DSL Methods
-    # @!endgroup
-
-    # retreives all facts, optionally prefixing the name of each
-    # with a string value.
-    def retrieve_facts(prefix = '')
-      facts = @facts.merge(Hash[fqdn_components])
-
-      # build facts from components
-      @components.each do |name, value|
-        case value
-        when Hash then
-          data = facts[name].scan(Regexp.new(value.values.join)).flatten
-          value.keys.zip(data).each do |key, v|
-            if @conversions[name] && @conversions[name][key]
-              facts["#{name}_#{key}".to_sym] = @conversions[name][key].call(v)
-            else
-              facts["#{name}_#{key}".to_sym] = v
-            end
-          end
-        else
-          if @conversions[name]
-            facts[name] = @conversions[name].call(facts[name])
-          end
-          @facts.merge!(name.to_sym => value)
-        end
-      end
-
-      # handle conversions
-      facts.each do |key, value|
-        if value.is_a?(Proc)
-          value = value.arity == 1 ? value.call(facts) : value.call()
-        end
-        facts[key] = value.is_a?(Symbol) ? value.to_s : value
-      end
-
-      # add prefix
-      facts.replace(
-        facts.inject({}) { |h,(k,v)| h["#{prefix}_#{k}"] = v ; h }
-      ) unless prefix.empty?
-
-      facts.reject { |k,v| v.empty? }
-    end
-
-    # Checks to see if the fqdn matches this particular FQDN Fact Handler
-    def match?(fqdn)
-      parts = fqdn.split('.', @component_order.size)
-      return unless parts.size == @component_order.size
-
-      debug "Validating #{self.class}:"
-
-      test_data = @component_order.zip(parts)
-      debug "  test data -> #{test_data.inspect}"
-
-      test_data.all? do |name, value|
-        debug "  validating component '#{name}'"
-        validation = case @components[name]
-          when Hash then Regexp.new(@components[name].values.join)
-          when nil then %r:.+:
-          else @components[name]
-        end
-
-        case validation
-          when Regexp then
-            (value =~ validation).tap { |r|
-              debug "    Regexp -> #{value.inspect} =~ #{validation.inspect} == #{r.inspect}"
-            }
-          when Array  then
-            validation.include?(value).tap { |r|
-              debug "    Array -> #{validation.inspect}.include?(#{value.inspect}) == #{r.inspect}"
-            }
-          else
-            (value == validation).tap { |r|
-              debug "    #{validation.class} -> #{value.inspect} == #{validation.inspect} == #{r.inspect}"
-            }
-        end
-      end.tap { |r| debug " ---> validation #{r ? 'successful' : 'failed'} for #{self.class}"}
-    end
-
-    # Compares the priority of this handler to another handler
-    def <=>(other)
-      self.priority <=> other.priority
-    end
-
-    # Exports the internal state as a hash
-    def export
-      instance_variables.inject({}) do |exports, name|
-        varname = name.to_s.tr('@', '').to_sym
-        exports[varname] = begin
-          Marshal.load(Marshal.dump(instance_variable_get(name)))
-        rescue TypeError
-          instance_variable_get(name).dup
-        end
-        exports
-      end
-    end
-    alias_method :to_h, :export
-
-    private
-
-    # @api private
-    def fqdn_data
-      @fqdn.split('.', @component_order.size)
-    end
-
-    # @api private
-    def fqdn_components
-      @component_order.zip(fqdn_data)
-    end
-
-    # @api private
-    def debug(message)
-      if ENV.keys.collect(&:downcase).include? 'debug'
-        STDERR.puts message
-      end
-    end
-  end
-end