ramaze 2009.03 → 2009.04

data/lib/ramaze/helper/localize.rb

@@ -0,0 +1,138 @@
+require 'locale/tag'
+require 'locale'
+
+module Ramaze
+  module Helper
+    module Localize
+      include Traited
+
+      trait :localize_locale => ::Locale::Tag::Simple.new('en')
+      trait :localize_charset => 'UTF-8'
+
+      def localize(string, substitute = nil)
+        localize_dictionary.translate(string, locales, substitute)
+      end
+      alias l localize
+
+      def locale
+        locales.first
+      end
+
+      def locales
+        locales = request.env['localize.locales']
+        return locales if locales
+
+        fallback = ancestral_trait[:localize_locale]
+        locales = Parser.new(request).locales(fallback)
+        request.env['localize.locales'] = locales
+      end
+
+      class Dictionary
+        attr_reader :dict
+
+        def initialize
+          @dict = {}
+        end
+
+        def translate(string, locales, substitute)
+          target = string.to_s.dup
+          locales = locales.flatten.uniq
+
+          if substitute
+            substitute.each do |key, value|
+              target.gsub!(/\{#{Regexp.escape(key)}\}/, lookup(value, locales))
+            end
+            return target
+          elsif target =~ /\{/
+            target.gsub!(/\{([^\}]+)\}/){ lookup($1, locales) }
+            return target
+          else
+            lookup(target, locales)
+          end
+        end
+
+        def lookup(string, locales)
+          locales.each do |locale|
+            next unless dict = self[locale]
+            next unless translated = dict[string]
+            return translated
+          end
+
+          string
+        end
+
+        def locales
+          @dict.keys
+        end
+
+        def [](locale)
+          @dict[arg_to_locale(locale)]
+        end
+
+        def []=(locale, dict)
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        def load(locale, options = {})
+          if file = options.delete(:yaml)
+            dict = ::YAML.load_file(file)
+          elsif hash = options.delete(:hash)
+            dict = hash
+          elsif marshal = options.delete(:marshal)
+            dict = Marshal.load(File.read(marshal))
+          else
+            raise ArgumentError, "either :yaml, :marshal, or :hash"
+          end
+
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        private
+
+        def arg_to_locale(arg, raises = true)
+          if raises and not arg
+            raise(ArgumentError, "%p cannot be converted to a Locale" % arg)
+          end
+          arg.respond_to?(:language) ? arg : ::Locale::Tag.parse(arg.to_s)
+        end
+      end
+
+      class Parser
+        attr_accessor :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        def locales(fallback = nil)
+          locales = [parse, fallback].flatten.uniq
+          ::Locale::TagList.new(locales)
+        end
+
+        def parse
+          parse_params || parse_session || parse_cookie || parse_header
+        end
+
+        def parse_params(key = 'lang')
+          return unless lang = request.params[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_session(key = :lang)
+          return unless lang = Current.session[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_cookie(key = 'lang')
+          return unless lang = request.cookies[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_header
+          request.accept_language.map{|lang|
+            ::Locale::Tag.parse(lang) }
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/markaby.rb

@@ -15,7 +15,7 @@ module Ramaze
     def markaby(ivs = {}, helpers = nil, &block)
       builder = ::Markaby::Builder
       builder.extend(Ramaze::Helper::Methods)
-      builder.send(:helper, :redirect, :link, :sendfile, :flash, :cgi, :partial)
+      builder.send(:helper, :link)
 
       iv_hash = {}
       instance_variables.each do |iv|

data/lib/ramaze/helper/maruku.rb

@@ -1,9 +1,16 @@
 require 'maruku'
 
 module Ramaze
-  module Helper::Maruku
-    def maruku(text)
-      Maruku.new(text).to_html
+  module Helper
+    module Maruku
+      # Shortcut to generate HTML from Markdown code using Maruku
+      #
+      # @param [#to_str] text the markdown to be converted
+      # @return [String] html generated from +text+
+      # @author manveru
+      def maruku(text)
+        ::Maruku.new(text.to_str).to_html
+      end
     end
   end
 end

data/lib/ramaze/helper/pager.rb

@@ -83,6 +83,7 @@ module Ramaze
 
 class Pager
   include Ramaze::Helper::Link
+  include Ramaze::Traited
 
   # Items per page.
 
@@ -255,7 +256,7 @@ private
 
   def target_uri(page)
     params = @request.params.merge(@key => page)
-    Rs(Action.current.name, params)
+    Current.action.node.r(Current.action.name, params)
   end
 
   # Generate link for the first page.

data/lib/ramaze/helper/paginate.rb

@@ -9,6 +9,7 @@ module Ramaze
     # Also have a look at the examples/helpers/paginate.rb
 
     module Paginate
+      include Traited
 
       # Define default options in your Controller, they are being retrieved by
       # ancestral_trait, so you can also put it into a common superclass
@@ -62,8 +63,8 @@ module Ramaze
       # Provides easy pagination and navigation
 
       class Paginator
-        include Ramaze::Helper::Link
-        include Ramaze::Helper::CGI
+        include Ramaze::Helper
+        helper :link, :cgi
 
         def initialize(data = [], page = 1, limit = 10, var = 'pager')
           @data, @page, @limit, @var = data, page, limit, var
@@ -142,11 +143,18 @@ module Ramaze
           @pager.page_count > 1
         end
 
-        # Forward everything to the inner @pager
+        # these methods are actually on the pager, but we def them here for
+        # convenience (method_missing in helper is evil and even slower)
 
-        def method_missing(meth, *args, &block)
-          @pager.send(meth, *args, &block)
-        end
+        def page_count; @pager.page_count end
+        def each(&block) @pager.each(&block) end
+        def first_page?; @pager.first_page?; end
+        def prev_page; @pager.prev_page; end
+        def current_page; @pager.current_page; end
+        def last_page; @pager.last_page; end
+        def last_page?; @pager.last_page?; end
+        def next_page; @pager.next_page; end
+        def empty?; @pager.empty?; end
 
         private
 
@@ -164,9 +172,9 @@ module Ramaze
         def link(n, text = n, hash = {})
           text = h(text.to_s)
 
-          params = Ramaze::Request.current.params.merge(@var.to_s => n)
-          name = Ramaze::Request.current.path_info
-          hash[:href] = R(name, params)
+          action = Current.action
+          params = request.params.merge(@var.to_s => n)
+          hash[:href] = action.node.r(action.name, params)
 
           g.a(hash){ text }
         end

data/lib/ramaze/helper/partial.rb

@@ -1,105 +1,100 @@
-#          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
+  module Helper
 
-  # = Helper::Partial
-  #
-  # === Example Usage
-  #
-  #   class MyController
-  #     def index
-  #     end
-  #     def list
-  #       plain = request['plain']
-  #       "Hello World from List!  Plain List == #{plain}"
-  #     end
-  #   end
-  #
-  #
-  #   <html>
-  #     <head><title>Partial Render Index</title></head>
-  #     <body>
-  #       #{render_partial(Rs(:list), 'plain' => true)}
-  #     </body>
-  #   </html>
-
-  module Helper::Partial
-    module_function
-
-    # Renders a url 'inline'.
+    # = Helper::Partial
     #
-    # url:      normal URL, like you'd use for redirecting.
-    # options:  optional, will be used as request parameters.
-
-    def render_partial(url, options = {})
-      # Save any request params that clash with the ones we're about to add in.
-      saved = {}
-      options.keys.each {|x| saved[x] = Request.current.params[x] }
-
-      # Add/overwrite with the specified params. Ensure keys are strings since
-      # request[:foo] converts key to string when performing lookup.
-      options.each do |key, value|
-        Request.current.params[key.to_s] = value
-      end
-
-      Controller.handle(url)
-    ensure
-      # Always reinstate the original
-      options.keys.each {|x| Request.current.params[x] = saved[x] }
-    end
-
-    # Render the template file in view_root of the
-    # current controller.
-
-    def render_template(file, vars = {})
-      current = Action.current
-      options = { :controller => current.controller,
-                  :instance => current.instance.dup }
-
-      file = file.to_s
-
-      if Pathname(file).absolute?
-        file = file.squeeze '/'
-        unless File.exist?(file)
-          Log.warn "render_template: #{file} does not exist."
-          return ''
+    # Please note that this helper is deprecated in favor of # Helper::Render,
+    # it has been removed from Innate and remains in Ramaze until 2009.05.
+    #
+    # === Example Usage
+    #
+    #   class MyController
+    #     def index
+    #     end
+    #
+    #     def list
+    #       plain = request['plain']
+    #       "Hello World from List!  Plain List == #{plain}"
+    #     end
+    #   end
+    #
+    #
+    #   <html>
+    #     <head><title>Partial Render Index</title></head>
+    #     <body>
+    #       #{render_partial(Rs(:list), 'plain' => true)}
+    #     </body>
+    #   </html>
+    module Partial
+      module_function
+
+      # Renders a url 'inline'.
+      #
+      # +url+      normal URL, like you'd use for redirecting.
+      # +options+  optional, will be used as request parameters.
+      #
+      # Issues a mock request to the given +url+ with +options+ turned into
+      # query arguments.
+      def render_partial(url, options = {})
+        Ramaze.deprecated('Helper::Partial#render_partial', 'Helper::Render#render_full')
+
+        uri = URI(url)
+        query = options # Innate::Current.request.params.merge(options)
+        uri.query = Rack::Utils.build_query(query)
+
+        body = nil
+
+        Innate::Mock.session do |session|
+          cookie = Innate::Current.session.cookie
+          session.cookie = cookie
+          body = session.get(uri.to_s, options).body
         end
-        options[:template] = file
-      else
-        roots = [options[:controller].template_paths].flatten
 
-        if (files = Dir[File.join("{#{roots.join(',')}}","{#{file},#{file}.*}")]).any?
-          options[:template] = files.first.squeeze '/'
-        else
-          Log.warn "render_template: #{file} does not exist in the following directories: #{roots.join(',')}."
-          return ''
-        end
+        body
       end
 
-      binding = options[:instance].scope
-      
-      # For Ruby 1.9/1.8.7
-      binding = binding.binding if binding.respond_to?(:binding)
-
-      vars.each do |name, value|
-        options[:instance].instance_variable_set("@#{name}", value)
-
-        value = "ObjectSpace._id2ref(#{ value.object_id })"
-        eval "#{ name } = #{ value }", binding
+      # Render the template file in view_root of the
+      # current controller.
+      #
+      # TODO:
+      # * Doesn't work for absolute paths, but there are no specs for that yet.
+      # * the local variable hack isn't working because innate allocates a new
+      #   binding.
+      #   For now one can simply use instance variables, which I prefer anyway.
+      #
+      # the local binding hack:
+      #
+      #   variables.each do |key, value|
+      #     value = "ObjectSpace._id2ref(#{value.object_id})"
+      #     eval "#{key} = #{value}", action.binding
+      #   end
+
+      def render_template(path, variables = {})
+        Ramaze.deprecated('Helper::Partial#render_template')
+        path = path.to_s
+
+        ext = File.extname(path)
+        basename = File.basename(path, ext)
+
+        action = Innate::Current.action.dup
+        action.layout    = nil
+        action.view      = action.node.find_view(basename, 'html')
+        action.method    = action.node.find_method(basename, action.params)
+
+        action.variables = action.variables.merge(variables)
+        action.sync_variables(action)
+
+        return action.call if action.valid?
+        raise(ArgumentError, "cannot render %p" % path)
       end
 
-      options[:binding] = binding
-
-      Ramaze::Action(options).render
-    end
-
-    # shortcut to render_partial, accepts a method and contructs a link to the
-    # current controller, then calls render_partial on that
-
-    def render_action method, *params
-      render_partial(Rs(method), *params)
+      def render_action(method, *params)
+        Ramaze.deprecated('Helper::Partial#render_action', 'Helper::Render#render_full')
+        render_partial(r(method), *params)
+      end
     end
-
   end
 end

data/lib/ramaze/helper/remarkably.rb

@@ -0,0 +1,14 @@
+require 'remarkably'
+
+module Ramaze
+  module Helper
+    module Remarkably
+      include ::Remarkably::Common
+
+      # Avoid calling the Helper::Link#a method
+      def a(*args, &block)
+        method_missing(:a, *args, &block)
+      end
+    end
+  end
+end