Pistos-ramaze 2009.02 → 2009.04.08

data/lib/ramaze/middleware_compiler.rb

@@ -0,0 +1,13 @@
+module Ramaze
+  class MiddlewareCompiler < Innate::MiddlewareCompiler
+    def static(path)
+      require 'rack/contrib'
+      Rack::ETag.new(Rack::ConditionalGet.new(Rack::File.new(path)))
+    end
+
+    def directory(path)
+      require 'rack/contrib'
+      Rack::ETag.new(Rack::ConditionalGet.new(Rack::Directory.new(path)))
+    end
+  end
+end

data/lib/ramaze/plugin.rb

@@ -0,0 +1,69 @@
+#          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
+  def self.plugin(name, options = {})
+    Plugin.load(name, options)
+  end
+
+  module Plugin
+    PLUGIN_LIST = Set.new
+    EXTS = %w[rb so bundle]
+    PATH = []
+    POOL = []
+
+    module_function
+
+    Ramaze.options.setup << self
+
+    def setup
+      PLUGIN_LIST.each do |name, const, options|
+        const.setup(options) if const.respond_to?(:setup)
+      end
+    end
+
+    def teardown
+      PLUGIN_LIST.each do |name, const, options|
+        const.teardown if const.respond_to?(:teardown)
+      end
+    end
+
+    def add_pool(pool)
+      POOL.unshift(pool)
+      POOL.uniq!
+    end
+
+    add_pool(self)
+
+    def add_path(path)
+      PATH.unshift(File.expand_path(path))
+      PATH.uniq!
+    end
+
+    add_path(__DIR__)
+    add_path('')
+
+    def load(name, options)
+      name = name.to_s
+      try_require(name.snake_case)
+      PLUGIN_LIST << [name, const_get(name.camel_case), options]
+    rescue Exception => exception
+      Log.error(exception)
+      raise LoadError, "Plugin #{name} not found"
+    end
+
+    def try_require(name)
+      found = Dir[glob(name)].first
+      require(File.expand_path(found)) if found
+    rescue LoadError
+    end
+
+    def glob(name = '*')
+      "{#{paths.join(',')}}/plugin/#{name}.{#{EXTS.join(',')}}"
+    end
+
+    def paths
+      PATH
+    end
+  end
+end

data/lib/ramaze/reloader.rb

@@ -46,7 +46,11 @@ module Ramaze
     }
 
     begin
-      gem 'RInotify', '>=0.9' # is older version ok?
+      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
@@ -56,7 +60,7 @@ module Ramaze
       Watcher = WatchStat
     end
 
-    def initialize(app = nil)
+    def initialize(app)
       @app = app
       @files = {}
       @watcher = Watcher.new
@@ -81,7 +85,7 @@ module Ramaze
         end
       end
 
-      @app.call(env) if @app
+      @app.call(env)
     end
 
     def cycle
@@ -147,9 +151,7 @@ module Ramaze
       # 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)
-        Ramaze::Cache.compiled.clear
-        Ramaze::Cache.resolved.clear
-        Ramaze::Cache.action_methods.clear
+        Cache.clear_after_reload
         after_safe_load(file)
       end
 

data/lib/ramaze/request.rb

@@ -0,0 +1,117 @@
+#          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
+  # 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
+    # Currently active request out of STATE[:request]
+    def self.current; Current.request; end
+
+    # 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_ivs(*args)
+      instance = Action.current.instance
+      args.each do |arg|
+        next unless value = self[arg]
+        instance.instance_variable_set("@#{arg}", value)
+      end
+    end
+
+    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/{current/response.rb → response.rb}

@@ -1,24 +1,23 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          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
-    class << self
-      # Alias for Current::response
-      def current() Current.response end
-    end
+    # Alias for Current.response
+    def self.current; Current.response; end
 
     def initialize(body = [], status = 200, header = {}, &block)
-      header['Content-Type'] ||= Global.content_type
-      header['Accept-Charset'] = Global.accept_charset if Global.accept_charset
+      modified_header = Ramaze.options.header.merge(header)
+      header.merge!(modified_header)
       super
     end
 
     # Build/replace this responses data
-    def build(new_body = body, status = status, new_header = {})
-      self.header.merge!(new_header)
+    def build(new_body = nil, new_status = nil, new_header = nil)
+      self.header.merge!(new_header) if new_header
 
-      self.body, self.status = new_body, status
+      self.body   = new_body if new_body
+      self.status = new_status if new_status
     end
 
     def body=(obj)

data/lib/ramaze/setup.rb

@@ -1,50 +1,110 @@
 module Ramaze
-  def self.setup(start = true, &block)
-    SetupEnvironment.new(&block) if block_given?
-    self.start if start
+  # 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.
+  #
+  # @usage
+  #   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 SetupEnvironment
-    # FIXME:
-    # * This is weird, class scope includes Global, yet it's skipped
-    #   by Ruby on the lookup only because it's not in the scope of the block
-    #   at the point of creation, shouldn't instance_eval take the binding of
-    #   the SetupEnvironment instance in acocunt?
+  class GemSetup
+    def initialize(options = {}, &block)
+      @gems = []
+      @options = options.dup
+      @verbose = @options.delete(:verbose)
 
-    def initialize(&block)
+      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
 
-    # Shortcut for Ramaze::Gems::gem
-    def gem(*args)
-      require 'ramaze/contrib/gems'
-      Ramaze::Gems::gem(*args)
-      Ramaze::Gems::setup
+    # 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
 
-    # Shortcut if you don't need specific versions but tons of gems
-    def gems(*args)
-      args.each{|g| gem(g) }
+    # first try to activate, install and try to activate again if activation
+    # fails the first time
+    def setup_gem(name, options, try_install = true)
+      log "activating #{name}"
+      Gem.activate(name, *[options[:version]].compact)
+      require(options[:lib] || name)
+    rescue LoadError => exception
+      puts exception
+      install_gem(name, options) if try_install
+      setup_gem(name, options, try_install = false)
     end
 
-    def global(hash = nil)
-      if hash
-        Global.merge!(hash)
-      else
-        Global
+    # 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
-    alias option global
-  end
-end
 
-__END__
-Usage example:
+    # prepare ARGV for rubygems installer
+    def temp_argv(extconf)
+      if extconf ||= @options[:extconf]
+        old_argv = ARGV.clone
+        ARGV.replace(extconf.split(' '))
+      end
+
+      yield
 
-Ramaze.setup do
-  gem 'json'
+    ensure
+      ARGV.replace(old_argv) if extconf
+    end
+
+    private
 
-  option :middleware => true
-  global.adapter = :thin
-  option.port = 7000
+    def log(msg)
+      puts(msg) if @verbose
+    end
+
+    def rubyforge; 'http://gems.rubyforge.org/' end
+    def github; 'http://gems.github.com/' end
+  end
 end

data/lib/ramaze/snippets/ramaze/deprecated.rb

@@ -1,6 +1,8 @@
 module Ramaze
   DEPRECATED_CONSTANTS = {
-    :ThreadAccessor => :StateAccessor
+    :BASEDIR        => :ROOT,
+    :Template       => :View,
+    :Optional       => :Optioned,
   }
 
   def self.deprecated(from, to = nil)

data/lib/ramaze/snippets/{dictionary.rb → ramaze/dictionary.rb}

@@ -398,107 +398,3 @@ module Ramaze
 
   end
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_Dictionary < Test::Unit::TestCase
-
-    def test_create
-      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-      assert_equal( ['z','a','c'], hsh.keys )
-    end
-
-    def test_op_store
-      hsh = Dictionary.new
-      hsh['z'] = 1
-      hsh['a'] = 2
-      hsh['c'] = 3
-      assert_equal( ['z','a','c'], hsh.keys )
-    end
-
-    def test_push
-      hsh = Dictionary['a', 1, 'c', 2, 'z', 3]
-      assert( hsh.push('end', 15) )
-      assert_equal( 15, hsh['end'] )
-      assert( ! hsh.push('end', 30) )
-      assert( hsh.unshift('begin', 50) )
-      assert_equal( 50, hsh['begin'] )
-      assert( ! hsh.unshift('begin', 60) )
-      assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
-      assert_equal( ["end", 15], hsh.pop )
-      assert_equal( ["begin", "a", "c", "z"], hsh.keys )
-      assert_equal( ["begin", 50], hsh.shift )
-    end
-
-    def test_insert
-      # front
-      h = Dictionary['a', 1, 'b', 2, 'c', 3]
-      r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
-      assert_equal( 4, h.insert(0,'d',4) )
-      assert_equal( r, h )
-      # back
-      h = Dictionary['a', 1, 'b', 2, 'c', 3]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( 4, h.insert(-1,'d',4) )
-      assert_equal( r, h )
-    end
-
-    def test_update
-      # with other orderred hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = Dictionary['d', 4]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.update(h2) )
-      assert_equal( r, h1 )
-      # with other hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = { 'd' => 4 }
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.update(h2) )
-      assert_equal( r, h1 )
-    end
-
-    def test_merge
-      # with other orderred hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = Dictionary['d', 4]
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.merge(h2) )
-      # with other hash
-      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
-      h2 = { 'd' => 4 }
-      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
-      assert_equal( r, h1.merge(h2) )
-    end
-
-    def test_order_by
-      h1 = Dictionary['a', 3, 'b', 2, 'c', 1]
-      h1.order_by{ |k,v| v }
-      assert_equal( [1,2,3], h1.values )
-      assert_equal( ['c','b','a'], h1.keys )
-    end
-
-    def test_op_store
-      h1 = Dictionary[]
-      h1[:a] = 1
-      h1[:c] = 3
-      assert_equal( [1,3], h1.values )
-      h1[:b,1] = 2
-      assert_equal( [1,2,3], h1.values )
-      assert_equal( [:a,:b,:c], h1.keys )
-    end
-
-  end
-
-=end

data/lib/ramaze/snippets/ramaze/fiber.rb

@@ -1,10 +1,10 @@
 module Ramaze
   class Fiber < ::Fiber
-    attr_accessor :state
-
-    def initialize(*args)
-      super
-      @state = {}
+    # initialize isn't being called, so we have to hook into ::new
+    def self.new(*args)
+      instance = super
+      instance.state = {}
+      instance
     end
 
     attr_accessor :state

data/lib/ramaze/spec/helper/bacon.rb

@@ -1,7 +1,8 @@
-libdir = File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
-$LOAD_PATH.unshift libdir
-require 'vendor/bacon'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../ramaze'))
+
+require 'bacon'
 require 'ramaze/spec/helper/pretty_output'
+
 Bacon.extend Bacon::PrettyOutput
 # Bacon.extend Bacon::TestUnitOutput
 Bacon.summary_on_exit

data/lib/ramaze/spec/helper/snippets.rb

@@ -11,4 +11,6 @@ if caller
   end
 end
 
-require 'lib/ramaze/spec/helper/bacon'
+require 'bacon'
+
+Bacon.summary_on_exit

data/lib/ramaze/spec/helper/template_examples.rb

@@ -0,0 +1,29 @@
+module Ramaze
+  module Spec
+    module Examples
+      module Templates
+        def self.tests( describe, spec_engine )
+
+            describe.behaves_like :mock
+
+            describe.it '/' do
+              get('/').body.strip.should =~
+                %r{<a href\s*=\s*"/">Home</a>\s+\|\s+<a href\s*=\s*"/internal">internal</a>\s+\|\s+<a href\s*=\s*"/external">external</a>}
+            end
+
+            %w[/internal /external].each do |url|
+              describe.it url do
+                html = get(url).body
+                html.should.not == nil
+                html.should =~ %r{<title>Template::#{spec_engine} (internal|external)</title>}
+                html.should =~ %r{<h1>The (internal|external) Template for #{spec_engine}</h1>}
+              end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/spec.rb

@@ -1 +1,37 @@
-require 'ramaze/spec/helper'
+require 'ramaze'
+require 'bacon'
+
+require 'innate/spec'
+
+def spec_requires(*libs)
+  spec_precondition 'require' do
+    libs.each{|lib| require(lib) }
+  end
+end
+alias spec_require spec_requires
+
+def spec_precondition(name)
+  yield
+rescue LoadError => ex
+  puts "Spec require: %p failed: %p" % [name, ex.message]
+  exit 0
+rescue Exception => ex
+  puts "Spec precondition: %p failed: %p" % [name, ex.message]
+  exit 0
+end
+
+module Ramaze
+  Mock::OPTIONS[:app] = Ramaze
+
+  middleware!(:spec){|m| m.run(AppMap) }
+end
+
+shared :rack_test do
+  require 'rack/test'
+
+  extend Rack::Test::Methods
+
+  def app
+    Ramaze.middleware(:spec)
+  end
+end

data/lib/ramaze/tool/create.rb

@@ -24,7 +24,7 @@ module Ramaze
       #   :layout copy one subdirectory in +proto+
 
       DEFAULT = {
-        :proto => File.join(::Ramaze::BASEDIR, 'proto'),
+        :proto => File.join(ROOT, 'proto'),
         :amend => false,
         :force => false,
         :layout => '/',

data/lib/ramaze/version.rb

@@ -1,6 +1,3 @@
-#          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
-  VERSION = "2009.02"
+  VERSION = "2009.04.08"
 end