Pistos-ramaze 2009.02 → 2009.04.08

data/lib/ramaze/template.rb

@@ -1,87 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# This module serves as a namespace for all templates, it will autoload
-# Amrita2, Erubis, Haml, Liquid and Markaby if you refer to them.
-
-module Ramaze
-
-  # Namespace for templating.
-
-  module Template
-
-    COMPILED = {} unless defined?(COMPILED)
-
-    # Place register_engine puts the class and extensions for templating engines
-
-    ENGINES = {} unless defined?(ENGINES)
-
-    AVAILABLE_ENGINES = %w[
-      Amrita2 Builder Erubis Haml Liquid Markaby Maruku Nagoro None RedCloth
-      Remarkably Sass Tagz Tenjin XSLT
-    ]
-
-    AVAILABLE_ENGINES.each do |const|
-      autoload(const, "ramaze/template/#{const.downcase}")
-    end
-
-    # The superclass for all templates, contains the shared behaviour of
-    # the templates and includes Ramaze::Helper::Methods
-
-    class Template
-      include Ramaze::Helper::Methods
-
-      class << self
-
-        # calls result_and_file with the given action and returns the first of
-        # the result of the controller or content of the file.
-
-        def reaction_or_file action
-          result_and_file(action).reverse.compact.first
-        end
-
-        # Takes an Action and returns the result from sending the action.method
-        # to the controller via render_method and reads the contents of the file
-        # if given.
-
-        def result_and_file(action)
-          result = render_method(action)
-
-          if file = action.template
-            content = File.read(file)
-          end
-
-          [result, content]
-        end
-
-        # returns nil if no method is on the action, otherwise it will send the
-        # action and optional parameters to the controller via __send__ and
-        # return the unaltered result
-
-        def render_method(action)
-          return unless method = action.method
-          action.instance.__send__(method, *action.params)
-        end
-
-        # This is a wrapper to use Global.compile without even thinking about
-        # it. Don't use it if your engine is not based on a compile/eval
-        # principle.
-
-        def wrap_compile(action, template = nil)
-          template ||= reaction_or_file(action).to_s
-          caching_compile(action, template)
-        end
-
-        # If Global.compile is enabled try to find the action in the cache,
-        # otherwise give a new compiled object back.
-        def caching_compile(action, template)
-          if Global.compile && action.template
-            Cache.compiled[action.relaxed_hash] ||= compile(action, template)
-          else
-            compile(action, template)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/tool/daemonize.rb

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

@@ -1,202 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-$KCODE = 'UTF-8'
-require 'ya2yaml'
-
-# Localize helps transforming arbitrary text into localized forms using
-# a simple regular expression and substituting occurences with predefined
-# snippets stored in YAML files.
-#
-# == Usage:
-#
-#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Localize
-
-module Ramaze
-  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]
-
-          body = []
-
-          response.body.each do |chunk|
-            body << localize_body(chunk, options)
-          end
-
-          response.body = body.join
-        end
-
-        # 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.
-
-        def localize_body(body, options)
-          locale =
-            if languages.include?(response["Content-Language"])
-              response["Content-Language"]
-            else
-              (session[:LOCALE] || set_session_locale).to_s
-            end
-
-          body.gsub!(trait[:regex]) do
-            localize($1, locale) unless $1.to_s.empty?
-          end
-
-          store(locale, default_language) if trait[:collect]
-
-          body
-        end
-
-        # Localizes a single 'entity'.  If a translation in the chosen language is
-        # not available, it falls back to the default language.
-
-        def localize(str, locale)
-          dict = dictionary
-          dict[locale] ||= {}
-          dict[default_language] ||= {}
-
-          trans = dict[locale][str] ||= dict[default_language][str] ||= str
-        rescue Object => ex
-          Log.error(ex)
-          str
-        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.
-
-        def set_session_locale
-          session[:LOCALE] = default_language
-          accepted_langs = request.locales << default_language
-
-          mapping = trait[:mapping]
-          dict = dictionary
-
-          accepted_langs.each do |language|
-            if mapped = mapping.find{|k,v| k === language }
-              language = mapped[1]
-            end
-
-            if dict.key?(language)
-              session[:LOCALE] = language
-              break
-            end
-          end
-
-          session[:LOCALE]
-        end
-
-        # Returns the dictionary used for translation.
-
-        def dictionary
-          trait[:languages].map! {|x| x.to_s }.uniq!
-          trait[:dictionary] || load(*languages)
-        end
-
-        # Load given locales from disk and save it into the dictionary.
-
-        def load(*locales)
-          Log.debug "loading locales: #{locales.inspect}"
-
-          dict = trait[:dictionary] || {}
-
-          locales.each do |locale|
-            begin
-              dict[locale] = YAML.load_file(file_for(locale))
-            rescue Errno::ENOENT
-              dict[locale] = {}
-            end
-          end
-
-          trait[:dictionary] = dict
-        end
-
-        # Stores given locales from the dictionary to disk.
-
-        def store(*locales)
-          locales.uniq.compact.each do |locale|
-            file = file_for(locale)
-            data = dictionary[locale].ya2yaml
-
-            Log.dev "saving localized to: #{file}"
-            File.open(file, 'w+'){|fd| fd << data }
-          end
-        rescue Errno::ENOENT => e
-          Log.error e
-        end
-
-        # Call trait[:file] with the passed locale if it reponds to that,
-        # otherwise we call #to_s and % with the locale on it.
-
-        def file_for(locale)
-          file_source = trait[:file]
-
-          if file_source.respond_to?(:call)
-            file = file_source.call(locale)
-          else
-            file = file_source.to_s % locale
-          end
-        end
-
-        # alias for trait[:languages]
-
-        def languages
-          trait[:languages]
-        end
-
-        # alias for trait[:default_language]
-
-        def default_language
-          trait[:default_language]
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/tool/mime.rb

@@ -1,35 +0,0 @@
-#          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 Tool
-
-    # Responsible for lookup of MIME info for filetypes based on extension.
-
-    module MIME
-
-      # the mime_types.yaml as full path, we use a copy of mongrels.
-      trait :types => YAML.load_file(File.join(BASEDIR, 'ramaze/tool/mime_types.yaml'))
-
-      class << self
-
-        # Get MIME-type for the given filename based on extension.
-        # Answers with an empty string if none is found.
-        def type_for(file)
-          ext = File.extname(file)
-          trait[:types][ext].to_s
-        end
-
-        def ext_for(mime)
-          exts = []
-
-          trait[:types].each do |ext, mime_type|
-            exts << ext if mime == mime_type
-          end
-
-          exts.sort_by{|e| e.size }.first
-        end
-      end
-    end
-  end
-end