rjspotter-ramaze 2009.06.29

data/lib/ramaze/reloader/watch_inotify.rb

@@ -0,0 +1,85 @@
+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
+  end
+end

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
+  end
+end

data/lib/ramaze/request.rb

@@ -0,0 +1,115 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  # The purpose of this class is to act as a simple wrapper for Rack::Request
+  # and provide some convinient 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'}
+    #   to_ivs(:name, :q)
+    #   @q    # => 'google'
+    #   @name # => 'manveru'
+    #   @lang # => nil
+
+    def to_instance_variables(*args)
+      instance = Action.current.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 enviroment
+    # variables.
+    def pretty_print(pp)
+      pp.object_group(self){
+        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

data/lib/ramaze/response.rb

@@ -0,0 +1,36 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Response < Rack::Response
+    # Alias for Current.response
+    def self.current; Current.response; end
+
+    def initialize(body = [], status = 200, header = {}, &block)
+      modified_header = Ramaze.options.header.merge(header)
+      header.merge!(modified_header)
+      super
+    end
+
+    # Build/replace this responses data
+    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
+
+    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
+end

data/lib/ramaze/setup.rb

@@ -0,0 +1,123 @@
+module Ramaze
+  # Convenient setup and activation of gems from different sources and specific
+  # versions.
+  # It's almost like Kernel#gem but also installs automatically if a gem is
+  # missing.
+  #
+  # @example
+  #
+  #   Ramaze.setup :verbose => true do
+  #     # gem and specific version
+  #     gem 'makura', '>=2009.01'
+  #
+  #     # gem and name for require
+  #     gem 'aws-s3', :lib => 'aws/s3'
+  #
+  #     # gem with specific version from rubyforge (default)
+  #     gem 'json', :version => '=1.1.3', :source => rubyforge
+  #
+  #     # gem from github
+  #     gem 'manveru-org', :lib => 'org', :source => github
+  #   end
+  #
+  # @option options [boolean] (true) verbose
+  # @option options [String] (nil) extconf
+  # @yield block
+  # @see GemSetup#initialize
+  # @author manveru
+  def self.setup(options = {:verbose => true}, &block)
+    GemSetup.new(options, &block)
+  end
+
+  class GemSetup
+    def initialize(options = {}, &block)
+      @gems = []
+      @options = options.dup
+      @verbose = @options.delete(:verbose)
+
+      run(&block)
+    end
+
+    def run(&block)
+      return unless block_given?
+      instance_eval(&block)
+      setup
+    end
+
+    def gem(name, version = nil, options = {})
+      if version.respond_to?(:merge!)
+        options = version
+      else
+        options[:version] = version
+      end
+
+      @gems << [name, options]
+    end
+
+    # all gems defined, let's try to load/install them
+    def setup
+      require 'rubygems'
+      require 'rubygems/dependency_installer'
+
+      @gems.each do |name, options|
+        setup_gem(name, options)
+      end
+    end
+
+    # first try to activate, install and try to activate again if activation
+    # fails the first time
+    def setup_gem(name, options)
+      version = [options[:version]].compact
+      lib_name = options[:lib] || name
+
+      log "activating #{name}"
+
+      Gem.activate(name, *version)
+      require(lib_name)
+
+    rescue LoadError
+
+      install_gem(name, options)
+      Gem.activate(name, *version)
+      require(lib_name)
+    end
+
+    # tell rubygems to install a gem
+    def install_gem(name, options)
+      installer = Gem::DependencyInstaller.new(options)
+
+      temp_argv(options[:extconf]) do
+        log "Installing #{name}"
+        installer.install(name, options[:version])
+      end
+    end
+
+    # prepare ARGV for rubygems installer
+    def temp_argv(extconf)
+      if extconf ||= @options[:extconf]
+        old_argv = ARGV.clone
+        ARGV.replace(extconf.split(' '))
+      end
+
+      yield
+
+    ensure
+      ARGV.replace(old_argv) if extconf
+    end
+
+    private
+
+    def log(msg)
+      return unless @verbose
+
+      if defined?(Log)
+        Log.info(msg)
+      else
+        puts(msg)
+      end
+    end
+
+    def rubyforge; 'http://gems.rubyforge.org/' end
+    def github; 'http://gems.github.com/' end
+  end
+end

data/lib/ramaze/snippets.rb

@@ -0,0 +1,22 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+dir  = File.join(File.expand_path(File.dirname(__FILE__)), 'snippets')
+glob = File.join(dir, '**', '*.rb')
+
+Dir[glob].each do |snippet|
+  require(snippet)
+end
+
+Ramaze::CoreExtensions.constants.each do |const|
+  ext = Ramaze::CoreExtensions.const_get(const)
+  into = Module.const_get(const)
+
+  collisions = ext.instance_methods & into.instance_methods
+
+  if collisions.empty?
+    into.__send__(:include, ext)
+  else
+    warn "Won't include %p with %p, %p exists" % [into, ext, collisions]
+  end
+end

data/lib/ramaze/snippets/array/put_within.rb

@@ -0,0 +1,44 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Array
+
+    module Array
+
+      #   a = [1, 2, 3]
+      #   a.put_within(4, :after => 2, :before => 3)
+      #   a # => [1, 2, 4, 3]
+
+      def put_within(object, constrain)
+        pre, post = constrain.values_at(:after, :before)
+
+        return put_after(pre, object) if rindex(post) - index(pre) == 1
+
+        raise ArgumentError, "Too many elements within constrain"
+      end
+
+      #   a = [1, 2, 3]
+      #   a.put_after(2, 4)
+      #   a # => [1, 2, 4, 3]
+
+      def put_after(element, object)
+        return self[index(element) + 1, 0] = object if include?(element)
+
+        raise ArgumentError, "The given element doesn't exist"
+      end
+
+      #   a = [1, 2, 3]
+      #   a.put_before(2, 4)
+      #   a # => [1, 4, 2, 3]
+
+      def put_before(element, object)
+        return self[rindex(element), 0] = object if include?(element)
+
+        raise ArgumentError, "The given element doesn't exist"
+      end
+    end
+  end
+end