scribbler 0.2.3 → 0.3.0

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+coverage

data/.irbrc

@@ -0,0 +1,2 @@
+$:<< "./lib"
+require 'scribbler'

data/.rvmrc

@@ -1,4 +1,4 @@
-rvm --create ruby-1.9.3-p125@scribbler
+rvm --create ruby-1.9.3-p327-turbo@scribbler
 # Ensure that Bundler is installed, install it if it is not.
 if ! command -v bundle > /dev/null; then
   gem install bundler

data/README.md

@@ -1,6 +1,7 @@
 # Scribbler
 
 [![TravisCI](https://secure.travis-ci.org/jphenow/scribbler.png "TravisCI")](http://travis-ci.org/jphenow/scribbler "Travis-CI Scribbler")
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/jphenow/scribbler)
 
 [RubyGems](https://rubygems.org/gems/scribbler)
 
@@ -11,79 +12,122 @@ Currently it assists in:
 * Centralized log method for file, message, and error checks
   - Currently also able to notify NewRelic, abstraction and extension to come
 
+## Notes on upgrading to 0.3.0
+
+Scribbler was initially written with a lot of class-level (almost entirely) operations.
+For sanity sake, the version 0.3.0 is the big step towards dropping most of the gem into
+instances. There isn't much functionality change yet, but it will make expanding the gem much
+simpler to develop.
+
+### Changes For You
+
+`Scribbler::Base` is now deprecated, look to remove. See `Scribbler`
+
+`Scribbler.configure` now yields the configurator so you now want to change from:
+
+```ruby
+Scribbler::Base.configure do
+  config.some_config_options
+  # ...
+end
+```
+
+to
+
+```ruby
+Scribbler.configure do |config|
+  config.some_config_options
+  # ...
+end
+```
+
 ## Usage
 
 In your Rails project add
 
-    gem 'scribbler'
+```ruby
+gem 'scribbler'
+```
 
 to your Gemfile and
 
-    bundle install
+```bash
+bundle install
+```
 
 Then
 
-    scribbler install # For options do `scribbler` first
+```bash
+scribbler install # For options do `scribbler` first
+```
 
 You'll find your configuration options in `config/initializers/scribbler.rb`.
 **Better, more documented examples in the template file provided by `scribbler install`**
 As an example, with this configuration file in a Rails app called `Blogger`:
 
-    Scribbler::Base.configure do
-      config.application_include = true
-
-      # config.log_directory = File.new '/a/better/path'
+```ruby
+Scribbler.configure do |config|
+  config.application_include = true
 
-      config.logs = %w[production delayed_job]
+  # config.log_directory = File.new '/a/better/path'
 
-      config.use_template_by_default = true # Default: false
+  config.use_template_by_default = true # Default: false
 
-      # config.template = proc do |options|
-      #   <<-MSG
-      #   ##########
-      #   Cool template bro!
-      #   Message: #{options[:message]}
-      #   MSG
-      # end
-    end
+  # config.template = proc do |options|
+  #   <<-MSG
+  #   ##########
+  #   Cool template bro!
+  #   Message: #{options[:message]}
+  #   MSG
+  # end
+end
+```
 
 You are given a few methods for free. To get the production logfile location:
 
-    Blogger.production_log_location
-    # => <#Path: Rails.root.join('log', 'production.log')>
+```ruby
+Blogger.production_log_location
+# => <#Path: Rails.root.join('log', 'production.log')>
+```
 
 or
 
-    Scribbler::Base.production_log_location
-    # => <#Path: Rails.root.join('log', 'production.log')>
+```ruby
+Scribbler.production_log_location
+# => <#Path: Rails.root.join('log', 'production.log')>
+```
 
 More importantly you're given access to a sweet `log` method:
 
-    # Notifies NewRelic and drops the message in log found at Blogger.production_log_location
-    Blogger.log :production, :error => e, :message => "#{e} broke stuff"
-    Scribbler::Base.log :production, :error => e, :message => "#{e} broke stuff"
+```ruby
+# Notifies NewRelic and drops the message in log found at Blogger.production_log_location
+Blogger.log :production, :error => e, :message => "#{e} broke stuff"
+Scribbler.log :production, :error => e, :message => "#{e} broke stuff"
 
-    # Only logs to log/delayed_job.log and doesn't notify NewRelic
-    Blogger.log :delayed_job, :message => "Successfully executed Delayed Job"
-    Scribbler::Base.log :delayed_job, :message => "Successfully executed Delayed Job"
+# Only logs to log/delayed_job.log and doesn't notify NewRelic
+Blogger.log :delayed_job, :message => "Successfully executed Delayed Job"
+Scribbler.log :delayed_job, :message => "Successfully executed Delayed Job"
 
-    # Doesn't notify NewRelic but gives the method access to the error and logs the message
-    # to the given logfile
-    Blogger.log 'production', :new_relic => false, :error => e, :message => "#{e} broke stuff"
-    Scribbler::Base.log 'production', :new_relic => false, :error => e, :message => "#{e} broke stuff"
+# Doesn't notify NewRelic but gives the method access to the error and logs the message
+# to the given logfile
+Blogger.log 'production', :new_relic => false, :error => e, :message => "#{e} broke stuff"
+Scribbler.log 'production', :new_relic => false, :error => e, :message => "#{e} broke stuff"
 
-    # Logs to given file without using the fancy log methods
-    Blogger.log File.expand_path(File.join(File.dirname(__FILE__), 'logfile.log')), :message => "#{e} broke stuff"
-    Scribbler::Base.log File.expand_path(File.join(File.dirname(__FILE__), 'logfile.log')), :message => "#{e} broke stuff"
+# Logs to given file without using the fancy log methods
+Blogger.log File.expand_path(File.join(File.dirname(__FILE__), 'logfile.log')), :message => "#{e} broke stuff"
+Scribbler.log File.expand_path(File.join(File.dirname(__FILE__), 'logfile.log')), :message => "#{e} broke stuff"
+```
 
 Log options with the default template proc:
 
-    options   - Hash of options for logging on Ngin
-              :error            - Error object, mostly for passing to NewRelic
-              :message          - Message to log in the actual file [REQUIRED]
-              :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)
+```
+# options   - Hash of options for logging on Ngin
+#             :error            - Error object, mostly for passing to NewRelic
+#             :message          - Message to log in the actual file [REQUIRED]
+#             :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)
+```
 
 With the template enabled (either during call to log [:template => true] or by setting to
 be used by default) you will have each log entry wrapped into a template to pretty-up and
@@ -94,7 +138,10 @@ docs and specs for more information.
 
 * Configure the module/class receiving the include
 * Configurable notification gem (NewRelic, Airbrake, etc.)
+* Have default template cascade through hashes/arrays for prettier viewing
 * Currently attempts to notify NewRelic if its there, abstract and allow custom services
 * Allow a class to set default options for a log call within itself
 * Allow there to be a log made without the option[:message], in case its all custom_fields or someting
 * Allow event hooks on log call?
+* Log4r support
+* Bring class-level methods down to instance methods (More OO)

data/bin/scribbler

@@ -7,7 +7,7 @@ class ScribblerExecutable < Thor
   desc "install", "Installs the necessary files for Scribbler (default: config/initializers/scribbler.rb)"
   method_option :path, :aliases => "-p", :desc => "Specify a different path for the scribbler initialization"
   def install
-    Scribbler::Executable.install(options)
+    Scribbler::Executable.new.install(options)
   end
 end
 

data/lib/scribbler.rb

@@ -1,7 +1,68 @@
 require 'active_support/all'
 require 'scribbler/version'
 require 'scribbler/configurator'
-require 'scribbler/base'
+require 'scribbler/log_location'
+require 'scribbler/logger'
 require 'scribbler/includeables'
-require 'scribbler/cli'
+require 'scribbler/cli_client'
 require 'scribbler/executable'
+
+module Scribbler
+  include Includeables
+  # Rails style configure block with some cleanup afterwards. This is the
+  # main method that kicks off the module and is necessary for its operation
+  #
+  # &block  - Block is class_eval'd to give total access to the config file.
+  #           Most importantly giving access to `config` object
+  #
+  # Examples:
+  #
+  #   Scribbler.configure do |config|
+  #     config.logs = %w[log1 log2]
+  #     config.application_include = true
+  #   end
+  #   # => Nothing
+  #
+  # Returns Nothing
+  # TODO Abstract the callbacks so that we can just add them where they're written
+  def self.configure
+    yield config
+    include_in_application
+  end
+
+  # Simply returns the configurator class.
+  #
+  # Examples:
+  #
+  #   Scribbler.config
+  #   # => Scribbler::Configurator
+  #
+  # Returns the singleton configurator
+  def self.config
+    @config ||= Configurator.new
+  end
+
+  private
+
+  # If the config agrees, attempt to include our special methods
+  # in the main application object.
+  #
+  # Example:
+  #
+  #   Scribbler.include_in_application
+  #   # => Nothing
+  #
+  # Returns Nothing
+  #
+  # TODO: Allow config to define where we send the include
+  def self.include_in_application
+    if config.application_include
+      begin
+        ::Rails.application.class.parent.send :include, Includeables
+      rescue NameError
+        nil
+      end
+    end
+  end
+end
+require 'scribbler/base'

data/lib/scribbler/base.rb

@@ -1,199 +1,23 @@
 module Scribbler
-  class Base
-    # Gets the path of this Gem
-    #
-    # Examples:
-    #
-    #   Base.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 self.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:
-    #
-    #   Base.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 self.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:
-    #
-    #   Base.default_install_path
-    #   # => '/some/home/projects/rails_app/config/initializers/'
-    #
-    # Returns String for best guess of a good install path
-    def self.default_install_path
-      begin
-        ::Rails.root.join 'config', 'initializers', ''
-      rescue NameError
-        File.join Dir.pwd, 'config', 'initializers', ''
-      end
-    end
-
-    # Rails style configure block with some cleanup afterwards. This is the
-    # main method that kicks off the module and is necessary for its operation
-    #
-    # &block  - Block is class_eval'd to give total access to the config file.
-    #           Most importantly giving access to `config` object
-    #
-    # Examples:
-    #
-    #   Base.configure do
-    #     config.logs = %w[log1 log2]
-    #     config.application_include = true
-    #   end
-    #   # => Nothing
-    #
-    # Returns Nothing
-    # TODO Abstract the callbacks so that we can just add them where they're written
+  module Base
     def self.configure(&block)
-      class_eval(&block)
-      Base.include_in_application
-      BaseIncluder.include_includeables
-    end
-
-    # Simply returns the configurator class.
-    #
-    # Examples:
-    #
-    #   Base.config
-    #   # => Scribbler::Configurator
-    #
-    # Returns the singleton configurator
-    def self.config
-      Scribbler::Configurator
-    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 self.log(location, options={})
-      options = {
-        :template => config.use_template_by_default,
-        :stack_frame => options[:call_stack] ? Kernel.caller[1..-1] : nil
-      }.merge options
-      begin
-        NewRelic::Agent.notice_error(options[:error]) if options[:error] and options[:new_relic] != false
-      rescue NameError
-        nil
-      end
-
-      apply_to_log location, options
-    end
-
-    private
-    # Builds the message and any other options into a string
-    # using the template defined in the configure
-    #
-    # 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
-    #
-    #   Base.build_with_template(:message => "...", :template => false)
-    #   # => "..."
-    #
-    #   Base.build_with_template
-    #   # => nil
-    #
-    #   Base.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 self.build_with_template(options={})
-      if options[:message].present?
-        options[:message] = options[:message].strip_heredoc.rstrip
-        options[:template] ? config.template.call(options) : options[:message]
-      end
-    end
-
-    # Drops built message into the log with the given location
-    #
-    # location    - location either found with Base.*_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 Base.log
-    #
-    # Examples
-    #
-    #   Base.apply_to_log :some_loc, :message => "...", :template => false, :error => e
-    #   # => Nothing
-    #
-    # Returns Nothing
-    def self.apply_to_log(location, options={})
-      if can_apply_to_log? location, options
-        File.open log_at(location), 'a' do |f|
-          f.puts build_with_template(options)
-        end
+      ActiveSupport::Deprecation.deprecated_method_warning :configure,
+        "Scribbler is now preferred over Scribbler::Base see github for more info"
+      Scribbler.configure { |config| config.instance_eval(&block) }
+    end
+
+    def self.method_missing(method, *args, &block)
+      if Scribbler.respond_to? method
+        ActiveSupport::Deprecation.deprecated_method_warning method,
+          "Scribbler is now preferred over Scribbler::Base see github for more info"
+        Scribbler.public_send method, *args, &block
+      else
+        super
       end
     end
 
-    # TODO: Fix to work with any template
-    def self.can_apply_to_log?(location, options)
-      location.present? and
-        (options[:message].present? or
-         options[:object].present? or
-         options[:custom_fields].present?)
-    end
-
-    # If the config agrees, attempt to include our special methods
-    # in the main application object.
-    #
-    # Example:
-    #
-    #   Base.include_in_application
-    #   # => Nothing
-    #
-    # Returns Nothing
-    #
-    # TODO: Allow config to define where we send the include
-    def self.include_in_application
-      if config.application_include
-        begin
-          ::Rails.application.class.parent.send :include, Includeables
-        rescue NameError
-          nil
-        end
-      end
+    def self.respond_to?(method, include_private = false)
+      Scribbler.respond_to?(method) || super
     end
   end
 end