chef-api 0.2.0

data/lib/chef-api/logger.rb

@@ -0,0 +1,160 @@
+require 'logger'
+
+module ChefAPI
+  module Logger
+    class << self
+      # @private
+      def included(base)
+        base.send(:extend,  ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      #
+      # Get the logger class for the given name. If a logger does not exist
+      # for the given name, a new one is created.
+      #
+      # @param [String] name
+      #   the name of the logger to find
+      #
+      # @return [DefaultLogger]
+      #   the logger for the given name
+      #
+      def logger_for(name)
+        loggers[name] ||= DefaultLogger.new(name, level)
+      end
+
+      #
+      # The global log level.
+      #
+      # @return [Symbol]
+      #
+      def level
+        @level ||= :warn
+      end
+
+      #
+      # Set the global log level.
+      #
+      # @param [String, Symbol] level
+      #   the log level
+      #
+      # @return [Symbol]
+      #
+      def level=(level)
+        @level = level.to_s.downcase.to_sym
+
+        loggers.each do |_, logger|
+          logger.level = @level
+        end
+
+        @level
+      end
+
+      private
+
+      def loggers
+        @loggers ||= {}
+      end
+    end
+
+    module ClassMethods
+      #
+      # Write a message to the logger for this class.
+      #
+      # @return [DefaultLogger]
+      #
+      def log
+        @log ||= Logger.logger_for(name)
+      end
+    end
+
+    module InstanceMethods
+      #
+      # Write a message to the logger for this instance's class.
+      #
+      # @return [DefaultLogger]
+      #
+      def log
+        @log ||= Logger.logger_for(self.class.name)
+      end
+    end
+
+    #
+    # The default logger for everything logged through the Chef API.
+    #
+    class DefaultLogger < ::Logger
+      class << self
+        private
+
+        #
+        # @macro attr_questioner
+        #
+        #   @method $1?
+        #     Determine if the current logger's level is +:$1+.
+        #
+        #     @return [Boolean]
+        #       true if the current log level is +:$1+ or lower, false otherwise
+        #
+        def attr_questioner(name)
+          class_eval <<-EOH, __FILE__, __LINE__ + 1
+            def #{name}?
+              level == ::Logger::Severity.const_get('#{name}'.upcase)
+            end
+          EOH
+        end
+      end
+
+      attr_questioner :fatal
+      attr_questioner :error
+      attr_questioner :warn
+      attr_questioner :info
+      attr_questioner :debug
+
+      #
+      # Create a new logger with the given name. In debug mode, the +name+ is
+      # used to identify the caller of the log message. In other modes, it is
+      # ignored entirely.
+      #
+      # @param [String] name
+      #   the name of the class calling the logger
+      #
+      def initialize(name, level)
+        super($stdout)
+
+        @formatter = formatter
+        @progname  = name
+        self.level = level
+      end
+
+      #
+      # Set this logger's level to the given key.
+      #
+      # @example Set the log level to +info+
+      #   logger.level = :info
+      #
+      # @param [String, Symbol] value
+      #   the value to set for the logger
+      #
+      def level=(value)
+        @level = ::Logger::Severity.const_get(value.to_s.upcase)
+      end
+
+      private
+
+      def formatter
+        Proc.new do |severity, timestamp, progname, message|
+          if debug?
+            "[#{progname}] #{message}\n"
+          else
+            message + "\n"
+          end
+        end
+      end
+    end
+
+    class NullLogger < DefaultLogger
+      def initialize(*args); end
+      def add(*args, &block); end
+    end
+  end
+end

data/lib/chef-api/proxy.rb

@@ -0,0 +1,72 @@
+module ChefAPI
+  #
+  # Create a proxy object, which delegates all methods to the class given in
+  # the initializer. This is used by the client object to filter the first
+  # parameter of any singleton methods to pass in the given client as the first
+  # argument. It's dirty, but it allows developers to write pretty code, which
+  # is more what I care about.
+  #
+  # @example Without a proxy object
+  #   client = ChefAPI::Client.new('...')
+  #   repo = ChefAPI::Resource::Repository.new(client, name: '...')
+  #
+  # @example With a proxy object
+  #   client = ChefAPI::Client.new('...')
+  #   repo = client.repositories.new(name: '...')
+  #
+  class Proxy < BasicObject
+    #
+    # This is quite possibly the worst thing I've ever done in my life.
+    # Dynamically remove all methods from this class, just we we can delegate
+    # *everything* to the instance class.
+    #
+    # It is presumed there is no hope...
+    #
+    instance_methods.each do |name|
+      unless name =~ /__|object_id|instance_eval/
+        undef_method name
+      end
+    end
+
+    #
+    # Create a new proxy object.
+    #
+    # @param [ChefAPI::Client] client
+    #   the client object to use for the proxy
+    # @param [Class] klass
+    #   the class to proxy to
+    #
+    def initialize(client, klass)
+      @client = client
+      @klass  = klass
+
+      klass.singleton_methods.each do |name|
+        instance_eval <<-EOH, __FILE__, __LINE__ + 1
+          def #{name}(*args)
+            if args.last.is_a?(::Hash)
+              args.last[:client] = @client
+            else
+              args << { client: @client }
+            end
+
+            @klass.send(:#{name}, *args)
+          end
+        EOH
+      end
+    end
+
+    # @private
+    def method_missing(m, *args, &block)
+      if @klass.respond_to?(m)
+        @klass.send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    # @private
+    def respond_to_missing?(m, include_private = false)
+      @klass.respond_to?(m) || super
+    end
+  end
+end

data/lib/chef-api/resource.rb

@@ -0,0 +1,16 @@
+module ChefAPI
+  module Resource
+    autoload :Base,            'chef-api/resources/base'
+    autoload :Client,          'chef-api/resources/client'
+    autoload :CollectionProxy, 'chef-api/resources/collection_proxy'
+    autoload :Cookbook,        'chef-api/resources/cookbook'
+    autoload :CookbookVersion, 'chef-api/resources/cookbook_version'
+    autoload :DataBag,         'chef-api/resources/data_bag'
+    autoload :DataBagItem,     'chef-api/resources/data_bag_item'
+    autoload :Environment,     'chef-api/resources/environment'
+    autoload :Node,            'chef-api/resources/node'
+    autoload :Principal,       'chef-api/resources/principal'
+    autoload :Role,            'chef-api/resources/role'
+    autoload :User,            'chef-api/resources/user'
+  end
+end