ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/log/syslog.rb

@@ -1,36 +1,62 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
+# All files in this distribution are subject to the terms of the MIT license.
 
 require 'syslog'
 
 module Ramaze
-
-  # Informer for Syslog from rubys standard-library.
-
-  class Syslog
-    include ::Syslog
-
-    # opens syslog
-
-    def initialize
-      open unless ::Syslog.opened?
-    end
-
-    # alias for default syslog methods so they match ramaze
-    alias error err
-    alias warn warning
-    alias dev debug
-
-    # just sends all messages received to ::Syslog
-    def inform(tag, *args)
-      self.__send__(tag, *args)
-    end
-
-    public :error, :warn
-
-    # Has to call the modules singleton-method.
-    def inspect
-      ::Syslog.inspect
-    end
-  end
-end
+  module Logger
+    ##
+    # Logger class for writing to syslog. It is a *very* thin wrapper
+    # around the Syslog library.
+    #
+    class Syslog
+      include Logging
+
+      # Hash containing various method aliases. Rbx and Jruby don't seem to like
+      # the combination of alias() and module_function() so this works around
+      # that.
+      ALIASES = {:dev => :debug, :warn => :warning, :error => :err}
+
+      ##
+      # Open the syslog library, if it is already open, we reopen it using the
+      # new argument list. The argument list is passed on to the Syslog library
+      # so please check that, and man syslog for detailed information.
+      #
+      # There are 3 parameters:
+      #
+      # * ident:  The identification used in the log file, defaults to $0
+      # * options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
+      # * facility: defaults to Syslog::LOG_USER
+      #
+      def initialize(*args)
+        ::Syslog.close if ::Syslog.opened?
+        ::Syslog.open(*args)
+      end
+
+      ##
+      # Just sends all messages received to ::Syslog
+      # We simply return if the log was closed for some reason, this behavior
+      # was copied from Informer.  We do not handle levels here. This will
+      # be done by the syslog daemon based on it's configuration.
+      def log(tag, *messages)
+        return if !::Syslog.opened?
+        tag = tag.to_sym
+
+        if ALIASES.key?(tag)
+          tag = ALIASES[tag]
+        end
+
+        messages = messages.map {|m| m.gsub(/(%[^m])/,'%\1')}
+        ::Syslog.send(tag, *messages)
+      end
+
+      ##
+      # Has to call the modules singleton-method.
+      #
+      def inspect
+        ::Syslog.inspect
+      end
+    end # Syslog
+  end # Logger
+end # Ramaze

data/lib/ramaze/log.rb

@@ -1,28 +1,29 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 require 'ramaze/log/logging'
-require 'ramaze/log/hub'
 require 'ramaze/log/informer'
 
 begin
-  require 'win32console' if RUBY_PLATFORM =~ /win32/i
+  require 'win32console' if RUBY_PLATFORM =~ /win32/i && RUBY_VERSION < '1.9'
 rescue LoadError => ex
   puts ex
   puts "For nice colors on windows, please `gem install win32console`"
-  Ramaze::Informer.trait[:colorize] = false
+  Ramaze::Logger::Informer.trait[:colorize] = false
 end
 
 module Ramaze
-  autoload :Analogger, "ramaze/log/analogger.rb"
-  autoload :Knotify,   "ramaze/log/knotify.rb"
-  autoload :Syslog,    "ramaze/log/syslog.rb"
-  autoload :Growl,     "ramaze/log/growl.rb"
-  autoload :Xosd,      "ramaze/log/xosd.rb"
-  autoload :Logger,    "ramaze/log/logger.rb"
-  autoload :Inform,    "ramaze/inform"
+  Log = Innate::Log
 
-  unless defined?(Log)
-    Log = LogHub.new(Informer)
+  ##
+  # Module used as the base namespace for all loggers that ship with Ramaze.
+  #
+  # @author Michael Fellinger
+  # @since  11-08-2009
+  #
+  module Logger
+    autoload :LogHub          , 'ramaze/log/hub'
+    autoload :RotatingInformer, 'ramaze/log/rotatinginformer'
+    autoload :Syslog          , 'ramaze/log/syslog'
+    autoload :Logger          , 'ramaze/log/logger'
   end
 end

data/lib/ramaze/reloader/watch_inotify.rb

@@ -0,0 +1,84 @@
+module Ramaze
+  class Reloader
+    ##
+    # TODO:
+    #   * There seems to be a problem somewhere that I couldn't identify yet, a
+    #     file has to be modified twice initially to make it show up as
+    #     modified here, subsequent changes work just fine.
+    #     The only workaround I could find right now would be to read/write
+    #     every single file, but that would be unexpected, irresponsible, and
+    #     error-prone.
+    #
+    # NOTE:
+    #   * I have changed from using a Mutex to using a Queue, which uses a
+    #     Mutex internally.
+    class WatchInotify
+      POLL_INTERVAL = 2 # seconds
+      NOTIFY_MASK = RInotify::MODIFY | RInotify::IN_ONESHOT
+
+      def initialize
+        @watcher = RInotify.new
+        @changed = Queue.new
+        @watcher_thread = start_watcher
+      end
+
+      def call(cooldown)
+        yield
+      end
+
+      # TODO: define a finalizer to cleanup? -- reloader never calls #close
+
+      def start_watcher
+        Thread.new{ loop{ watcher_cycle }}
+      end
+
+      # Not much work here, we just have to empty the event queue and push the
+      # descriptors for reloading on next request.
+      def watcher_cycle
+        return unless @watcher.wait_for_events(POLL_INTERVAL)
+
+        @watcher.each_event do |event|
+          @changed.push(event.watch_descriptor)
+        end
+      end
+
+      def watch(file)
+        return if @watcher.watch_descriptors.has_value?(file)
+        return unless File.exist?(file)
+
+        @watcher.add_watch(file, NOTIFY_MASK)
+      rescue Errno::ENOENT
+        retry
+      end
+
+      # FIXME:
+      #   Seems like this won't work due to some bug in the rinotify library.
+      #   Would be cool if someone could make a FFI version.
+      def remove_watch(file)
+        @watcher.rm_watch(file)
+      end
+
+      def close
+        @watcher_thread.terminate
+        @watcher.close
+        true
+      end
+
+      # NOTE:
+      #   We have to add the changed file again after we got a notification, I
+      #   have no idea why, but using IN_ONESHOT should make sure that there is
+      #   no memory leak in the C level even if we add a file again.
+      #   There is a memory leak however in the watch_descriptors hash, since
+      #   rinotify won't synchronize the contents properly and will only add to
+      #   the hash, so we have to clean up ourselves.
+      def changed_files
+        until @changed.empty?
+          descriptor = @changed.shift
+          file = @watcher.watch_descriptors.delete(descriptor)
+          watch(file)
+          yield(file)
+        end
+      end
+    end # WatchInotify
+  end # Reloader
+end # Ramaze

data/lib/ramaze/reloader/watch_stat.rb

@@ -0,0 +1,58 @@
+module Ramaze
+  class Reloader
+    class WatchStat
+      def initialize
+        # @files[file_path] = stat
+        @files = {}
+        @last = Time.now
+      end
+
+      def call(cooldown)
+        if cooldown and Time.now > @last + cooldown
+          yield
+          @last = Time.now
+        end
+      end
+
+      # start watching a file for changes
+      # true if succeeded, false if failure
+      def watch(file)
+        return true if watching?(file) # if already watching
+        if stat = safe_stat(file)
+          @files[file] = stat
+        end
+      end
+
+      def watching?(file)
+        @files.has_key?(file)
+      end
+
+      # stop watching a file for changes
+      def remove_watch(file)
+        @files.delete(file)
+      end
+
+      # no need for cleanup
+      def close
+      end
+
+      # return files changed since last call
+      def changed_files
+        @files.each do |file, stat|
+          if new_stat = safe_stat(file)
+            if new_stat.mtime > stat.mtime
+              @files[file] = new_stat
+              yield(file)
+            end
+          end
+        end
+      end
+
+      def safe_stat(file)
+        File.stat(file)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end # WatchStat
+  end # Reloader
+end # Ramaze

data/lib/ramaze/reloader.rb

@@ -0,0 +1,212 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+module Ramaze
+  ##
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # It does not depend on Ramaze itself, but you might have to adjust the
+  # Reloader::Hooks module or include your own module to override the hooks.
+  # You also might have to set the Log constant.
+  #
+  # Currently, it uses RInotify if available and falls back to using File.stat.
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called
+  # In case of Ramaze it is performing a check/reload cycle at the start of
+  # every request, but also respects a cool down time, during which nothing will
+  # be done.
+  #
+  # After every reload the OPTIONS hash will be checked for changed options and
+  # assigned to the instance, so you may change options during the lifetime of
+  # your application.
+  #
+  # A number of hooks will be executed during the reload cycle, see
+  # Ramaze::ReloaderHooks for more information.
+  #
+  class Reloader
+    OPTIONS = {
+      # At most check every n seconds
+      # nil/false will never trigger the reload cycle
+      # 0 will cycle on every call
+      :cooldown => 2,
+
+      # Compiled files cannot be reloaded during runtime
+      :ignore => /\.so$/,
+
+      # Run cycle in a Thread.exclusive, by default no threads are used.
+      :thread => false,
+
+      # If you assign a block here it will be instance_evaled instead of
+      # calling cycle. This allows you to use for example EventMachine for
+      # well performing asynchronous cycling.
+      :control => nil, # lambda{ cycle },
+    }
+
+    begin
+      begin
+        gem('RInotify', '>=0.9') # is older version ok?
+      rescue NoMethodError # Kernel::gem might simply be not available
+      end
+
+      require 'rinotify'
+      require 'ramaze/reloader/watch_inotify'
+      Watcher = WatchInotify
+    rescue LoadError
+      # stat always available
+      require 'ramaze/reloader/watch_stat'
+      Watcher = WatchStat
+    end
+
+    ##
+    # Creates a new instance of the class and saves the application it has to
+    # watch.
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    # @param  [Ramaze::App] app The application to monitor.
+    #
+    def initialize(app)
+      @app = app
+      @files = {}
+      @watcher = Watcher.new
+      options_reload
+    end
+
+    ##
+    # Returns all the options for this class.
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    # @return [Array]
+    #
+    def options_reload
+      @cooldown, @ignore, @control, @thread =
+        OPTIONS.values_at(:cooldown, :ignore, :control, :thread)
+    end
+
+    ##
+    # Allows this class to be called as a Rack middleware.
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    # @param  [Hash] env A hash containing all environment details.
+    #
+    def call(env)
+      options_reload
+
+      @watcher.call(@cooldown) do
+        if @control
+          instance_eval(&@control)
+        elsif @thread
+          Thread.exclusive{ cycle }
+        else
+          cycle
+        end
+      end
+
+      @app.call(env)
+    end
+
+    ##
+    # Loops through all the files and reloads all changes files.
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    #
+    def cycle
+      before_cycle
+
+      rotation{|file| @watcher.watch(file) }
+      @watcher.changed_files{|f| safe_load(f) }
+
+      after_cycle
+    end
+
+    ##
+    # A safe Kernel::load, issuing the hooks depending on the results
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    # @param  [String] file Path to the file to safely load.
+    #
+    def safe_load(file)
+      before_safe_load(file)
+      load(file)
+      after_safe_load_succeed(file)
+    rescue Object => ex
+      Log.error(ex)
+      after_safe_load_failed(file, ex)
+    end
+
+    def rotation
+      files = [$0, __FILE__, *$LOADED_FEATURES].uniq
+      paths = ['./', *$LOAD_PATH].uniq
+
+      files.each do |file|
+        next if file =~ @ignore
+        if not @files.has_key?(file) and path = figure_path(file, paths)
+          @files[file] = path
+          yield path
+        end
+      end
+    end
+
+    ##
+    # Tries to find a given file in an array of file paths.
+    #
+    # @author Michael Fellinger
+    # @since  09-08-2008
+    # @param  [String] file The name of the file to look for.
+    # @param  [Array] paths An array of paths to search.
+    # @return [String]
+    #
+    def figure_path(file, paths)
+      if Pathname.new(file).absolute?
+        return File.exist?(file) ? file : nil
+      end
+
+      paths.each do |possible_path|
+        full_path = File.join(possible_path, file)
+        return full_path if File.exist?(full_path)
+      end
+      nil
+    end
+
+    # Holds hooks that are called before and after #cycle and #safe_load
+    module Hooks
+      # Overwrite to add actions before the reload rotation is started.
+      def before_cycle; end
+
+      # Overwrite to add actions after the reload rotation has ended.
+      def after_cycle; end
+
+      # Overwrite to add actions before a file is Kernel::load-ed
+      def before_safe_load(file)
+        Log.debug("reload #{file}")
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed successfully,
+      # by default we clean the Cache for compiled templates and resolved
+      # actions.
+      def after_safe_load_succeed(file)
+        Cache.clear_after_reload
+        after_safe_load(file)
+      end
+
+      # Overwrite to add custom hook in addition to default Cache cleaning
+      def after_safe_load(file)
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed unsuccessfully,
+      # by default we output an error-message with the exception.
+      def after_safe_load_failed(file, error)
+        Log.error(error)
+      end
+    end # Hooks
+
+    include Hooks
+  end # Reloader
+end # Ramaze

data/lib/ramaze/request.rb

@@ -0,0 +1,126 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+module Ramaze
+  ##
+  # The purpose of this class is to act as a simple wrapper for Rack::Request
+  # and provide some convenient methods for our own use.
+  class Request < Innate::Request
+    ##
+    # you can access the original @request via this method_missing,
+    # first it tries to match your method with any of the HTTP parameters
+    # then, in case that fails, it will relay to @request
+    def method_missing meth, *args
+      key = meth.to_s.upcase
+      return env[key] if env.has_key?(key)
+      super
+    end
+
+    ##
+    # Sets any arguments passed as @instance_variables for the current action.
+    #
+    # Usage:
+    #
+    #     request.params # => {'name' => 'manveru', 'q' => 'google', 'lang' => 'de'}
+    #     request.to_ivs(:name, :q)
+    #
+    #     @q    # => 'google'
+    #     @name # => 'manveru'
+    #     @lang # => nil
+    #
+    def to_instance_variables(*args)
+      instance = Current.action.instance
+      args.each do |arg|
+        next unless value = self[arg]
+        instance.instance_variable_set("@#{arg}", value)
+      end
+    end
+    alias to_ivs to_instance_variables
+
+    def accept_charset(default = 'UTF-8')
+      return default unless charsets = env['HTTP_ACCEPT_CHARSET']
+      charset = charsets.split(',', 2).first
+      charset == '*' ? default : charset
+    end
+
+    ##
+    # Try to find out which languages the client would like to have and sort
+    # them by weight, (most wanted first).
+    #
+    # Returns and array of locales from env['HTTP_ACCEPT_LANGUAGE].
+    # e.g. ["fi", "en", "ja", "fr", "de", "es", "it", "nl", "sv"]
+    #
+    # Usage:
+    #
+    #     request.accept_language # => ['en-us', 'en', 'de-at', 'de']
+    #
+    # @param [String #to_s] string the value of HTTP_ACCEPT_LANGUAGE
+    # @return [Array] list of locales
+    # @see Request#accept_language_with_weight
+    # @author manveru
+    #
+    def accept_language(string = env['HTTP_ACCEPT_LANGUAGE'])
+      return [] unless string
+
+      accept_language_with_weight(string).map{|lang, weight| lang }
+    end
+    alias locales accept_language
+
+    ##
+    # Transform the HTTP_ACCEPT_LANGUAGE header into an Array with:
+    #
+    #     [[lang, weight], [lang, weight], ...]
+    #
+    # This algorithm was taken and improved from the locales library.
+    #
+    # Usage:
+    #
+    #     request.accept_language_with_weight
+    #     # => [["en-us", 1.0], ["en", 0.8], ["de-at", 0.5], ["de", 0.3]]
+    #
+    # @param [String #to_s] string the value of HTTP_ACCEPT_LANGUAGE
+    # @return [Array] array of [lang, weight] arrays
+    # @see Request#accept_language
+    # @author manveru
+    #
+    def accept_language_with_weight(string = env['HTTP_ACCEPT_LANGUAGE'])
+      string.to_s.gsub(/\s+/, '').split(',').
+            map{|chunk|        chunk.split(';q=', 2) }.
+            map{|lang, weight| [lang, weight ? weight.to_f : 1.0] }.
+        sort_by{|lang, weight| -weight }
+    end
+
+    INTERESTING_HTTP_VARIABLES =
+      (/USER|HOST|REQUEST|REMOTE|FORWARD|REFER|PATH|QUERY|VERSION|KEEP|CACHE/)
+
+    # Interesting HTTP variables from env
+    def http_variables
+      env.reject{|key, value| key.to_s !~ INTERESTING_HTTP_VARIABLES }
+    end
+    alias http_vars http_variables
+
+    REQUEST_STRING_FORMAT = "#<%s params=%p cookies=%p env=%p>"
+
+    def to_s
+      REQUEST_STRING_FORMAT % [self.class, params, cookies, http_variables]
+    end
+    alias inspect to_s
+
+    # Pretty prints current action with parameters, cookies and environment
+    # variables.
+    def pretty_print(pp)
+      pp.object_group(self) do
+        group = {
+          'params'  => params,
+          'cookies' => cookies,
+          'env'     => http_variables
+        }
+
+        group.each do |name, hash|
+          pp.breakable
+          pp.text " @#{name}="
+          pp.nest(name.size + 3){ pp.pp_hash(hash) }
+        end
+      end
+    end
+  end # Request
+end # Ramaze

data/lib/ramaze/response.rb

@@ -0,0 +1,67 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+module Ramaze
+  ##
+  # Ramaze::Response is a small wrapper around Rack::Response that makes it
+  # easier to send response data to the browser from a Ramaze application.
+  #
+  # @author Michael Fellinger
+  # @since  01-03-2008
+  #
+  class Response < Rack::Response
+    # Alias for Current.response
+    def self.current; Current.response; end
+
+    ##
+    # Creates a new instance of the response class and processes the specified
+    # parameters. Once this has been done it calls Rack::Response#initialize.
+    #
+    # @author Michael Fellinger
+    # @since  01-03-2008
+    # @param  [Array] body An array containing the data for the response body.
+    # @param  [Fixnum] status The HTPP status code for the response.
+    # @param  [Hash] header A hash containing additional headers and their
+    #  values.
+    # @param  [Proc] block
+    #
+    def initialize(body = [], status = 200, header = {}, &block)
+      modified_header = Ramaze.options.header.merge(header)
+      header.merge!(modified_header)
+      super
+    end
+
+    ##
+    # Updates the body, status and headers.
+    #
+    # @author Michael Fellinger
+    # @since  01-03-2008
+    # @see    Ramaze::Response#initialize
+    #
+    def build(new_body = nil, new_status = nil, new_header = nil)
+      self.header.merge!(new_header) if new_header
+
+      self.body   = new_body   if new_body
+      self.status = new_status if new_status
+    end
+
+    ##
+    # Sets the body of the response to the given object.
+    #
+    # @author Michael Fellinger
+    # @since  01-03-2008
+    # @param  [Object] obj The object to use as the response body.
+    #
+    def body=(obj)
+      if obj.respond_to?(:stat)
+        @length = obj.stat.size
+        @body   = obj
+      elsif obj.respond_to?(:size)
+        @body   = []
+        @length = 0
+        write(obj)
+      else
+        raise(ArgumentError, "Invalid body: %p" % obj)
+      end
+    end
+  end # Response
+end # Ramaze