scribbler 0.2.3 → 0.3.0

data/lib/scribbler/{cli.rb → cli_client.rb}

@@ -1,5 +1,5 @@
 module Scribbler
-  class CLI
+  class CLIClient
     # Run a shell command and output clean text explaining what happened
     #
     # command   - Shell command to run
@@ -20,28 +20,12 @@ module Scribbler
     #   # => nothing
     #
     # Returns the backtick return of the command
-    def self.run_command(command, poptions={})
+    def run_command(command, poptions={})
       options = {:output => true}.merge(poptions)
       output command if options[:output]
       `#{command}`
     end
 
-    # Central method for outputting text. Will serve
-    # as a central location for changing how Scribbler outputs
-    #
-    # text  - Text to output
-    #
-    # Examples:
-    #
-    #   CLI.say "Output stuff"
-    #   # "Output stuff"
-    #   # => "Output stuff"
-    #
-    # Returns whatever `puts` command returns
-    def self.say(text)
-      puts text
-    end
-
     # Copy a list of files to one location with one output
     # for the whole copy
     #
@@ -55,7 +39,7 @@ module Scribbler
     #   # => Nothing
     #
     # Returns Nothing
-    def self.mass_copy(files, destination)
+    def mass_copy(files, destination)
       output 'cp'
       files.each do |file|
         run_command "cp #{file} #{destination}", :output => false
@@ -64,6 +48,22 @@ module Scribbler
 
     private
 
+    # Central method for outputting text. Will serve
+    # as a central location for changing how Scribbler outputs
+    #
+    # text  - Text to output
+    #
+    # Examples:
+    #
+    #   CLI.say "Output stuff"
+    #   # "Output stuff"
+    #   # => "Output stuff"
+    #
+    # Returns whatever `puts` command returns
+    def say(text)
+      puts text
+    end
+
     # Get the command and try to output a human description
     # of what's happening
     #
@@ -80,16 +80,16 @@ module Scribbler
     #   # => "Checking necessary directories are in place"
     #
     # Returns Nothing
-    def self.output(command)
-      final_out = []
-      pieces = command.split(' ')
-      case pieces.first
-      when 'mkdir'
-        final_out << "Checking necessary directories are in place"
-      when 'cp'
-        final_out << "Coping files"
-      end
-      say final_out.join ' '
+    def output(command)
+      base_command = command.split(' ').first
+      say out_definitions[base_command]
+    end
+
+    def out_definitions
+      Hash.new { |h,k| h[k.to_s] ||= "Running command: #{k}" }.tap { |hash|
+        hash["cp"] = "Coping files"
+        hash["mkdir"] = "Checking necessary directories are in place"
+      }
     end
   end
 end

data/lib/scribbler/configurator.rb

@@ -1,7 +1,55 @@
 module Scribbler
   class Configurator
-    class << self
-      attr_accessor :logs, :application_include, :template, :use_template_by_default, :log_directory
+    attr_accessor :logs, :application_include, :template, :use_template_by_default, :log_directory
+
+    # USED FOR CONFIGURE BLOCK DEPRECATION
+    def config
+      self
+    end
+    private :config
+
+    # Gets the path of this Gem
+    #
+    # Examples:
+    #
+    #   Configurator.gem_path
+    #   # => '/some/home/.rvm/gems/ruby-1.9.3-p125/gems/scribbler-0.0.1/'
+    #
+    # Returns String of the current gem's directory path
+    def gem_path
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+    end
+
+    # Gets all the paths to the template files in the gem's template directory
+    #
+    # Examples:
+    #
+    #   Configurator.templates
+    #   # => ['/some/home/.rvm/gems/ruby-1.9.3-p125/gems/scribbler-0.0.1/templates/1.rb',
+    #   #     '/some/home/.rvm/gems/ruby-1.9.3-p125/gems/scribbler-0.0.1/templates/2.rb]
+    #
+    # Returns Array of Strings of the gem's template files
+    def templates
+      Dir.glob(File.join(gem_path, 'templates', '*'))
+    end
+
+    # Gets the path to the default install directory. If Rails is present
+    # it will default to the Rails.root/config/initializers/. Otherwise
+    # it assumes its the $PWD/config/initializer. Should look at a cleaner
+    # abstraction of this
+    #
+    # Examples:
+    #
+    #   Configurator.default_install_path
+    #   # => '/some/home/projects/rails_app/config/initializers/'
+    #
+    # Returns String for best guess of a good install path
+    def default_install_path
+      begin
+        ::Rails.root.join 'config', 'initializers', ''
+      rescue NameError
+        File.join Dir.pwd, 'config', 'initializers', ''
+      end
     end
 
     # Provides location for getting the directory Scribbler will place
@@ -14,10 +62,10 @@ module Scribbler
     #   # => "/some/path/to/log/"
     #
     # Returns String for log directory location
-    def self.log_directory
+    def log_directory
       @log_directory ||= begin
                            Rails.root.join('log')
-                         rescue NameError
+                         rescue => e
                            File.join Dir.pwd, 'log'
                          end
     end
@@ -36,12 +84,12 @@ module Scribbler
     # Returns boolean
     #
     # TODO: Allow the class we're sending the include to to be custom
-    def self.application_include
+    def application_include
       @application_include || false
     end
 
     # Boolean for deciding if we should use the logger template by
-    # by default when calling Base.log
+    # by default when calling Scribbler.log
     #
     # Default: false
     #
@@ -51,15 +99,15 @@ module Scribbler
     # # => false
     #
     # Returns boolean
-    def self.use_template_by_default
+    def use_template_by_default
       @use_template_by_default || false
     end
 
     # The method that sets a template for each log made with
-    # Base.log
+    # Scribbler.log
     #
     # The template proc is given the whole options hash that is
-    # passed through Base.log or YourApplication.log. So if you
+    # passed through Scribbler.log or YourApplication.log. So if you
     # had:
     #
     #   YourApplication.log :a_log,
@@ -79,16 +127,16 @@ module Scribbler
     #     "Message: options[:message]"
     #   end
     #
-    # From Scribbler::Base.configure that would be:
+    # From Scribbler.configure that would be:
     #
     #   config.template = proc do |options|
     #     "Message: options[:message]"
     #   end
     #
     # **Keep in mind** that the template can be ignored at any
-    # Base.log call with:
+    # Scribbler.log call with:
     #
-    #   Base.log :your_log, :template => false, :message "..."
+    #   Scribbler.log :your_log, :template => false, :message "..."
     #
     # Default:
     #
@@ -108,7 +156,7 @@ module Scribbler
     #
     # TODO: Block input that would break this
     # TODO: Test
-    def self.template
+    def template
       @template ||= proc do |options|
         begin
           if_id = options[:object].present? ? options[:object].try(:id) : 'no id'

data/lib/scribbler/executable.rb

@@ -5,10 +5,18 @@ module Scribbler
     # options   - Options from command in shell
     #           :path - changes the path its installing config files too
     #
-    def self.install(options={})
-      install_path = options[:path] || Base.default_install_path
-      CLI.run_command "mkdir -p #{install_path}"
-      CLI.mass_copy Base.templates, install_path
+    def install(options={})
+      install_path = options[:path] || config.default_install_path
+      cli.run_command "mkdir -p #{install_path}"
+      cli.mass_copy config.templates, install_path
+    end
+
+    def config
+      Scribbler.config
+    end
+
+    def cli
+      CLIClient.new
     end
   end
 end

data/lib/scribbler/includeables.rb

@@ -1,23 +1,20 @@
 module Scribbler
-  class BaseIncluder # I don't love this
-    # Wonky way of allowing Base to include the Includeables.
-    # Receives require errors with this currently.
-    #
-    # Examples:
-    #
-    #   BaseIncluder.include_includeables
-    #   # => Nothing
-    #
-    # Returns Nothing
-    # TODO Rework; there must be a more sane way of including these
-    def self.include_includeables
-      Base.send :include, Scribbler::Includeables
-    end
-  end
-
   module Includeables
     extend ActiveSupport::Concern
+
     module ClassMethods
+      def logger
+        Logger
+      end
+
+      def log(*args)
+        logger.log *args
+      end
+
+      def log_at(location)
+        LogLocation.new.find_path location
+      end
+
       def log_location_regex
         /(?<file>.*)_log_location$/
       end
@@ -40,33 +37,6 @@ module Scribbler
       def respond_to?(name)
         (m = name.to_s.match log_location_regex) ? !!m : super
       end
-
-      def log_at(file_name)
-        File.join Scribbler::Configurator.log_directory, "#{file_name}.log"
-      end
-
-      # Public: Save ourselves some repetition. Notifies error to NewRelic
-      # and drops given string into a given log.
-      #
-      # location  - Either a pathname from the above method or symbol for an above
-      #             method
-      # options   - Hash of options for logging on Ngin
-      #           :error     - Error object, mostly for passing to NewRelic
-      #           :message   - Message to log in the actual file
-      #           :new_relic - Notify NewRelic of the error (default: true)
-      #
-      # Examples
-      #
-      #   log(Ngin.subseason_log_location, :error => e, :message  => "Error message stuff", :new_relic => false)
-      #
-      #   log(:subseason, :error => e, :message => "Error message stuff")
-      #
-      #   log(:subseason, :message => "Logging like a bauss")
-      #
-      # Returns Nothing.
-      def log(location, options={})
-        Scribbler::Base.log(location, options)
-      end
     end
   end
 end

data/lib/scribbler/log_location.rb

@@ -0,0 +1,13 @@
+require 'pathname'
+module Scribbler
+  class LogLocation
+    def find_path(file_name)
+      Pathname.new File.join(config.log_directory, "#{file_name}.log")
+    end
+
+    private
+    def config
+      Scribbler.config
+    end
+  end
+end

data/lib/scribbler/logger.rb

@@ -0,0 +1,152 @@
+module Scribbler
+  class Logger
+    private
+    attr_accessor :location
+    attr_accessor :options
+
+    public
+
+    def self.log(location, options = {})
+      new(location, options).log
+    end
+
+    def initialize(location, options = {})
+      self.location = location
+      self.options = gather_log_options options
+    end
+
+    # Public: Save ourselves some repetition. Notifies error to NewRelic
+    # and drops given string into a given log.
+    #
+    # location  - Either a pathname from the above method or symbol for an above
+    #             method
+    # options   - Hash of options for logging on Ngin
+    #           :error            - Error object, mostly for passing to NewRelic
+    #           :message          - Message to log in the actual file
+    #           :custom_fields    - Custom fields dropped into the default template
+    #           :template         - Whether or not to use the template at this log
+    #           :new_relic        - Notify NewRelic of the error (default: true)
+    #
+    # Examples
+    #
+    #   log(Ngin.subseason_log_location, :error => e, :message  => "Error message stuff", :new_relic => false)
+    #
+    #   log(:subseason, :error => e, :message => "Error message stuff")
+    #
+    #   log(:subseason, :message => "Logging like a bauss")
+    #
+    # Returns Nothing.
+    def log
+      notify_new_relic options[:error], options[:new_relic]
+      apply_to_log
+    end
+
+    private
+
+    def actual_log_location
+      LogLocation.new.find_path location
+    end
+
+    def notify_new_relic(error, new_relic)
+      NewRelic::Agent.notice_error(error) if error and new_relic != false
+    rescue NameError
+      nil
+    end
+
+    def gather_log_options(given_options)
+      {
+        :template => config.use_template_by_default,
+        :stack_frame => given_options[:call_stack] ? Kernel.caller[1..-1] : nil
+      }.merge given_options
+    end
+
+    def config
+      Scribbler.config
+    end
+
+    # Builds the message and any other options into a string
+    # using the template defined in the configure.
+    #
+    # NOTE: These "options" come from the instance
+    #
+    # options   - options hash that comprises most of the important log pieces
+    #           :message  - The message we're wrapping into the templater [required]
+    #           :template - Whether or not to use the template method
+    #           **Other option information given in the .log docs
+    #
+    # Examples
+    #
+    #   build_with_template(:message => "...", :template => false)
+    #   # => "..."
+    #
+    #   build_with_template
+    #   # => nil
+    #
+    #   build_with_template(:message => "...", :template => true)
+    #   # => <<-EXAMPLE
+    #     --------------------
+    #     TEMPLATE STUFF
+    #     ....
+    #     EXAMPLE
+    #
+    # Returns nil, a string, or a string built with calling the Configurator.template method
+    def build_with_template
+      options[:message] = options[:message].to_s.strip_heredoc.rstrip
+      template.call options
+    end
+
+    def no_template
+      ->(o) { o[:message] }
+    end
+
+    def decypher_template_option
+      if options[:template]
+        options[:template].is_a?(Proc) ? options[:template] : default_template
+      else
+        no_template
+      end
+    end
+
+    def template_option_given?
+      options.key?(:template)
+    end
+
+    def default_template
+      config.template
+    end
+
+    def template
+      template_option_given? ? decypher_template_option : default_template
+    end
+
+    # Drops built message into the log with the given location
+    #
+    # location    - location either found with Scribbler.*_log_location or by hoping a valid
+    #               path string or Path object were passed
+    # options     - options hash
+    #             :message - Message to be built and put in log file [required]
+    #             ** Other hash information given in Scribbler.log
+    #
+    # Examples
+    #
+    #   apply_to_log  # WITH :some_loc, :message => "...", :template => false, :error => e
+    #   # => Nothing
+    #
+    # Returns Nothing
+    def apply_to_log
+      if can_apply_to_log?
+        File.open actual_log_location, 'a' do |f|
+          f.puts build_with_template
+        end
+      end
+    end
+
+    # TODO: Fix to work with any template
+    def can_apply_to_log?
+      location.present? and
+        (options[:message].present? or
+         options[:object].present? or
+         options[:custom_fields].present?)
+    end
+  end
+end