quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/extlib/logger.rb

@@ -0,0 +1,202 @@
+require "time" # httpdate
+# ==== Public Merb Logger API
+#
+# To replace an existing logger with a new one:
+#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Merb.logger.fatal(message<String>,&block)
+#   Merb.logger.error(message<String>,&block)
+#   Merb.logger.warn(message<String>,&block)
+#   Merb.logger.info(message<String>,&block)
+#   Merb.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Merb.logger.fatal!(message<String>,&block)
+#   Merb.logger.error!(message<String>,&block)
+#   Merb.logger.warn!(message<String>,&block)
+#   Merb.logger.info!(message<String>,&block)
+#   Merb.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to
+#   Merb.logger.flush
+#
+# Remove the current log object
+#   Merb.logger.close
+#
+# ==== Private Merb Logger API
+#
+# To initialize the logger you create a new object, proxies to set_log.
+#   Merb::Logger.new(log{String, IO},level{Symbol, String})
+module Extlib
+
+  class << self
+    attr_accessor :logger
+  end
+
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :delimiter
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels =
+    {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }
+
+    private
+
+    # Readies a log for writing.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    def initialize_log(log)
+      close if @log # be sure that we don't leave open files laying around.
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
+      end
+    end
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Parameters
+    # *args:: Arguments to create the log from. See set_logs for specifics.
+    def initialize(*args)
+      @init_args = args
+      set_log(*args)
+    end
+
+    # Replaces an existing logger with a new one.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    # log_level<~to_sym>::
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+    #   production environment and :debug otherwise.
+    # delimiter<String>::
+    #   Delimiter to use between message sections. Defaults to " ~ ".
+    # auto_flush<Boolean>::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to false.
+    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
+      if log_level && Levels[log_level.to_sym]
+        @level = Levels[log_level.to_sym]
+      elsif Merb.environment == "production"
+        @level = Levels[:warn]
+      else
+        @level = Levels[:debug]
+      end
+      @buffer     = []
+      @delimiter  = delimiter
+      @auto_flush = auto_flush
+
+      initialize_log(log)
+
+      Merb.logger = self
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @log.write(@buffer.slice!(0..-1).to_s)
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # string<String>:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # String:: The resulting message added to the log file.
+    def <<(string = nil)
+      message = ""
+      message << delimiter
+      message << string if string
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+
+      message
+    end
+    alias :push :<<
+
+    # Generate the logging methods for Merb.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        self << message if #{number} >= level
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        self << message if #{number} >= level
+        flush if #{number} >= level
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+  end
+
+end

data/lib/quickbooks/extlib/object.rb

@@ -0,0 +1,162 @@
+class Object
+  # Extracts the singleton class, so that metaprogramming can be done on it.
+  #
+  # @return <Class> The meta class.
+  #
+  # @example [Setup]
+  #   class MyString < String; end
+  #
+  #   MyString.instance_eval do
+  #     define_method :foo do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   MyString.meta_class.instance_eval do
+  #     define_method :bar do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   def String.add_meta_var(var)
+  #     self.meta_class.instance_eval do
+  #       define_method var do
+  #         puts "HELLO"
+  #       end
+  #     end
+  #   end
+  #
+  # @example
+  #   MyString.new("Hello").foo #=> "Hello"
+  # @example
+  #   MyString.new("Hello").bar
+  #     #=> NoMethodError: undefined method `bar' for "Hello":MyString
+  # @example
+  #   MyString.foo
+  #     #=> NoMethodError: undefined method `foo' for MyString:Class
+  # @example
+  #   MyString.bar
+  #     #=> MyString
+  # @example
+  #   String.bar
+  #     #=> NoMethodError: undefined method `bar' for String:Class
+  # @example
+  #   MyString.add_meta_var(:x)
+  #   MyString.x #=> HELLO
+  #
+  # @details [Description of Examples]
+  #   As you can see, using #meta_class allows you to execute code (and here,
+  #   define a method) on the metaclass itself. It also allows you to define
+  #   class methods that can be run on subclasses, and then be able to execute
+  #   code on the metaclass of the subclass (here MyString).
+  #
+  #   In this case, we were able to define a class method (add_meta_var) on
+  #   String that was executable by the MyString subclass. It was then able to
+  #   define a method on the subclass by adding it to the MyString metaclass.
+  #
+  #   For more information, you can check out _why's excellent article at:
+  #   http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def meta_class() class << self; self end end
+
+  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
+  #
+  # @return <Object> The constant corresponding to the name.
+  def full_const_get(name)
+    list = name.split("::")
+    list.shift if list.first.blank?
+    obj = self
+    list.each do |x|
+      # This is required because const_get tries to look for constants in the
+      # ancestor chain, but we only want constants that are HERE
+      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+    end
+    obj
+  end
+
+  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
+  # @param value<Object> The value to assign to the constant.
+  #
+  # @return <Object> The constant corresponding to the name.
+  def full_const_set(name, value)
+    list = name.split("::")
+    toplevel = list.first.blank?
+    list.shift if toplevel
+    last = list.pop
+    obj = list.empty? ? Object : Object.full_const_get(list.join("::"))
+    obj.const_set(last, value) if obj && !obj.const_defined?(last)
+  end
+
+  # Defines module from a string name (e.g. Foo::Bar::Baz)
+  # If module already exists, no exception raised.
+  #
+  # @param name<String> The name of the full module name to make
+  #
+  # @return <NilClass>
+  def make_module(str)
+    mod = str.split("::")
+    current_module = self
+    mod.each do |x|
+      unless current_module.const_defined?(x)
+        current_module.class_eval "module #{x}; end"
+      end
+      current_module = current_module.const_get(x)
+    end
+    current_module
+  end
+
+  # @param duck<Symbol, Class, Array> The thing to compare the object to.
+  #
+  # @note
+  #   The behavior of the method depends on the type of duck as follows:
+  #   Symbol:: Check whether the object respond_to?(duck).
+  #   Class:: Check whether the object is_a?(duck).
+  #   Array::
+  #     Check whether the object quacks_like? at least one of the options in the
+  #     array.
+  #
+  # @return <TrueClass, FalseClass>
+  #   True if the object quacks like duck.
+  def quacks_like?(duck)
+    case duck
+    when Symbol
+      self.respond_to?(duck)
+    when Class
+      self.is_a?(duck)
+    when Array
+      duck.any? {|d| self.quacks_like?(d) }
+    else
+      false
+    end
+  end
+
+  # Override this in a child if it cannot be dup'ed
+  #
+  # @return <Object>
+  def try_dup
+    self.dup
+  end
+
+  # @param arrayish<#include?> Container to check, to see if it includes the object.
+  # @param *more<Array>:: additional args, will be flattened into arrayish
+  #
+  # @return <TrueClass, FalseClass>
+  #   True if the object is included in arrayish (+ more)
+  #
+  # @example 1.in?([1,2,3]) #=> true
+  # @example 1.in?(1,2,3) #=> true
+  def in?(arrayish,*more)
+    arrayish = more.unshift(arrayish) unless more.empty?
+    arrayish.include?(self)
+  end
+
+  # Add instance_variable_defined? for backward compatibility
+  # @param variable<Symbol, String>
+  #
+  # @return <TrueClass, FalseClass>
+  #   True if the object has the given instance variable defined
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+end

data/lib/quickbooks/extlib/pathname.rb

@@ -0,0 +1,15 @@
+class Pathname
+  # Append path segments and expand to absolute path
+  #
+  #   file = Pathname(Dir.pwd) / "subdir1" / :subdir2 / "filename.ext"
+  #
+  # @param [Pathname, String, #to_s] path path segment to concatenate with receiver
+  #
+  # @return [Pathname]
+  #   receiver with _path_ appended and expanded to an absolute path
+  #
+  # @api public
+  def /(path)
+    (self + path).expand_path
+  end
+end # class Pathname

data/lib/quickbooks/extlib/rubygems.rb

@@ -0,0 +1,38 @@
+# this is a temporary workaround until rubygems Does the Right thing here
+require 'rubygems'
+module Gem
+  class SourceIndex
+
+    # This is resolved in 1.1
+    if Version.new(RubyGemsVersion) < Version.new("1.1")
+
+      # Overwrite this so that a gem of the same name and version won't push one
+      # from the gems directory out entirely.
+      #
+      # @param gem_spec<Gem::Specification> The specification of the gem to add.
+      def add_spec(gem_spec)
+        unless gem_spec.instance_variable_get("@loaded_from") &&
+          @gems[gem_spec.full_name].is_a?(Gem::Specification) &&
+          @gems[gem_spec.full_name].installation_path ==
+            File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
+
+          @gems[gem_spec.full_name] = gem_spec
+        end
+      end
+
+    end
+
+  end
+
+  class Specification
+
+    # Overwrite this so that gems in the gems directory get preferred over gems
+    # from any other location. If there are two gems of different versions in
+    # the gems directory, the later one will load as usual.
+    #
+    # @return <Array[Array]> The object used for sorting gem specs.
+    def sort_obj
+      [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+  end
+end

data/lib/quickbooks/extlib/string.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+class String
+  ##
+  # Convert to snake case.
+  #
+  #   "FooBar".snake_case           #=> "foo_bar"
+  #   "HeadlineCNNNews".snake_case  #=> "headline_cnn_news"
+  #   "CNN".snake_case              #=> "cnn"
+  #
+  # @return [String] Receiver converted to snake case.
+  #
+  # @api public
+  def snake_case
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+      return $+.downcase
+  end
+
+  ##
+  # Convert to camel case.
+  #
+  #   "foo_bar".camel_case          #=> "FooBar"
+  #
+  # @return [String] Receiver converted to camel case.
+  #
+  # @api public
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+end # class String