scribbler 0.0.2 → 0.1.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scribbler (0.0.2)
+    scribbler (0.1.0)
       activesupport
       thor
 

data/README.markdown

@@ -15,7 +15,7 @@ Currently it assists in:
 
 In your Rails project add
 
-    gem scribbler
+    gem 'scribbler'
 
 to your Gemfile and
 

data/lib/scribbler/base.rb

@@ -1,7 +1,4 @@
 module Scribbler
-  # TODO not sure this'll work
-  delegate :configure, :to => :Base
-  delegate :log, :to => :Base
   class Base
     # Gets the path of this Gem
     #
@@ -67,6 +64,7 @@ module Scribbler
       class_eval(&block)
       Base.include_in_application
       BaseIncluder.include_includeables
+      build_methods
     end
 
     # Simply returns the configurator class.
@@ -81,7 +79,119 @@ module Scribbler
       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
+      }.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 location.present? and options[:message].present?
+        log = File.open(find_file_at(location), 'a')
+        log.puts build_with_template(options)
+        log.close
+      end
+    end
+
+    # Attempts to turn a symbol or string into the *_log_location method that
+    # was auto-build based on Configurator.logs and finds the file path
+    #
+    # location  - a string or symbol that will be turned into a *_log_location
+    #             method
+    #
+    # Examples
+    #
+    #   Base.find_file_at :a_file
+    #   # => <#Path:...>      # The method `a_file_log_location` exists
+    #
+    #   Base.find_file_at :another_file
+    #   # => :another_file    # The method `another_file_log_location` does not exist
+    #
+    # Returns Nothing
+    #
+    # TODO: allow the log base directory to be set in configurator
+    def self.find_file_at(location)
+      if location.is_a?(Symbol) or location.is_a?(String)
+        real_method = location.to_s + "_log_location"
+        location = respond_to?(real_method) ? send(real_method) : location.to_s
+      end
+      location
+    end
+
     # If the config agrees, attempt to include our special methods
     # in the main application object.
     #
@@ -91,7 +201,8 @@ module Scribbler
     #   # => Nothing
     #
     # Returns Nothing
-    # TODO Allow config to define where we send the include
+    #
+    # TODO: Allow config to define where we send the include
     def self.include_in_application
       if config.application_include
         begin

data/lib/scribbler/configurator.rb

@@ -1,15 +1,142 @@
 module Scribbler
   class Configurator
     class << self
-      attr_accessor :logs, :application_include
+      attr_accessor :logs, :application_include, :template, :use_template_by_default, :log_directory
     end
 
+    # Provides location for getting the directory Scribbler will place
+    # log files in. Favors RailsApplication/log/ but falls back to
+    # $PWD/log if not set in config
+    #
+    # Examples
+    #
+    #   Configurator.log_directory
+    #   # => "/some/path/to/log/"
+    #
+    # Returns String for log directory location
+    def self.log_directory
+      @log_directory ||= begin
+                           Rails.root.join('log')
+                         rescue NameError
+                           File.join Dir.pwd, 'log'
+                         end
+    end
+
+    # List of strings or symbols that represent logs we want methods
+    # generated for
+    #
+    # Default: []
+    #
+    # Examples
+    #
+    # Scribbler::Configurator.logs
+    # # => ['copy', 'destroy']
+    #
+    # Returns list of logs
     def self.logs
       @logs ||= []
     end
 
+    # Boolean used for deciding whether or not Scribbler should
+    # define #*_log_location methods and a .log method in a rails application
+    #
+    # Default: false
+    #
+    # Examples
+    #
+    # Scribbler::Configurator.application_include
+    # # => false
+    #
+    # Returns boolean
+    #
+    # TODO: Allow the class we're sending the include to to be custom
     def self.application_include
       @application_include || false
     end
+
+    # Boolean for deciding if we should use the logger template by
+    # by default when calling Base.log
+    #
+    # Default: false
+    #
+    # Examples
+    #
+    # Scribbler::Configurator.use_template_by_default
+    # # => false
+    #
+    # Returns boolean
+    def self.use_template_by_default
+      @use_template_by_default || false
+    end
+
+    # The method that sets a template for each log made with
+    # Base.log
+    #
+    # The template proc is given the whole options hash that is
+    # passed through Base.log or YourApplication.log. So if you
+    # had:
+    #
+    #   YourApplication.log :a_log,
+    #                       :message => "information data",
+    #                       :custom => "stuff"
+    #
+    # Then you can assume the template proc will get:
+    #
+    # options = {
+    #   :message => "information data",
+    #   :custom => "stuff"
+    # }
+    #
+    # To set a custom template:
+    #
+    #   Scribbler::Configurator.template = proc do |options|
+    #     "Message: options[:message]"
+    #   end
+    #
+    # From Scribbler::Base.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:
+    #
+    #   Base.log :your_log, :template => false, :message "..."
+    #
+    # Default:
+    #
+    # -------------------------------------------------
+    # SomeObject: #{id}                                 # options[:object] and options[:object].try(:id)
+    # Custom1: some good info                           # options[:custom_fields] hash
+    # Custom2: some better info                         # Left of colon is the key.humanize, right is the value
+    # OH NO YOU BROKED STUFF                            # options[:message].strip_heredoc
+    # DO PLX FIX                                        #
+    #
+    # Examples
+    #
+    #   Scribbler::Configurator.template
+    #   # => <#Proc:...>
+    #
+    # Returns the proc that wraps around each log entry
+    #
+    # TODO: Block input that would break this
+    # TODO: Test
+    def self.template
+      @template ||= proc do |options|
+        begin
+          if_id = options[:object].id
+        rescue NoMethodError
+          if_id = "no id"
+        end
+        custom_fields = options[:custom_fields].to_a.collect { |x| "#{x[0].to_s.humanize}: #{x[1]}" }.join("\n")
+
+        template = "-------------------------------------------------\n"
+        template << "#{Time.now}\n"
+        template << "#{options[:object].class.name}: #{if_id}\n" if options[:object]
+        template << "#{custom_fields}\n" if custom_fields.present?
+        template << "#{options[:message]}\n\n"
+      end
+    end
   end
 end

data/lib/scribbler/includeables.rb

@@ -11,7 +11,7 @@ module Scribbler
     # Returns Nothing
     # TODO Rework; there must be a more sane way of including these
     def self.include_includeables
-      Scribbler::Base.send :include, Scribbler::Includeables
+      Base.send :include, Scribbler::Includeables
     end
   end
 
@@ -37,8 +37,7 @@ module Scribbler
         # Returns Pathname to log
         Scribbler::Base.config.logs.each do |value|
           define_singleton_method "#{value}_log_location" do
-            Rails.root.join('log', "#{value}.log")
-            #TODO remove dependence on Rails here
+            File.join Scribbler::Configurator.log_directory, "#{value}.log"
           end
         end
       end
@@ -63,26 +62,7 @@ module Scribbler
       #
       # Returns Nothing.
       def log(location, options={})
-        begin
-          NewRelic::Agent.notice_error(options[:error]) if options[:error] and options[:new_relic] != false
-        rescue NameError
-          nil
-        end
-
-        real_location = location
-        if real_location.is_a?(Symbol) or real_location.is_a?(String)
-          real_method = location.to_s + "_log_location"
-          real_location = self.send(real_method) if self.respond_to? real_method
-          real_location = real_location.to_s
-        end
-
-        #if File.exists?(real_location) and options[:message].present?
-        if options[:message].present?
-          message = options[:message].strip_heredoc
-          log = File.open(real_location, 'a')
-          log.puts message
-          log.close
-        end
+        Scribbler::Base.log(location, options)
       end
     end
   end

data/lib/scribbler/version.rb

@@ -1,3 +1,3 @@
 module Scribbler
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

data/spec/scribbler/base_spec.rb

@@ -6,6 +6,7 @@ module Scribbler
 
     before :each do
       Object.send :remove_const, :Rails if defined?(Rails) == 'constant' && Rails.class == Class
+      Time.stub :now => "now"
     end
 
     it "should give me a configurator" do
@@ -34,6 +35,7 @@ module Scribbler
     describe "configure" do
       it "kicks off the module and sends includes" do
         subject.should_receive(:include_in_application).once
+        subject.should_receive(:build_methods).once # Twice if we didn't stub below method
         BaseIncluder.should_receive(:include_includeables).once
         subject.configure do
         end
@@ -46,5 +48,110 @@ module Scribbler
         subject.config.application_include.should be_true
       end
     end
+
+    describe "build with template" do
+      let(:some_object) { stub(:id => "no id", :class => stub(:name => "SomeObject")) }
+      before :each do
+        subject.configure do
+          config.application_include = false
+        end
+      end
+
+      it "calls log, skips templater and still works" do
+        Scribbler::Base.send(:build_with_template,
+                             :object => some_object,
+                             :template => false,
+                             :message => "test\n123").should == "test\n123"
+      end
+
+      it "calls log and gets message with template wrapper" do
+        Scribbler::Base.send(:build_with_template,
+                             :object => some_object,
+                             :template => true,
+                             :message => <<-MSG
+        test
+        123
+        MSG
+                           ).should == <<-MSG.strip_heredoc
+        -------------------------------------------------
+        now
+        SomeObject: no id
+        test
+        123
+
+        MSG
+      end
+
+      it "calls log and gets message with custom params" do
+        Scribbler::Base.send(:build_with_template,
+                             :template => true,
+                             :object => some_object,
+                             :custom_fields => {:test1 => 1, :test2 => 2},
+                             :message => <<-MSG
+        test
+        123
+        MSG
+                           ).should == <<-MSG.strip_heredoc
+        -------------------------------------------------
+        now
+        SomeObject: no id
+        Test1: 1
+        Test2: 2
+        test
+        123
+
+        MSG
+      end
+    end
+
+    describe "apply to log" do
+      before :each do
+        subject.configure do
+          config.logs = %w[test_log]
+        end
+      end
+
+      it "should not work without location" do
+        subject.apply_to_log(nil, :message => "...").should be_nil
+      end
+
+      it "should not work without message" do
+        subject.should_not_receive :test_log_log_location
+        subject.apply_to_log(:test_log).should be_nil
+      end
+
+      it "should build a template and try to put it in a file" do
+        options = { :message => "..." }
+        subject.should_receive(:send).with "test_log_log_location"
+        subject.should_receive(:build_with_template).with options
+        file_stub = stub
+        file_stub.should_receive :puts
+        file_stub.should_receive :close
+        File.should_receive(:open) { file_stub }
+        subject.apply_to_log :test_log, options
+      end
+    end
+
+    describe "find file at" do
+      it "doesn't find a file method" do
+        # in case we have bad config data lingering
+        subject.stub(:respond_to?).with('test_log_log_location').and_return false
+        subject.should_not_receive(:test_log_log_location)
+        subject.find_file_at(:test_log).should == 'test_log'
+      end
+
+      it "finds a file method defined" do
+        subject.configure do
+          config.logs = %w[test_log]
+        end
+        subject.should_receive(:test_log_log_location).once
+        subject.find_file_at :test_log
+      end
+
+      it "isn't a string or a symbol and just returns the input" do
+        path = Pathname.new '/'
+        subject.find_file_at(path).should be(path)
+      end
+    end
   end
 end

data/spec/scribbler/configurator_spec.rb

@@ -21,5 +21,34 @@ module Scribbler
         subject.application_include.should == true
       end
     end
+
+    describe "log directory" do
+      it "tries a rails root when Rails defined" do
+        root_stub = stub
+        root_stub.should_receive(:join).with 'log'
+        Rails = stub(:root => root_stub)
+        subject.log_directory
+      end
+
+      it "falls back to pwd/log without rails" do
+        dir = "dir/"
+        Rails.should_receive(:root).and_raise(NameError)
+        Dir.should_receive(:pwd).and_return('dir')
+        subject.log_directory.should == 'dir/log'
+      end
+
+      it "sets the log directory" do
+        var_log = File.new "/var/log"
+        subject.log_directory = var_log
+        subject.log_directory.should == var_log
+        subject.log_directory = nil
+
+        # Check the reset
+        Rails.should_receive(:root).and_raise(NameError)
+        Dir.should_receive(:pwd).and_return('dir')
+        subject.log_directory.should == 'dir/log'
+        subject.log_directory
+      end
+    end
   end
 end

data/templates/scribbler.rb

@@ -3,15 +3,66 @@ Scribbler::Base.configure do
   # Unless you'd like to experiment with breaking things and battling dragons,
   # please only use what we document here.
   #
-  # Alter the path to the configuration yaml. If you alter those variables
-  # from this config, those here will take precedence. Don't confuse yourself
-  # by having thos options here and there.
-  #
-  # config.yaml_config_path = Rails.root.join('config', 'scribbler.yml')
-  #
   # Include the log methods to the rails application. So, if you have an
   # application called Blog you can do Blog.log(...), rather than
   # Scribbler.log(...). Default: false
   #
   # config.application_include = true
+  #
+  #
+  # What directory should these logs be placed in? The default is
+  # to try the Rails log directory and fallback to the $PWD/log path
+  #
+  # config.log_directory = File.new '/a/better/path'
+  #
+  #
+  # A list of the logs you'd like location methods for. if the logs list
+  # has:
+  #
+  #   ['log1']
+  #
+  # You are afforded a Base.log1_log_location method and you may do:
+  #
+  #   Base.log :log1, ....
+  #
+  # REQUIRED
+  #
+  # config.logs = %w[log1 log2]
+  #
+  # This option enables log templating. Each time you log a message you
+  # can have it automatically wrapped in some sugar. The default is something
+  # like:
+  #
+  # -------------------------------------------------
+  # SomeObject: #{id}                                 # options[:object] and options[:object].try(:id)
+  # Custom1: some good info                           # options[:custom_fields] hash
+  # Custom2: some better info                         # Left of colon is the key.humanize, right is the value
+  # OH NO YOU BROKED STUFF                            # options[:message].strip_heredoc
+  # DO PLX FIX                                        #
+  #
+  # If you would rather this not be default you may set this to false. Keep
+  # in mind, there is an option on the Base.log to enable or disable the
+  # template on a per-call basis. (:template)
+  #
+  # config.use_template_by_default = true # Default: false
+  #
+  #
+  # Don't like the default template above? Write your own proc here.
+  # The proc is given the options hash that you give to Base.log so you're
+  # given plenty of control over what information you have to work with.
+  #
+  # 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)
+  #
+  # config.template = proc do |options|
+  #   <<-MSG
+  #   ##########
+  #   Cool template bro!
+  #   Message: #{options[:message]}
+  #   MSG
+  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scribbler
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-20 00:00:00.000000000 Z
+date: 2012-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -140,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2255771618684195708
+      hash: -504908089194974695
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -149,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2255771618684195708
+      hash: -504908089194974695
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24