ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/tool/daemonize.rb

@@ -0,0 +1,37 @@
+require 'tmpdir'
+
+module Ramaze
+  def self.daemonize(runner, instruction, options = {})
+    puts "Instructing daemonize to: #{instruction}"
+    require 'daemons'
+
+    pids = File.join(Dir.tmpdir, 'ramaze.pids')
+    FileUtils.mkdir_p(pids)
+
+    # FIXME: there's a much better way, gotta search irc logs.
+    unless File.executable?(runner)
+      mode = File.stat(runner).mode.to_s(8)
+      mode[3,1] = '7'
+      File.chmod(mode.to_i(8), runner)
+    end
+
+    content = File.readlines(runner)
+    content.unshift('#!/usr/bin/env ruby') unless content[0] =~ /#!/
+    File.open(runner, 'w+'){|io| io.puts(content) }
+
+    options = {
+      :app_name   => File.basename(File.dirname(runner)),
+      :ARGV       => [instruction],
+      :script     => runner,
+      :dir_mode   => :normal,
+      :dir        => pids,
+      :multiple   => false,
+      :ontop      => false,
+      :mode       => :exec,
+      :backtrace  => true,
+      :monitor    => true,
+    }.merge(options)
+
+    Daemons.run(runner, options)
+  end
+end

data/lib/ramaze/tool/localize.rb

@@ -13,149 +13,185 @@ require 'ya2yaml'
 #   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Localize
 
 module Ramaze
-  class Tool::Localize
+  module Tool
+    class Localize
+
+      # Enable Localization
+      trait :enable => true
+
+      # Default language that is used if the browser don't suggests otherwise or
+      # the language requested is not available.
+      trait :default_language => 'en'
+
+      # languages supported
+      trait :languages => %w[ en ]
+
+      # This block should respond with the correct location of the yaml file
+      # for the given locale.
+      # Alternative is setting the value as a string that used by String#% with
+      # the locale as argument.
+      # The YAML file is used for saving and loading the localization.
+      #
+      # Example:
+      #   trait :file => "locale/%s.yaml"
+      #
+      # Please note that giving a relative String can lead to issues when the
+      # application is started from another pwd.
+      # That is why we, by default, use a dynamic lambda and set the path
+      # relative to Global.root.
+      trait :file => lambda{|locale|
+        Ramaze::Global.root/"conf/locale_#{locale}.yaml"
+      }
+
+      # The pattern that is substituted with the translation of the current locale.
+      trait :regex => /\[\[(.*?)\]\]/
+
+      # Browsers may send different keys for the same language, this allows you to
+      # do some coercion between what you use as keys and what the browser sends.
+      trait :mapping => { /^en-/ => 'en', 'ja' => 'jp'}
+
+      # When this is set to false, it will not save newly collected translatable
+      # strings to disk.  Disable this for production use, as it slows the
+      # application down.
+      trait :collect => true
+
+      class << self
+
+        include Trinity
+
+        # Enables being plugged into Dispatcher::Action::FILTER
+
+        def call(response, options = {})
+          return response unless trait[:enable]
+          return response if response.body.nil?
+          return response if response.body.respond_to?(:read)
+          response.body = localize_body(response.body, options)
+          response
+        end
 
-    # Enable Localization
-    trait :enable => true
+        # Localizes a response body.  It reacts to a regular expression as given
+        # in trait[:regex].  Every 'entity' in it will be translated, see
+        # `localize` for more information.
 
-    # Default language that is used if the browser don't suggests otherwise or
-    # the language requested is not available.
-    trait :default_language => 'en'
+        def localize_body(body, options)
+          locale =
+            if languages.include?(response["Content-Language"])
+              response["Content-Language"]
+            else
+              (session[:LOCALE] || set_session_locale).to_s
+            end
 
-    # languages supported
-    trait :languages => %w[ en ]
+          body.gsub!(trait[:regex]) do
+            localize($1, locale) unless $1.to_s.empty?
+          end
 
-    # YAML files the localizations are saved to and loaded from, %s is
-    # substituted by the values from trait[:languages]
-    trait :file => 'conf/locale_%s.yaml'.freeze
+          store(locale, default_language) if trait[:collect]
 
-    # The pattern that is substituted with the translation of the current locale.
-    trait :regex => /\[\[(.*?)\]\]/
+          body
+        end
 
-    # Browsers may send different keys for the same language, this allows you to
-    # do some coercion between what you use as keys and what the browser sends.
-    trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
+        # Localizes a single 'entity'.  If a translation in the chosen language is
+        # not available, it falls back to the default language.
 
-    # When this is set to false, it will not save newly collected translatable
-    # strings to disk.  Disable this for production use, as it slows the
-    # application down.
-    trait :collect => true
+        def localize(str, locale)
+          dict = dictionary
+          dict[locale] ||= {}
+          dict[default_language] ||= {}
 
-    class << self
+          trans = dict[locale][str] ||= dict[default_language][str] ||= str
+        rescue Object => ex
+          Log.error(ex)
+          str
+        end
 
-      include Trinity
+        # Sets session[:LOCALE] to one of the languages defined in the dictionary.
+        # It first tries to honor the browsers accepted languages and then falls
+        # back to the default language.
 
-      # Enables being plugged into Dispatcher::Action::FILTER
+        def set_session_locale
+          session[:LOCALE] = default_language
+          accepted_langs = request.locales << default_language
 
-      def call(response, options = {})
-        return response unless trait[:enable]
-        return response if response.body.nil?
-        return response if response.body.respond_to?(:read)
-        response.body = localize_body(response.body, options)
-        response
-      end
+          mapping = trait[:mapping]
+          dict = dictionary
 
-      # Localizes a response body.  It reacts to a regular expression as given
-      # in trait[:regex].  Every 'entity' in it will be translated, see
-      # `localize` for more information.
+          accepted_langs.each do |language|
+            if mapped = mapping.find{|k,v| k === language }
+              language = mapped[1]
+            end
 
-      def localize_body(body, options)
-        locale =
-          if trait[:languages].include?(response["Content-Language"])
-            response["Content-Language"]
-          else
-            (session[:LOCALE] || set_session_locale).to_s
+            if dict.key?(language)
+              session[:LOCALE] = language
+              break
+            end
           end
 
-        body.gsub!(trait[:regex]) do
-          localize($1, locale) unless $1.to_s.empty?
+          session[:LOCALE]
         end
 
-        store(locale, trait[:default_language]) if trait[:collect]
+        # Returns the dictionary used for translation.
 
-        body
-      end
+        def dictionary
+          trait[:languages].map! {|x| x.to_s }.uniq!
+          trait[:dictionary] || load(*languages)
+        end
 
-      # Localizes a single 'entity'.  If a translation in the chosen language is
-      # not available, it falls back to the default language.
+        # Load given locales from disk and save it into the dictionary.
 
-      def localize(str, locale)
-        default_language = trait[:default_language]
-        dict = dictionary
-        dict[locale] ||= {}
-        dict[default_language] ||= {}
+        def load(*locales)
+          Log.debug "loading locales: #{locales.inspect}"
 
-        trans = dict[locale].fetch(str, dict[default_language][str])
-        dict[locale][str] ||= trans
-        dict[default_language][str] ||= trans
+          dict = trait[:dictionary] || {}
 
-        trans
-      rescue Object => ex
-        Log.error(ex)
-        str
-      end
+          locales.each do |locale|
+            begin
+              dict[locale] = YAML.load_file(file_for(locale))
+            rescue Errno::ENOENT
+              dict[locale] = {}
+            end
+          end
 
-      # Sets session[:LOCALE] to one of the languages defined in the dictionary.
-      # It first tries to honor the browsers accepted languages and then falls
-      # back to the default language.
+          trait[:dictionary] = dict
+        end
 
-      def set_session_locale
-        session[:LOCALE] = trait[:default_language]
-        accepted_langs = request.http_accept_language rescue 'en'
+        # Stores given locales from the dictionary to disk.
 
-        mapping = trait[:mapping]
-        dict = dictionary
-        accepted_langs = accepted_langs.scan(/([^,;]+)(?:;q=[^,]+)?/m)[0]
+        def store(*locales)
+          locales.uniq.compact.each do |locale|
+            file = file_for(locale)
+            data = dictionary[locale].ya2yaml
 
-        accepted_langs.each do |language|
-          language = mapping[language] || language
-          if dict.key?(language)
-            session[:LOCALE] = language
-            break
+            Log.dev "saving localized to: #{file}"
+            File.open(file, 'w+'){|fd| fd << data }
           end
+        rescue Errno::ENOENT => e
+          Log.error e
         end
 
-        session[:LOCALE]
-      end
-
-      # Returns the dictionary used for translation.
-
-      def dictionary
-        trait[:languages].map! {|x| x.to_s }.uniq!
-        trait[:dictionary] || load(*trait[:languages])
-      end
-
-      # Load given locales from disk and save it into the dictionary.
-
-      def load(*locales)
-        Log.debug "loading locales: #{locales.inspect}"
+        # Call trait[:file] with the passed locale if it reponds to that,
+        # otherwise we call #to_s and % with the locale on it.
 
-        dict = trait[:dictionary] || {}
+        def file_for(locale)
+          file_source = trait[:file]
 
-        locales.each do |locale|
-          begin
-            dict[locale] = YAML.load_file(trait[:file] % locale)
-          rescue Errno::ENOENT
-            dict[locale] = {}
+          if file_source.respond_to?(:call)
+            file = file_source.call(locale)
+          else
+            file = file_source.to_s % locale
           end
         end
 
-        trait[:dictionary] = dict
-      end
+        # alias for trait[:languages]
 
-      # Stores given locales from the dictionary to disk.
+        def languages
+          trait[:languages]
+        end
 
-      def store(*locales)
-        locales.uniq.compact.each do |locale|
-          Log.dev "saving localized to: #{trait[:file] % locale}"
-          data = dictionary[locale].ya2yaml
-          file = trait[:file] % locale
-          File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|
-            fd.write data
-          end
+        # alias for trait[:default_language]
+
+        def default_language
+          trait[:default_language]
         end
-      rescue Errno::ENOENT => e
-        Log.error e
       end
     end
   end

data/lib/ramaze/version.rb

@@ -1,14 +1,6 @@
 #          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 #:nodoc:
-  module Version #:nodoc:
-    MAJOR = 0
-    MINOR = 3
-    TINY  = 9.1
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-
-  VERSION = Version::STRING
+module Ramaze
+  VERSION = "2008.06"
 end

data/rake_tasks/conf.rake

@@ -1,17 +1,11 @@
-AUTHOR = "manveru"
-EMAIL = "m.fellinger@gmail.com"
-DESCRIPTION = "Ramaze is a simple and modular web framework"
-HOMEPATH = 'http://ramaze.rubyforge.org'
-BIN_FILES = %w( ramaze )
-
 BASEDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 
-NAME = "ramaze"
 VERS = Ramaze::VERSION
 COPYRIGHT = [
   "#          Copyright (c) #{Time.now.year} Michael Fellinger m.fellinger@gmail.com",
   "# All files in this distribution are subject to the terms of the Ruby license."
 ]
+README = 'README.markdown'
 CLEAN.include %w[
   **/.*.sw?
   *.gem
@@ -22,22 +16,22 @@ CLEAN.include %w[
   pkg
   rdoc
 ]
-RDOC_OPTS = %w[
+RDOC_OPTS = %W[
   --all
   --quiet
   --op rdoc
   --line-numbers
   --inline-source
-  --main doc/README
+  --main #{README}
   --opname index.html
   --title "Ramaze\ documentation"
-  --exclude "^(_darcs|spec|examples|bin|pkg)/"
+  --exclude "^(spec|examples|bin|pkg)/"
   --exclude "lib/proto"
   --include "doc"
   --accessor "trait"
 ]
-RDOC_FILES = %w[
-  lib doc doc/README doc/FAQ doc/CHANGELOG
+RDOC_FILES = %W[
+  lib doc #{README} doc/FAQ doc/CHANGELOG
 ]
 POST_INSTALL_MESSAGE = %{
 #{'=' * 60}
@@ -52,11 +46,13 @@ You can now do following:
 }.strip
 
 AUTHOR_MAP = {
+  'andy@tinnedfruit.org'                    => 'Andy Smith',
   'ahoward'                                 => 'Ara T. Howard',
   'ara.t.howard@gmail.com'                  => 'Ara T. Howard',
   'blueonyx@dev-area.net'                   => 'Martin Hilbig',
   'clive@crous.co.za'                       => 'Clive Crous',
-  'comp.lang.zenix+ramaze@gmail.com'        => 'zenix',
+  'comp.lang.zenix+ramaze@gmail.com'        => 'Colin Shea',
+  'evaryont@gmx.us'                         => 'Colin Shea',
   'jesusisramazing.10.pistos@geoshell.com'  => 'Pistos',
   'jesuswasramazing.10.pistos@geoshell.com' => 'Pistos',
   'keita.yamaguchi@gmail.com'               => 'Keita Yamaguchi',
@@ -64,9 +60,11 @@ AUTHOR_MAP = {
   'manveru@weez-int.com'                    => 'Michael Fellinger',
   'm.fellinger@gmail.com'                   => 'Michael Fellinger',
   'outtenr@gmail.com'                       => 'Richard Outten',
+  'ryan@wonko.com'                          => 'Ryan Grove',
   'rff.rff@gmail.com'                       => 'Gabriele Renzi',
   'skaar@waste.org'                         => 'skaar',
   'stephan@spaceboyz.net'                   => 'Stephan Maka',
+  'samcarr@gmail.com'                       => 'samcarr',
 }
 
 # * Browse and try the Examples in

data/rake_tasks/gem.rake

@@ -1,43 +1,65 @@
-spec =
-    Gem::Specification.new do |s|
-        s.name = NAME
-        s.version = VERS
-        s.platform = Gem::Platform::RUBY
-        s.has_rdoc = true
-        s.extra_rdoc_files = RDOC_FILES
-        s.rdoc_options += RDOC_OPTS
-        s.summary = DESCRIPTION
-        s.description = DESCRIPTION
-        s.author = AUTHOR
-        s.email = EMAIL
-        s.homepage = HOMEPATH
-        s.executables = BIN_FILES
-        s.bindir = "bin"
-        s.require_path = "lib"
-        s.post_install_message = POST_INSTALL_MESSAGE
-
-        s.add_dependency('rake', '>=0.7.3')
-        s.add_dependency('rack', '>=0.2.0')
-        # s.required_ruby_version = '>= 1.8.5'
-
-        s.files = (RDOC_FILES + %w[Rakefile] + Dir["{examples,bin,doc,spec,lib,rake_tasks}/**/*"]).uniq
-
-        # s.extensions = FileList["ext/**/extconf.rb"].to_a
-    end
+def generate_gemspec(version)
+  Gem::Specification.new{|s|
+    s.name = "ramaze"
+    s.version = version
+    s.summary = "Ramaze is a simple and modular web framework"
+    s.description = s.summary
+
+    s.author = "Michael 'manveru' Fellinger"
+    s.email = "m.fellinger@gmail.com"
+    s.homepage = "http://ramaze.rubyforge.org"
+    s.rubyforge_project = "ramaze"
+
+    s.bindir = "bin"
+    s.require_path = "lib"
+
+    s.executables = Dir["#{s.bindir}/*"].map{|f| File.basename(f) }
+    s.files = FileList.new('**/*'){|fl|
+      fl.exclude(/^pkg\//)
+    }
+
+    s.has_rdoc = true
+    s.post_install_message = POST_INSTALL_MESSAGE
 
-Rake::GemPackageTask.new(spec) do |p|
-    p.need_tar = true
-    p.gem_spec = spec
+    s.add_dependency('rack', '>=0.3.0')
+  }
 end
 
-desc "package and install ramaze"
-task :install do
-  name = "#{NAME}-#{VERS}.gem"
-  sh %{rake package}
-  sh %{sudo gem install pkg/#{name}}
+def update_gemspec(spec)
+  gemspec = <<-OUT.strip
+Gem::Specification.new do |s|
+  s.name = %name%
+  s.version = %version%
+
+  s.summary = %summary%
+  s.description = %description%
+  s.has_rdoc = %has_rdoc%
+  s.author = %author%
+  s.email = %email%
+  s.homepage = %homepage%
+  s.executables = %executables%
+  s.bindir = %bindir%
+  s.require_path = %require_path%
+  s.post_install_message = %post_install_message%
+
+  %dependencies%
+
+  s.files = %files%
 end
+  OUT
+
+  gemspec.gsub!(/%(\w+)%/) do
+    case key = $1
+    when 'version'
+      spec.version.to_s.dump
+    when 'dependencies'
+      spec.dependencies.map{|dep|
+        "s.add_dependency('#{dep.name}', '#{dep.version_requirements}')"
+      }.join("\n  ")
+    else
+      spec.send($1).pretty_inspect.strip
+    end
+  end
 
-desc "uninstall the ramaze gem"
-task :uninstall => [:clean] do
-  sh %{sudo gem uninstall #{NAME}}
+  File.open("ramaze.gemspec", 'w+'){|file| file.puts(gemspec) }
 end