ramaze 0.1.1 → 0.1.2

data/lib/ramaze/template/erubis.rb

@@ -3,27 +3,31 @@
 
 require 'erubis'
 
-module Ramaze::Template
+module Ramaze
+  module Template
 
-  # Is responsible for compiling a template using the Erubis templating engine.
+    # Is responsible for compiling a template using the Erubis templating engine.
 
-  class Erubis < Template
+    class Erubis < Template
 
-    Ramaze::Controller.register_engine self, %w[ rhtml ]
+      ENGINES[self] = %w[ rhtml ]
 
-    class << self
+      class << self
 
-      # Takes a controller and the options :action, :parameter, :file and :binding
-      #
-      # Builds a template out of the method on the controller and the
-      # template-file.
+        # Entry-point for Action#render
 
-      def transform action
-        template = reaction_or_file(action)
+        def transform action
+          eruby = wrap_compile(action)
+          eruby.result(action.binding)
+        end
 
-        eruby = ::Erubis::Eruby.new(template)
-        eruby.init_evaluator(:filename => (action.template || __FILE__))
-        eruby.result(action.binding)
+        # Creates an instance of ::Erubis::Eruby, sets the filename
+        # from the template and returns the instance.
+        def compile(action, template)
+          eruby = ::Erubis::Eruby.new(template)
+          eruby.init_evaluator(:filename => (action.template || __FILE__))
+          eruby
+        end
       end
     end
   end

data/lib/ramaze/template/ezamar.rb

@@ -10,41 +10,30 @@ module Ramaze
 
     class Ezamar < Template
 
-      Ramaze::Controller.register_engine self, %w[ xhtml zmr ]
+      ENGINES[self] = %w[ xhtml zmr ]
 
-      trait :transform_pipeline => [
-        ::Ezamar::Element, ::Ezamar::Template
-      ]
-
-      trait :actionless => true
+      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
 
       class << self
 
-        # Takes a controller and the options :action, :parameter, :file and :binding
-        #
-        # Uses Ezamar::Template to compile the template.
-
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
         def transform action
-          template = reaction_or_file(action)
-          file = (action.template || __FILE__)
-          pipeline(template.to_s, action.binding, file)
+          ezamar = wrap_compile(action)
+          ezamar.result(action.binding)
         end
 
-        # go through the pipeline and call #transform on every object found there,
-        # passing the template at that point.
-        # the order and contents of the pipeline are determined by an array
-        # in trait[:template_pipeline]
-        # the default being [Element, Morpher, self]
-        #
-        # TODO
-        #   - put the pipeline into the Controller for use with all templates.
-
-        def pipeline(template, binding, file)
-          class_trait[:transform_pipeline].each do |klass|
-            template = klass.transform(template, binding, file)
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Ezamar::Template
+
+        def compile(action, template)
+          file = (action.template || __FILE__)
+
+          TRANSFORM_PIPELINE.each do |tp|
+            template = tp.transform(template)
           end
 
-          template
+          ::Ezamar::Template.new(template, :file => file)
         end
       end
     end

data/lib/ramaze/template/ezamar/element.rb

@@ -83,7 +83,7 @@ class Ezamar::Element
     # a binding to be compatible to the transform-pipeline, won't have
     # any use for it though.
 
-    def transform template, binding, file = __FILE__
+    def transform template
       matches = template.scan(/<([A-Z][a-zA-Z0-9]*)(.*?)?>/)
 
       matches.each do |(klass, params)|

data/lib/ramaze/template/ezamar/engine.rb

@@ -17,47 +17,56 @@ module Ezamar
   # This class is responsible for initializing and compiling the template.
 
   class Template
-    class << self
-
-      # All ye who seek magic, look elsewhere, this method is ASAP (as simple as possible)
-      #
-      # There are some simple gsubs that build a final template which is evaluated
-      #
-      # The rules are following:
-      # <?r rubycode ?>
-      #   evaluate the code inside the tag, this is considered XHTML-valid and so is the
-      #   preferred method for executing code inside your templates.
-      #   The return-value is ignored
-      # <% rubycode %>
-      #   The same as <?r ?>, ERB-style and not valid XHTML, but should give someone who
-      #   is already familiar with ERB some common ground
-      # #{ rubycode }
-      #   You know this from normal ruby already and it's actually nothing else.
-      #   Interpolation at the position in the template, isn't any special taggy format
-      #   and therefor safe to use.
-      # <%= rubycode %>
-      #   The result of this will be interpolated at the position in the template.
-      #   Not valid XHTML either.
-      #
-      # TODO
-      #   - provide C version or maybe use erbuis
-
-      def transform(template, binding, file = __FILE__)
-        start_heredoc = "T" << Digest::SHA1.hexdigest(template)
-        start_heredoc, end_heredoc = "\n<<#{start_heredoc}\n", "\n#{start_heredoc}\n"
-        bufadd = "_out_ << "
-
-        template.gsub!(/<%\s+(.*?)\s+%>/m,
+    def initialize(template, options = {})
+      @template, @options = template, options
+      compile
+    end
+
+    # All ye who seek magic, look elsewhere, this method is ASAP (as simple as possible)
+    #
+    # There are some simple gsubs that build a final template which is evaluated
+    #
+    # The rules are following:
+    # <?r rubycode ?>
+    #   evaluate the code inside the tag, this is considered XHTML-valid and so is the
+    #   preferred method for executing code inside your templates.
+    #   The return-value is ignored
+    # <% rubycode %>
+    #   The same as <?r ?>, ERB-style and not valid XHTML, but should give someone who
+    #   is already familiar with ERB some common ground
+    # #{ rubycode }
+    #   You know this from normal ruby already and it's actually nothing else.
+    #   Interpolation at the position in the template, isn't any special taggy format
+    #   and therefor safe to use.
+    # <%= rubycode %>
+    #   The result of this will be interpolated at the position in the template.
+    #   Not valid XHTML either.
+    #
+    # TODO
+    #   - provide C version or maybe use erbuis
+
+    def compile
+      temp = @template.dup
+      start_heredoc = "T" << Digest::SHA1.hexdigest(temp)
+      start_heredoc, end_heredoc = "\n<<#{start_heredoc}\n", "\n#{start_heredoc}\n"
+      bufadd = "_out_ << "
+
+      temp.gsub!(/<%\s+(.*?)\s+%>/m,
             "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
-        template.gsub!(/<\?r\s+(.*?)\s+\?>/m,
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m,
             "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
-        template.gsub!(/<%=\s+(.*?)\s+%>/m,
+      temp.gsub!(/<%=\s+(.*?)\s+%>/m,
             "#{end_heredoc} #{bufadd} (\\1); #{bufadd} #{start_heredoc}")
 
-        template = "_out_ = ''; #{bufadd} #{start_heredoc} #{template} #{end_heredoc}; _out_"
+      @compiled = "_out_ = ''
+      #{bufadd} #{start_heredoc} #{temp} #{end_heredoc}
+      _out_"
+    end
+
+    # Takes a binding and evals it with the previously set options.
 
-        eval(template, binding, file).strip
-      end
+    def result(binding)
+      eval(@compiled, binding, @options[:file]).strip
     end
   end
 end

data/lib/ramaze/template/ezamar/morpher.rb

@@ -18,7 +18,7 @@ require 'ramaze/template/ezamar/engine'
 #
 # If you want to turn this functionality off, either remove Morpher
 # from:
-#   Ramaze::Template::Ezamar.trait[:transform_pipeline]
+#   Ramaze::Template::Ezamar::TRANSFORM_PIPELINE
 # or do:
 #   Ramaze::Morpher.trait[:morphs] = {}
 #
@@ -106,7 +106,7 @@ class Ezamar::Morpher
   # TODO:
   #   - Add pure Ruby implementation as a fall-back.
 
-  def self.transform template, action, file = __FILE__
+  def self.transform(template)
     morphs =
       trait[:morphs].map{|k,v| [k.to_s, v.to_s]}.select do |(k,v)|
         template.to_s.include?("#{k}=")
@@ -145,7 +145,7 @@ class Ezamar::Morpher
     # replace this method with a stub that only returns the template.
 
     self.class_eval do
-      def self.transform(template, action)
+      def self.transform(template)
         template
       end
     end

data/lib/ramaze/template/ezamar/render_partial.rb

@@ -0,0 +1,26 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/template/ezamar/engine'
+
+module Ezamar
+  class RenderPartial
+
+    # Renders <render src="/path" [optional="option", ...]> in place.
+    #
+    # Other options than `src` will be transformed to session parameters for the
+    # rendered action to use.
+
+    def self.transform(template, action, file = __FILE__)
+      template.gsub!(/<render (.*?) \/>/) do |m|
+        args = Hash[*$1.scan(/(\S+)=["'](.*?)["']/).flatten]
+        if src = args.delete('src')
+          PartialHelper.render_partial(src, args)
+        end
+      end
+
+      template
+    end
+
+  end
+end

data/lib/ramaze/template/haml.rb

@@ -3,32 +3,37 @@
 
 require 'haml/engine'
 
-module Ramaze::Template
-  class Haml < Template
+module Ramaze
+  module Template
+    class Haml < Template
 
-    # Custom HAML-options for your controller to be merged.
+      # Custom HAML-options for your controller to be merged.
 
-    trait :haml_options => {
-            :locals => {}
-          }
+      trait :haml_options => {
+        :locals => {}
+      }
 
-    Ramaze::Controller.register_engine self, %w[ haml ]
+      ENGINES[self] = %w[ haml ]
 
-    class << self
+      class << self
 
-      # Transform any String via Haml, takes optionally an hash with the haml_options
-      # that you can set also by
-      #   trait :haml_options => {}
-      # if you pass the options it will merge the trait with them. (your options
-      # override the defaults from trait[:haml_options]
+        # Transform any String via Haml, takes optionally an hash with the
+        # haml_options that you can set also by
+        #   trait :haml_options => {}
+        # if you pass the options it will merge the trait with them. (your
+        # options override the defaults from trait[:haml_options]
 
-      def transform action
-        template = reaction_or_file(action)
+        def transform action
+          haml = wrap_compile(action)
+          haml.to_html(action.instance)
+        end
 
-        return '' unless template
+        # Instantiates Haml::Engine with the template and haml_options from
+        # the trait.
 
-        haml = ::Haml::Engine.new(template, ancestral_trait[:haml_options])
-        haml.to_html(action.controller)
+        def compile(action, template)
+          ::Haml::Engine.new(template, ancestral_trait[:haml_options])
+        end
       end
     end
   end

data/lib/ramaze/template/liquid.rb

@@ -6,7 +6,8 @@ require 'liquid'
 module Ramaze
   module Template
     class Liquid < Template
-      Controller.register_engine self, %w[ liquid ]
+
+      ENGINES[self] = %w[ liquid ]
 
       class << self
 
@@ -18,9 +19,10 @@ module Ramaze
         def transform action
           template = reaction_or_file(action)
 
-          hash     = action.controller.instance_variable_get("@hash") || {}
+          instance = action.instance
+          hash     = instance.instance_variable_get("@hash") || {}
           template = ::Liquid::Template.parse(template)
-          options  = action.controller.ancestral_trait[:liquid_options]
+          options  = instance.ancestral_trait[:liquid_options]
 
           template.render(hash, options)
         end

data/lib/ramaze/template/markaby.rb

@@ -6,31 +6,34 @@ require 'markaby'
 module Ramaze
   module Template
     class Markaby < Template
-      Controller.register_engine self, %w[ mab ]
+      ENGINES[self] = %w[ mab ]
 
       class << self
 
-        # initializes the handling of a request on the controller.
-        # Creates a new instances of itself and sends the action and params.
-        # Also tries to render the template.
-        # In Theory you can use this standalone, this has not been tested though.
+        # Entry point for Action#render
 
         def transform action
           result, file = result_and_file(action)
 
-          result = transform_file(file, action) if file
+          result = transform_string(file, action) if file
           result.to_s
         end
 
-        def transform_file file, action
-          controller = action.controller
-          ivs = extract_ivs(controller)
+        # Takes a string and action, instance_evals the string inside a mab
+        # block that gets the instance_variables of the original
+        # action.instance passed.
 
-          controller.send(:mab, ivs) do
-            instance_eval(file)
+        def transform_string string, action
+          instance = action.instance
+          ivs = extract_ivs(instance)
+
+          instance.send(:mab, ivs) do
+            instance_eval(string)
           end
         end
 
+        # Generate a hash from instance-variables
+
         def extract_ivs(controller)
           controller.instance_variables.inject({}) do |hash, iv|
             sym = iv.gsub('@', '').to_sym

data/lib/ramaze/template/remarkably.rb

@@ -6,20 +6,26 @@ require 'remarkably/engines/html'
 module Ramaze
   module Template
     class Remarkably < Template
-      Controller.register_engine self, %w[ rem ]
+      ENGINES[self] = %w[ rem ]
 
       class << self
+
+        # Entry point for Action#render
+
         def transform action
           result, file = result_and_file(action)
 
-          result = transform_file(file, action) if file
+          result = transform_string(file, action) if file
           result.to_s
         end
 
-        def transform_file(file, action)
-          action.controller.instance_eval do
+        # Takes a string and action, sets args to action.args and then proceeds
+        # to instance_eval the string inside the action.instance
+
+        def transform_string(string, action)
+          action.instance.instance_eval do
             args = action.params
-            instance_eval(file)
+            instance_eval(string)
           end
         end
       end

data/lib/ramaze/tool/localize.rb

@@ -27,6 +27,11 @@ class Ramaze::Tool::Localize
   # do some coercion between what you use as keys and what the browser sends.
   trait :mapping => { 'en-us' => '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 Ramaze::Trinity
@@ -46,7 +51,7 @@ class Ramaze::Tool::Localize
         localize($1, locale)
       end
 
-      store(locale, trait[:default_language])
+      store(locale, trait[:default_language]) if trait[:collect]
 
       body
     end
@@ -60,9 +65,12 @@ class Ramaze::Tool::Localize
 
       if dict[locale] && trans = dict[locale][str]
         #
-      elsif trans = dict[default_language][str]
+      elsif dict[default_language] && trans = dict[default_language][str]
+        dict[locale] ||= {}
         dict[locale][str] = str
       else
+        dict[locale] ||= {}
+        dict[default_language] ||= {}
         dict[locale][str] = str
         dict[default_language][str] = str
       end
@@ -121,8 +129,8 @@ class Ramaze::Tool::Localize
           fd.write data
         end
       end
-    rescue Errno::ENOENT
-      # bleargh
+    rescue Errno::ENOENT => e
+      Ramaze::Inform.error e
     end
   end
 end