tennpipes-base 3.6.6

data/lib/tennpipes-base/command.rb

@@ -0,0 +1,38 @@
+require 'rbconfig'
+
+module Tennpipes
+  ##
+  # This method return the correct location of tennpipes bin or
+  # exec it using Kernel#system with the given args.
+  #
+  # @param [Array] args
+  #   command or commands to execute
+  #
+  # @return [Boolean]
+  #
+  # @example
+  #   Tennpipes.bin('start', '-e production')
+  #
+  def self.bin(*args)
+    @_tennpipes_bin ||= [self.ruby_command, File.expand_path("../../../bin/tennpipes", __FILE__)]
+    args.empty? ? @_tennpipes_bin : system(args.unshift(@_tennpipes_bin).join(" "))
+  end
+
+  ##
+  # Return the path to the ruby interpreter taking into account multiple
+  # installations and windows extensions.
+  #
+  # @return [String]
+  #   path to ruby bin executable
+  #
+  def self.ruby_command
+    @ruby_command ||= begin
+      ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+      ruby << RbConfig::CONFIG['EXEEXT']
+
+      # escape string in case path to ruby executable contain spaces.
+      ruby.sub!(/.*\s.*/m, '"\&"')
+      ruby
+    end
+  end
+end

data/lib/tennpipes-base/ext/sinatra.rb

@@ -0,0 +1,29 @@
+require 'sinatra/base'
+
+##
+# Adds to Sinatra +controller+ informations
+#
+class Sinatra::Request
+  attr_accessor :route_obj
+
+  def controller
+    route_obj && route_obj.controller
+  end
+  def action
+    route_obj && route_obj.action
+  end
+end
+
+##
+# This patches Sinatra to accept UTF-8 urls on JRuby 1.7.6
+#
+if RUBY_ENGINE == 'jruby' && defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7.4'
+  class Sinatra::Base
+    class << self
+      alias_method :old_generate_method, :generate_method
+      def generate_method(method_name, &block)
+        old_generate_method(method_name.to_sym, &block)
+      end
+    end
+  end
+end

data/lib/tennpipes-base/filter.rb

@@ -0,0 +1,52 @@
+module Tennpipes
+  class Filter
+    attr_reader :block
+
+    def initialize(mode, scoped_controller, options, args, &block)
+      @mode = mode
+      @scoped_controller = scoped_controller
+      @options = options
+      @args = args
+      @block = block
+    end
+
+    def apply?(request)
+      detect = match_with_arguments?(request) || match_with_options?(request)
+      detect ^ !@mode
+    end
+
+    def to_proc
+      if @args.empty? && @options.empty?
+        block
+      else
+        filter = self
+        proc { instance_eval(&filter.block) if filter.apply?(request) }
+      end
+    end
+
+    private
+
+    def scoped_controller_name
+      @scoped_controller_name ||= Array(@scoped_controller).join("_")
+    end
+
+    def match_with_arguments?(request)
+      route = request.route_obj
+      path = request.path_info
+      @args.any? do |argument|
+        if argument.instance_of?(Symbol)
+          next unless route
+          name = route.name
+          argument == name || name == [scoped_controller_name, argument].join(" ").to_sym
+        else
+          argument === path
+        end
+      end
+    end
+
+    def match_with_options?(request)
+      user_agent = request.user_agent
+      @options.any?{|name, value| value === (name == :agent ? user_agent : request.send(name)) }
+    end
+  end
+end

data/lib/tennpipes-base/loader.rb

@@ -0,0 +1,202 @@
+module Tennpipes
+  module Loader
+    ##
+    # Hooks to be called before a load/reload.
+    #
+    # @yield []
+    #   The given block will be called before Tennpipes was loaded/reloaded.
+    #
+    # @return [Array<Proc>]
+    #   The load/reload before hooks.
+    #
+    # @example
+    #   before_load do
+    #     pre_initialize_something
+    #   end
+    #
+    def before_load(&block)
+      @_before_load ||= []
+      @_before_load << block if block_given?
+      @_before_load
+    end
+
+    ##
+    # Hooks to be called after a load/reload.
+    #
+    # @yield []
+    #   The given block will be called after Tennpipes was loaded/reloaded.
+    #
+    # @return [Array<Proc>]
+    #   The load/reload hooks.
+    #
+    # @example
+    #   after_load do
+    #     DataMapper.finalize
+    #   end
+    #
+    def after_load(&block)
+      @_after_load ||= []
+      @_after_load << block if block_given?
+      @_after_load
+    end
+
+    ##
+    # Requires necessary dependencies as well as application files from root
+    # lib and models.
+    #
+    # @return [Boolean]
+    #   returns true if Tennpipes is not already bootstraped otherwise else.
+    #
+    def load!
+      return false if loaded?
+      began_at = Time.now
+      @_called_from = first_caller
+      set_encoding
+      Tennpipes.logger
+      Reloader.lock!
+      before_load.each(&:call)
+      require_dependencies(*dependency_paths)
+      after_load.each(&:call)
+      logger.devel "Loaded Tennpipes in #{Time.now - began_at} seconds"
+      precompile_all_routes!
+      Thread.current[:tennpipes_loaded] = true
+    end
+
+    ##
+    # Precompiles all routes if :precompile_routes is set to true
+    #
+    def precompile_all_routes!
+      mounted_apps.each do |app|
+        app_obj = app.app_obj
+        next unless app_obj.respond_to?(:precompile_routes?) && app_obj.precompile_routes?
+        app_obj.setup_application!
+        logger.devel "Precompiled routes of #{app_obj} (routes size #{app_obj.compiled_router.routes.size})"
+      end
+    end
+
+    ##
+    # Clear the tennpipes env.
+    #
+    # @return [NilClass]
+    #
+    def clear!
+      clear_middleware!
+      mounted_apps.clear
+      @_dependency_paths = nil
+      before_load.clear
+      after_load.clear
+      global_configurations.clear
+      Reloader.clear!
+      Thread.current[:tennpipes_loaded] = nil
+    end
+
+    ##
+    # Method for reloading required applications and their files.
+    #
+    def reload!
+      return unless Reloader.changed?
+      before_load.each(&:call)
+      Reloader.reload!
+      after_load.each(&:call)
+    end
+
+    ##
+    # This adds the ability to instantiate {Tennpipes.load!} after
+    # {Tennpipes::Application} definition.
+    #
+    def called_from
+      @_called_from || first_caller
+    end
+
+    ##
+    # Determines whether Tennpipes was loaded with {Tennpipes.load!}.
+    #
+    # @return [Boolean]
+    #   Specifies whether Tennpipes was loaded.
+    #
+    def loaded?
+      Thread.current[:tennpipes_loaded]
+    end
+
+    ##
+    # Attempts to require all dependency libs that we need.
+    # If you use this method we can perform correctly a Tennpipes.reload!
+    # Another good thing that this method are dependency check, for example:
+    #
+    #   # models
+    #   #  \-- a.rb => require something of b.rb
+    #   #  \-- b.rb
+    #
+    # In the example above if we do:
+    #
+    #   Dir["/models/*.rb"].each { |r| require r }
+    #
+    # We get an error, because we try to require first +a.rb+ that need
+    # _something_ of +b.rb+.
+    #
+    # With this method we don't have this problem.
+    #
+    # @param [Array<String>] paths
+    #   The paths to require.
+    #
+    # @example For require all our app libs we need to do:
+    #   require_dependencies("#{Tennpipes.root}/lib/**/*.rb")
+    #
+    def require_dependencies(*paths)
+      options = paths.extract_options!.merge( :cyclic => true )
+      files = paths.flatten.flat_map{ |path| Dir.glob(path).sort_by{ |filename| filename.count('/') } }.uniq
+
+      until files.empty?
+        error = fatal = loaded = nil
+
+        files.dup.each do |file|
+          begin
+            Reloader.safe_load(file, options)
+            files.delete(file)
+            loaded = true
+          rescue NameError, LoadError => error
+            logger.devel "Cyclic dependency reload for #{error.class}: #{error.message}"
+          rescue Exception => fatal
+            break
+          end
+        end
+
+        if fatal || !loaded
+          exception = fatal || error
+          logger.exception exception, :short
+          raise exception
+        end
+      end
+    end
+
+    ##
+    # Returns default list of path globs to load as dependencies.
+    # Appends custom dependency patterns to the be loaded for Tennpipes.
+    #
+    # @return [Array<String>]
+    #   The dependencey paths.
+    #
+    # @example
+    #   Tennpipes.dependency_paths << "#{Tennpipes.root}/uploaders/*.rb"
+    #
+    def dependency_paths
+      @_dependency_paths ||= default_dependency_paths + modules_dependency_paths
+    end
+
+    private
+
+    def modules_dependency_paths
+      modules.map(&:dependency_paths).flatten
+    end
+
+    def default_dependency_paths
+      @default_dependency_paths ||= [
+        "#{root}/config/database.rb",
+        "#{root}/lib/**/*.rb",
+        "#{root}/models/**/*.rb",
+        "#{root}/shared/**/*.rb",
+        "#{root}/config/apps.rb",
+      ]
+    end
+  end
+end

data/lib/tennpipes-base/logger.rb

@@ -0,0 +1,492 @@
+require 'pathname'
+
+# Defines the log level for a Tennpipes project.
+TENNPIPES_LOG_LEVEL = ENV['TENNPIPES_LOG_LEVEL'] unless defined?(TENNPIPES_LOG_LEVEL)
+
+# Defines the logger used for a Tennpipes project.
+TENNPIPES_LOGGER = ENV['TENNPIPES_LOGGER'] unless defined?(TENNPIPES_LOGGER)
+
+module Tennpipes
+  ##
+  # @return [Tennpipes::Logger]
+  #
+  # @example
+  #   logger.debug "foo"
+  #   logger.warn "bar"
+  #
+  def self.logger
+    Tennpipes::Logger.logger
+  end
+
+  ##
+  # Set the tennpipes logger.
+  #
+  # @param [Object] value
+  #   an object that respond to <<, write, puts, debug, warn etc..
+  #
+  # @return [Object]
+  #   The given value.
+  #
+  # @example using ruby default logger
+  #   require 'logger'
+  #   Tennpipes.logger = Logger.new(STDOUT)
+  #
+  # @example using ActiveSupport
+  #   require 'active_support/buffered_logger'
+  #   Tennpipes.logger = Buffered.new(STDOUT)
+  #
+  def self.logger=(value)
+    Tennpipes::Logger.logger = value
+  end
+
+  ##
+  # Tennpipess internal logger, using all of Tennpipes log extensions.
+  #
+  class Logger
+    ##
+    # Ruby (standard) logger levels:
+    #
+    # :fatal:: An not handleable 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
+    # :devel:: Development-related information that is unnecessary in debug mode
+    #
+    Levels = {
+      :fatal =>  4,
+      :error =>  3,
+      :warn  =>  2,
+      :info  =>  1,
+      :debug =>  0,
+      :devel => -1,
+    } unless defined?(Levels)
+
+    module Extensions
+      ##
+      # Generate the logging methods for {Tennpipes.logger} for each log level.
+      #
+      Tennpipes::Logger::Levels.each_pair do |name, number|
+        define_method(name) do |*args|
+          return if number < level
+          if args.size > 1
+            bench(args[0], args[1], args[2], name)
+          else
+            if location = resolve_source_location(caller(1).shift)
+              args.prepend(location)
+            end if enable_source_location?
+            push(args * '', name)
+          end
+        end
+
+        define_method(:"#{name}?") do
+          number >= level
+        end
+      end
+
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
+
+      ##
+      # Returns true if :source_location is set to true.
+      #
+      def enable_source_location?
+        respond_to?(:source_location?) && source_location?
+      end
+
+      ##
+      # Resolves a filename and line-number from caller.
+      #
+      def resolve_source_location(message)
+        path, line = *message.scan(SOURCE_LOCATION_REGEXP).first
+        return unless path && line
+        root = Tennpipes.root
+        path = File.realpath(path) if Pathname.new(path).relative?
+        if path.start_with?(root) && !path.start_with?(Tennpipes.root("vendor"))
+          "[#{path.gsub("#{root}/", "")}:#{line}] "
+        end
+      end
+
+      ##
+      # Append a to development logger a given action with time.
+      #
+      # @param [string] action
+      #   The action.
+      #
+      # @param [float] time
+      #   Time duration for the given action.
+      #
+      # @param [message] string
+      #   The message that you want to log.
+      #
+      # @example
+      #   logger.bench 'GET', started_at, '/blog/categories'
+      #   # => DEBUG - GET (0.0056s) - /blog/categories
+      #
+      def bench(action, began_at, message, level=:debug, color=:yellow)
+        @_pad  ||= 8
+        @_pad    = action.to_s.size if action.to_s.size > @_pad
+        duration = Time.now - began_at
+        color    = :red if duration > 1
+        action   = colorize(action.to_s.upcase.rjust(@_pad), color)
+        duration = colorize('%0.4fs' % duration, color, :bold)
+        push "#{action} (#{duration}) #{message}", level
+      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.
+      #
+      # @param [String] message
+      #   The message that you want write to your stream.
+      #
+      # @param [String] level
+      #   The level one of :debug, :warn etc. ...
+      #
+      #
+      def push(message = nil, level = nil)
+        add(Tennpipes::Logger::Levels[level], format(message, level))
+      end
+
+      ##
+      # Formats the log message. This method is a noop and should be implemented by other
+      # logger components such as {Tennpipes::Logger}.
+      #
+      # @param [String] message
+      #   The message to format.
+      #
+      # @param [String,Symbol] level
+      #   The log level, one of :debug, :warn ...
+      def format(message, level)
+        message
+      end
+
+      ##
+      # The debug level, with some style added. May be reimplemented.
+      #
+      # @example
+      #   stylized_level(:debug) => DEBUG
+      #
+      # @param [String,Symbol] level
+      #   The log level.
+      #
+      def stylized_level(level)
+        level.to_s.upcase.rjust(7)
+      end
+
+      ##
+      # Colorizes a string for colored console output. This is a noop and can be reimplemented
+      # to colorize the string as needed.
+      #
+      # @see
+      #   ColorizedLogger
+      #
+      # @param [string]
+      #   The string to be colorized.
+      #
+      # @param [Array<Symbol>]
+      #   The colors to use. Should be applied in the order given.
+      def colorize(string, *colors)
+        string
+      end
+
+      ##
+      # Turns a logger with LoggingExtensions into a logger with colorized output.
+      #
+      # @example
+      #   Tennpipes.logger = Logger.new($stdout)
+      #   Tennpipes.logger.colorize!
+      #   Tennpipes.logger.debug("Fancy Tennpipes debug string")
+      def colorize!
+        self.extend(Colorize)
+      end
+
+      ##
+      # Logs an exception.
+      #
+      # @param [Exception] exception
+      #   The exception to log
+      #
+      # @param [Symbol] verbosity
+      #   :short or :long, default is :long
+      #
+      # @example
+      #   Tennpipes.logger.exception e
+      #   Tennpipes.logger.exception(e, :short)
+      def exception(boom, verbosity = :long, level = :error)
+        return unless Levels.has_key?(level)
+        text = ["#{boom.class} - #{boom.message}:"]
+        trace = boom.backtrace
+        case verbosity
+        when :long
+          text += trace
+        when :short
+          text << trace.first
+        end if trace.kind_of?(Array)
+        send level, text.join("\n ")
+      end
+    end
+
+    module Colorize
+      # Colors for levels
+      ColoredLevels = {
+        :fatal => [:bold, :red],
+        :error => [:default, :red],
+        :warn  => [:default, :yellow],
+        :info  => [:default, :green],
+        :debug => [:default, :cyan],
+        :devel => [:default, :magenta]
+      } unless defined?(ColoredLevels)
+
+      ##
+      # Colorize our level.
+      #
+      # @param [String, Symbol] level
+      #
+      # @see Tennpipes::Logging::ColorizedLogger::ColoredLevels
+      #
+      def colorize(string, *colors)
+        string.colorize(:color => colors[0], :mode => colors[1])
+      end
+
+      def stylized_level(level)
+        style = "\e[%d;%dm" % ColoredLevels[level].map{|color| String::Colorizer.modes[color] || String::Colorizer.colors[color] }
+        [style, super, "\e[0m"] * ''
+      end
+    end
+
+    include Extensions
+
+    attr_accessor :auto_flush, :level, :log_static
+    attr_reader   :buffer, :colorize_logging, :init_args, :log
+
+    ##
+    # Configuration for a given environment, possible options are:
+    #
+    # :log_level:: Once of [:fatal, :error, :warn, :info, :debug]
+    # :stream:: Once of [:to_file, :null, :stdout, :stderr] our your custom stream
+    # :log_level::
+    #   The log level from, e.g. :fatal or :info. Defaults to :warn in the
+    #   production environment and :debug otherwise.
+    # :auto_flush::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to true.
+    # :format_datetime:: Format of datetime. Defaults to: "%d/%b/%Y %H:%M:%S"
+    # :format_message:: Format of message. Defaults to: ""%s - - [%s] \"%s\"""
+    # :log_static:: Whether or not to show log messages for static files. Defaults to: false
+    # :colorize_logging:: Whether or not to colorize log messages. Defaults to: true
+    #
+    # @example
+    #   Tennpipes::Logger::Config[:development] = { :log_level => :debug, :stream => :to_file }
+    #   # or you can edit our defaults
+    #   Tennpipes::Logger::Config[:development][:log_level] = :error
+    #   # or you can use your stream
+    #   Tennpipes::Logger::Config[:development][:stream] = StringIO.new
+    #
+    # Defaults are:
+    #
+    #   :production  => { :log_level => :warn, :stream => :to_file }
+    #   :development => { :log_level => :debug, :stream => :stdout }
+    #   :test        => { :log_level => :fatal, :stream => :null }
+    #
+    # In some cases, configuring the loggers before loading the framework is necessary.
+    # You can do so by setting TENNPIPES_LOGGER:
+    #
+    #   TENNPIPES_LOGGER = { :staging => { :log_level => :debug, :stream => :to_file }}
+    #
+    Config = {
+      :production  => { :log_level => :warn,  :stream => :to_file },
+      :development => { :log_level => :debug, :stream => :stdout, :format_datetime => '' },
+      :test        => { :log_level => :debug, :stream => :null }
+    }
+    Config.merge!(TENNPIPES_LOGGER) if TENNPIPES_LOGGER
+
+    @@mutex = Mutex.new
+    def self.logger
+      @_logger || setup!
+    end
+
+    def self.logger=(logger)
+      logger.extend(Tennpipes::Logger::Extensions)
+
+      @_logger = logger
+    end
+
+    ##
+    # Setup a new logger.
+    #
+    # @return [Tennpipes::Logger]
+    #   A {Tennpipes::Logger} instance
+    #
+    def self.setup!
+      self.logger = begin
+        config_level = (TENNPIPES_LOG_LEVEL || Tennpipes.env || :test).to_sym # need this for TENNPIPES_LOG_LEVEL
+        config = Config[config_level]
+
+        unless config
+          warn("No logging configuration for :#{config_level} found, falling back to :production")
+          config = Config[:production]
+        end
+
+        stream = case config[:stream]
+          when :to_file
+            FileUtils.mkdir_p(Tennpipes.root('log')) unless File.exist?(Tennpipes.root('log'))
+            File.new(Tennpipes.root('log', "#{Tennpipes.env}.log"), 'a+')
+          when :null   then StringIO.new
+          when :stdout then $stdout
+          when :stderr then $stderr
+          else config[:stream] # return itself, probabilly is a custom stream.
+        end
+
+        Tennpipes::Logger.new(config.merge(:stream => stream))
+      end
+    end
+
+    ##
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # @param [Hash] options
+    #
+    # @option options [Symbol] :stream ($stdout)
+    #   Either an IO object or a name of a logfile. Defaults to $stdout
+    #
+    # @option options [Symbol] :log_level (:production in the production environment and :debug otherwise)
+    #   The log level from, e.g. :fatal or :info.
+    #
+    # @option options [Symbol] :auto_flush (true)
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to true.
+    #
+    # @option options [Symbol] :format_datetime (" [%d/%b/%Y %H:%M:%S] ")
+    #   Format of datetime.
+    #
+    # @option options [Symbol] :format_message ("%s -%s%s")
+    #    Format of message.
+    #
+    # @option options [Symbol] :log_static (false)
+    #   Whether or not to show log messages for static files.
+    #
+    # @option options [Symbol] :colorize_logging (true)
+    #   Whether or not to colorize log messages. Defaults to: true.
+    #
+    def initialize(options={})
+      @buffer           = []
+      @auto_flush       = options.has_key?(:auto_flush) ? options[:auto_flush] : true
+      @level            = options[:log_level] ? Tennpipes::Logger::Levels[options[:log_level]] : Tennpipes::Logger::Levels[:debug]
+      @log              = options[:stream]  || $stdout
+      @log.sync         = true
+      @format_datetime  = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
+      @format_message   = options[:format_message]  || "%s - %s %s"
+      @log_static       = options.has_key?(:log_static) ? options[:log_static] : false
+      @colorize_logging = options.has_key?(:colorize_logging) ? options[:colorize_logging] : true
+      @source_location  = options[:source_location]
+      colorize! if @colorize_logging
+    end
+
+    def source_location?
+      !!@source_location
+    end
+
+    ##
+    # Flush the entire buffer to the log object.
+    #
+    def flush
+      return unless @buffer.size > 0
+      @@mutex.synchronize do
+        @log.write(@buffer.join(''))
+        @buffer.clear
+      end
+    end
+
+    ##
+    # Close and remove the current log object.
+    #
+    # @return [NilClass]
+    #
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    ##
+    # Adds a message to the log - for compatibility with other loggers.
+    #
+    def add(level, message = nil)
+      write(message)
+    end
+
+    ##
+    # Directly append message to the log.
+    #
+    # @param [String] message
+    #   The message
+    #
+    def <<(message = nil)
+      message << "\n" unless message[-1] == ?\n
+      @@mutex.synchronize {
+        @buffer << message
+      }
+      flush if @auto_flush
+      message
+    end
+    alias :write :<<
+
+    def format(message, level)
+      @format_message % [stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
+    end
+
+    ##
+    # Tennpipes::Logger::Rack forwards every request to an +app+ given, and
+    # logs a line in the Apache common log format to the +logger+, or
+    # rack.errors by default.
+    #
+    class Rack
+      def initialize(app, uri_root)
+        @app = app
+        @uri_root = uri_root.sub(/\/$/,"")
+      end
+
+      def call(env)
+        env['rack.logger'] = Tennpipes.logger
+        began_at = Time.now
+        status, header, body = @app.call(env)
+        log(env, status, header, began_at) if logger.debug?
+        [status, header, body]
+      end
+
+      private
+
+      def log(env, status, header, began_at)
+        return if env['sinatra.static_file'] && (!logger.respond_to?(:log_static) || !logger.log_static)
+        logger.bench(
+          env["REQUEST_METHOD"],
+          began_at,
+          [
+            @uri_root.to_s,
+            env["PATH_INFO"],
+            env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
+            ' - ',
+            logger.colorize(status.to_s[0..3], :default, :bold),
+            ' ',
+            code_to_name(status)
+          ] * '',
+          :debug,
+          :magenta
+        )
+      end
+
+      def code_to_name(status)
+        ::Rack::Utils::HTTP_STATUS_CODES[status.to_i] || ''
+      end
+    end
+  end
+end
+
+module Kernel
+  ##
+  # Define a logger available every where in our app
+  #
+  def logger
+    Tennpipes.logger
+  end
+end