ramaze 2009.03 → 2009.04

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.rb

@@ -1 +1,34 @@
-require 'ramaze/spec/helper'
+begin; require 'rubygems'; rescue LoadError; end
+
+require(File.expand_path("#{__FILE__}/../")) unless defined?(Ramaze)
+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 :mock do
+  Ramaze.setup_dependencies
+  extend Rack::Test::Methods
+
+  def app; Ramaze.middleware; end
+end

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/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) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
 module Ramaze
-  VERSION = "2009.03"
+  VERSION = "2009.04"
 end

data/lib/ramaze/view.rb

@@ -0,0 +1,48 @@
+#          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
+
+  # This is a container module for wrappers of templating engines and handles
+  # lazy requiring of needed engines.
+
+  module View
+    extend Innate::View
+
+    def self.get(*args)
+      Innate::View.get(*args)
+    end
+
+    # Combine Kernel#autoload and Innate::View::register
+
+    def self.auto_register(name, *exts)
+      autoload(name, "ramaze/view/#{name}".downcase)
+      register("Ramaze::View::#{name}", *exts)
+    end
+
+    # TODO:
+    # * markaby - though we should advertise remarkably instead
+    # * XSLT    - this one is just crazy, someone up for the task?
+
+    # Engines provided by Innate are:
+    # ERB, Etanni, None
+
+    auto_register :Erubis,     :erubis, :rhtml
+    auto_register :Ezamar,     :zmr
+    auto_register :Haml,       :haml
+    auto_register :Liquid,     :liquid
+    auto_register :Maruku,     :mkd, :md
+    auto_register :Nagoro,     :nag
+    auto_register :RedCloth,   :redcloth
+    auto_register :Sass,       :sass
+    auto_register :Tenjin,     :rbhtml, :tenjin
+    auto_register :Remarkably, :rem
+    auto_register :Tagz,       :rb, :tagz
+  end
+end
+
+module Innate
+  module View
+    include Ramaze::View
+  end
+end

data/lib/ramaze/view/erubis.rb

@@ -0,0 +1,23 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'erubis'
+
+module Ramaze
+  module View
+    module Erubis
+      OPTIONS = { :engine => ::Erubis::Eruby }
+
+      def self.call(action, string)
+        options = OPTIONS.dup
+        engine = options.delete(:engine)
+
+        eruby = engine.new(string, options)
+        eruby.init_evaluator(:filename => (action.view || __FILE__))
+        html = eruby.result(action.binding)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/ezamar.rb

@@ -0,0 +1,23 @@
+require 'ezamar'
+
+module Ramaze
+  module View
+    module Ezamar
+      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
+
+      def self.call(action, string)
+        template = compile(action, string)
+        html = template.result(action.binding)
+        return html, 'text/html'
+      end
+
+      def self.compile(action, template)
+        file = action.view || __FILE__
+
+        TRANSFORM_PIPELINE.each{|tp| template = tp.transform(template) }
+
+        ::Ezamar::Template.new(template, :file => file)
+      end
+    end
+  end
+end

data/lib/ramaze/view/haml.rb

@@ -0,0 +1,16 @@
+require 'haml/util'
+require 'haml/engine'
+
+module Ramaze
+  module View
+    module Haml
+      def self.call(action, string)
+        action.options[:filename] = (action.view || '(haml)')
+        haml = ::Haml::Engine.new(string.to_s, action.options)
+        html = haml.to_html(action.instance, action.variables)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/liquid.rb

@@ -0,0 +1,100 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'liquid'
+
+module Ramaze
+  module View
+    # Liquid is a smarty-style templating engine that restricts the usage of
+    # code inside templates. This is mostly helpful if you want to let users
+    # submit templates but prevent them from running arbitrary code.
+    #
+    # Liquid offers a pipe-like syntax for chaining operations on objects.
+    # Any instance variable from your Controller is available as a variable
+    # inside Liquid, so be sensitive about what data you provide.
+    #
+    # If you want to allow partials you can provide a kind of virtual
+    # filesystem that contains partials. These can be rendered using the
+    # Liquid `{% include 'name' %}` tag. The include tag has no relation to the
+    # Ramaze::Helper::Render, it simply inlines the file.
+    #
+    # To tell Liquid where to find partials, you have to set the file_system.
+    # The naming-convention for liquid-partials is to use a '_' prefix to the
+    # filename and the '.liquid' filename extension. The names of partials
+    # are restricted to ASCII alpha-numeric characters and underscores. You
+    # can also use '/' to use templates located in deeper directories.
+    # The partial has access to the same variables as the template including
+    # it.
+    #
+    # @example setting file_system
+    #   template_path = './partials/'
+    #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+    #
+    # @example using include
+    #   {% include 'foo' %}
+    #   {% include 'bar/foo' %}
+    #
+    # This will include the files located at './partials/_foo.liquid' and
+    # './partials/bar/_foo.liquid'.
+    #
+    # This functionality gets even more interesting if you customize it with
+    # your own virtual file-system, you can use anything that responds to
+    # `#read_template_file(path)`.
+    # That way you can even fetch templates from a database or instruct Liquid
+    # to allow you access to your own templates in the '/views' directory.
+    module Liquid
+
+      # Liquid requires the variable keys to be strings, most likely for
+      # security resons (don't allow arbitrary symbols).
+      def self.call(action, string)
+        action.sync_variables(action)
+        variables = {}
+        action.variables.each{|k,v| variables[k.to_s] = v }
+
+        template = ::Liquid::Template.parse(string.to_s)
+        html = template.render(variables)
+
+        return html, 'text/html'
+      end
+
+      class Tag < ::Liquid::Tag
+        def initialize(tag_name, arg, tokens)
+          super
+          @arg = arg.strip
+        end
+      end
+
+      # Liquid has intentionally? no support for binding, in order to use
+      # helpers you have to register them as tags.
+      #
+      # Creating a tag needs boilerplate, so we reduce that for your
+      # convenience.
+      #
+      # This is not the most performant way, it seems like Liquid uses
+      # initialize to compile templates and gives you the chance to process the
+      # arguments to the tag only once, but if you want that please contribute.
+      #
+      # Further below are a couple of tags that map to the most common helpers,
+      # this also needs contribution as I simply don't have the time to write
+      # all of that and invent a consistent syntax.
+      def self.register_tag(name, helper, &block)
+        klass = Class.new(Tag)
+        klass.send(:include, helper)
+        klass.send(:define_method, :render, &block)
+
+        ::Liquid::Template.register_tag(name, klass)
+      end
+
+      # {% route index %}
+      register_tag('route', Ramaze::Helper::Link) do |context|
+        Ramaze::Current.action.node.route(@arg)
+      end
+
+      # {% anchor "The index" index %}
+      register_tag('anchor', Ramaze::Helper::Link) do |context|
+        @arg =~ /^(['"])(.*?)\1\s+(.*)/
+        Ramaze::Current.action.node.anchor($2, $3)
+      end
+    end
+  end
+end

data/lib/ramaze/view/maruku.rb

@@ -0,0 +1,14 @@
+require 'maruku'
+
+module Ramaze
+  module View
+    module Maruku
+      def self.call(action, string)
+        string = File.read(action.view) if action.view
+        html = ::Maruku.new(string).to_html
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/nagoro.rb

@@ -0,0 +1,44 @@
+require 'nagoro'
+require 'ramaze/view/nagoro/render_partial'
+
+module Ramaze
+  module View
+    # Binding to the Nagoro templating engine.
+    #
+    # To pipe your template through tidy you have to use:
+    #
+    #   Ramaze::View::Nagoro.options.tidy = true
+    #
+    # @see http://github.com/manveru/nagoro
+    module Nagoro
+      include Optioned
+
+      options.dsl do
+        o "Pipes to pass the template through",
+          :pipes, ::Nagoro::DEFAULT_PIPES
+
+        o "Use tidy to cleanup the rendered template",
+          :tidy, false
+      end
+
+      def self.call(action, string)
+        default_options = {
+          :pipes     => options.pipes,
+          :filename  => action.view,
+          :binding   => action.binding,
+          :variables => action.variables
+        }
+
+        render_options = default_options.merge(action.options)
+
+        if options.tidy
+          html = ::Nagoro.tidy_render(string.to_s, render_options)
+        else
+          html = ::Nagoro.render(string.to_s, render_options)
+        end
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/nagoro/render_partial.rb

@@ -0,0 +1,32 @@
+require 'innate/helper/render'
+
+module Nagoro
+  module Pipe
+    # Pipe that transforms <render /> tags.
+    #
+    # the src parameter in the render tag will be used as first parameter to
+    # render_partial, all other paramters are passed on as +variables+.
+    #
+    # Example calling render_partial('hello'):
+    #   <render src="hello" />
+    #
+    # Example calling render_partial('hello', 'tail' => 'foo'):
+    #   <render src="hello" tail="foo" />
+    #
+    class RenderPartial < Base
+      include Innate::Helper::Render
+
+      def tag_start(tag, attrs)
+        if tag == 'render' and action_name = attrs.delete('src')
+          append(render_partial(action_name, attrs))
+        else
+          super
+        end
+      end
+
+      def tag_end(tag)
+        super unless tag == 'render'
+      end
+    end
+  end
+end

data/lib/ramaze/view/redcloth.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'redcloth'
+
+module Ramaze
+  module View
+    module RedCloth
+      def self.call(action, string)
+        restrictions = action.variables[:redcloth_options] || []
+        rules        = action.variables[:redcloth_options] || []
+
+        erubis, _ = Ramaze::View::Erubis.call(action, string)
+        redcloth = ::RedCloth.new(erubis, restrictions)
+        html = redcloth.to_html(*rules)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end