Pistos-ramaze 2008.09

data/lib/ramaze/template/markaby.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'markaby'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Markaby templating engine.
+    # Can be found at: http://code.whytheluckystiff.net/markaby/
+
+    class Markaby < Template
+      include Ramaze::Helper::Methods
+
+      ENGINES[self] = %w[ mab ]
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+          result, file = result_and_file(action)
+
+          result = transform_string(file, action) if file
+          result.to_s
+        end
+
+        # Takes a string and action, instance_evals the string inside a mab
+        # block that gets the instance_variables of the original
+        # action.instance passed.
+
+        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
+            hash.merge! sym => controller.instance_variable_get(iv)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/maruku.rb

@@ -0,0 +1,34 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'maruku'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Ezamar templating engine.
+
+    class Maruku < Template
+
+      ENGINES[self] = %w[ mkd ]
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform(action)
+          maruku = wrap_compile(action)
+          maruku.to_html
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Ezamar::Template
+
+        def compile(action, template)
+          ::Maruku.new(template)
+        end
+      end
+    end
+  end
+end
+

data/lib/ramaze/template/nagoro.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'nagoro'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Nagoro templating engine.
+
+    class Nagoro < Template
+
+      ENGINES[self] = %w[ xhtml nag ]
+
+      PIPES = ::Nagoro::DEFAULT_PIPES.dup
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform action
+          nagoro = wrap_compile(action)
+          file = action.template || action.method
+          nagoro.result(:file => file, :binding => action.binding)
+        end
+
+        # Use file_or_result instead of reaction_or_file
+        def wrap_compile(action, template = nil)
+          template ||= file_or_result(action)
+          caching_compile(action, template)
+        end
+
+        def file_or_result(action)
+          result = render_method(action).to_s
+
+          if file = action.template
+            return File.new(file)
+          end
+
+          result
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Nagoro::Template
+
+        def compile(action, template)
+          ::Nagoro.compile(template)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/none.rb

@@ -0,0 +1,14 @@
+#          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 Template
+
+      class None < Template
+        def self.transform action
+          render_method(action)
+        end
+      end
+
+  end
+end

data/lib/ramaze/template/redcloth.rb

@@ -0,0 +1,25 @@
+require 'redcloth'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the RedCloth templating engine.
+    # Can be found at: http://whytheluckystiff.net/ruby/redcloth/
+
+    class RedCloth < Erubis
+      ENGINES[self] = %w[ redcloth ]
+
+      class << self
+        # Take the action and directly transform it into html by RedCloth
+        def transform(action)
+          restrictions = action.controller.trait[:redcloth_options] || []
+          rules = action.controller.trait[:redcloth_options] || []
+
+          # Erubis -> RedCloth -> HTML
+          redcloth = ::RedCloth.new(super, restrictions)
+          redcloth.to_html(*rules)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/remarkably.rb

@@ -0,0 +1,38 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'remarkably/engines/html'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Remarkably templating engine.
+    # Can be found at: http://rubyforge.org/projects/remarkably
+
+    class Remarkably < Template
+      ENGINES[self] = %w[ rem ]
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+          result, file = result_and_file(action)
+
+          result = transform_string(file, action) if file
+          result.to_s
+        end
+
+        # 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(string)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/sass.rb

@@ -0,0 +1,37 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'sass/engine'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Sass CSS templating engine.
+    # Can be found at: http://haml.hamptoncatlin.com/
+
+    class Sass < Template
+
+      ENGINES[self] = %w[ sass ]
+
+      class << self
+
+        # Transform via Sass templating engine
+
+        def transform action
+          if response = Response.current
+            response['Content-Type'] = "text/css"
+          end
+          sass = wrap_compile(action)
+          sass.to_css()
+        end
+
+        # Instantiates Sass::Engine with the template and sass_options trait from
+        # the controller.
+
+        def compile(action, template)
+          ::Sass::Engine.new(template, action.controller.trait[:sass_options] || {})
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/tagz.rb

@@ -0,0 +1,79 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require "tagz"
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Tagz templating engine.
+    # Can be found at: http://rubyforge.org/projects/codeforpeople/
+    #   gem install tagz
+    # be sure you get version 1.0 or higher
+
+    class Tagz < Template
+      ENGINES[self] = %w[ rb tagz ]
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+          result, file = result_and_file(action)
+          if file
+            markup = "tagz{#{ file }}"
+            action.instance.extend Methods
+            result = eval markup, action.binding, file
+          end
+          result
+        end
+
+      end
+
+      # Methods defines a host of methods useful inside the context of a view
+      # including print style methods that output content rather that printing to
+      # STDOUT
+
+      module Methods
+        include ::Tagz
+
+      private
+        def << s
+          tagz << s; self
+        end
+
+        def concat *a
+          a.each{|s| tagz << s}; self
+        end
+
+        def puts *a
+          a.each{|elem| tagz << "#{ elem.to_s.chomp }#{ eol }"}
+        end
+
+        def print *a
+          a.each{|elem| tagz << elem}
+        end
+
+        def p *a
+          a.each{|elem| tagz << "#{ Rack::Utils.escape_html elem.inspect }#{ eol }"}
+        end
+
+        def pp *a
+          a.each{|elem| tagz << "#{ Rack::Utils.escape_html PP.pp(elem, '') }#{ eol }"}
+        end
+
+        def eol
+          if response.content_type =~ %r|text/plain|io
+            "\n"
+          else
+            "<br />"
+          end
+        end
+
+        def __ *a
+          concat eol
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/tenjin.rb

@@ -0,0 +1,74 @@
+require "tenjin"
+require "tempfile"
+
+# Tenjin does not work with a Binding, so helpers included by the controller
+# will not be automatically available in templates. Instead we add support
+# for popular helpers to its internal Context class to make them available.
+class Tenjin::Context
+  include Ramaze::Helper::Methods
+  helper :link, :sendfile, :flash, :cgi
+end
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Tenjin templating engine.
+    # Can be found at: http://www.kuwata-lab.com/tenjin/
+    #
+    # Instance variables in your action method are automatically available in
+    # the template:
+    #
+    #  class MainController < Ramaze::Controller
+    #    engine :Tenjin
+    #    def index
+    #      @names = ['Alice', 'Bob', 'Charlie']
+    #      @greeting = 'Hello'
+    #      %q{
+    #      <html><body>
+    #        <h1><?rb for name in @names ?><p>#{@greeting} #{name}</p><?rb end ?></h1>
+    #      </body></html>
+    #      }
+    #    end
+    #  end
+    #
+    # Note that only instance vars are available and methods (including helper methods)
+    # are not available in the template. A few common helpers are made generally available
+    # though by virtue of the modifications to Tenjin::Context at the top of this file.
+
+    class Tenjin < Template
+
+      ENGINES[self] = %w[ rbhtml tenjin ]
+
+      class << self
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result.
+        def transform(action)
+          tenjin = wrap_compile(action)
+          # Tenjin can't deal with a Binding so we construct a hash for it.
+          tenjin.render(context(action))
+        end
+
+        # Return a hash of all instance variables from the action.
+        # For each instance var @foo, we put :foo => @foo in the hash.
+        def context action
+          hash = {}
+          action_binding = action.binding
+          var_names = action.instance.instance_variables
+          var_names.each do |var_name|
+            # Strip the @ from the front of the var name to use as hash key,
+            # then simply use the value of the instance var as the hash value.
+            hash[var_name[1..-1]] = eval(var_name, action_binding)
+          end
+          hash
+        end
+
+        # Compile a template, returning an instance of ::Tenjin::Template.
+        def compile(action, template)
+          tenjin = ::Tenjin::Template.new
+          tenjin.convert(template)
+          return tenjin
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/xslt.rb

@@ -0,0 +1,100 @@
+#          Copyright (c) 2007  Stephan Maka  stephan@spaceboyz.net
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'xml/libxml'
+require 'xml/xslt'
+require 'thread'
+
+module Ramaze
+
+  # Use the Gestalt helper to put your controller result
+  # into proper XML form
+  #
+  # TODO:
+  # * Error handling
+  # * Maybe prevent extFunction to be called by HTTP
+  module Template
+    class XSLT < Template
+      ENGINES[self] = %w[ xsl ]
+
+      XSLT_EXT_FUNCTIONS_LOCK = Mutex.new
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+
+          if options = action.instance.ancestral_trait[:xslt_options] and
+              fun_xmlns = options[:fun_xmlns]
+            # If a controller uses extFunctions, lock the whole
+            # transform action with a Mutex to prevent mixing
+            # extFunction binding and callback of two controller
+            # instances with one fun_xmlns.
+            ext_functions_synchronize do
+              register_ext_functions action.instance, fun_xmlns
+              do_transform action
+            end
+
+          else
+            do_transform action
+          end
+
+        end
+
+        private
+
+        # further abstraction for the transform
+        def do_transform(action)
+          result, file = result_and_file(action)
+
+          xslt = XML::XSLT.new
+          xslt.xsl = action.template
+          xslt.xml = result
+          xslt.serve
+        end
+
+        # Synchronize the block to run with the mutex
+        def ext_functions_synchronize(&block)
+          XSLT_EXT_FUNCTIONS_LOCK.synchronize(&block)
+        end
+
+        # Expose functors
+        def register_ext_functions instance, fun_xmlns
+
+          instance.methods.each do |method|
+            if method =~ /^xslt_.+/
+              method_name = method[5..-1]
+
+              proxy_instance = make_functor(method_name.intern) { |*a|
+                instance.send method.intern, *a
+              }
+
+              XML::XSLT.extFunction method_name.gsub('_', '-'), fun_xmlns, proxy_instance
+            end
+          end
+
+        end
+
+        # Can be replaced by Ruby Facets' Functor pattern
+        def make_functor(m, &block)
+          # Create anonymous class and instantiate;
+          # anonymous because only this one object with this
+          # particular custom method should call &block
+          o = Class.new.new
+
+          class << o
+            # Delayed creation of method
+            def create_method(name, &block)
+              self.class.send(:define_method, name, &block)
+            end
+          end
+
+          o.create_method(m, &block)
+          o
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/template.rb

@@ -0,0 +1,87 @@
+#          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/create.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/tool/project_creator'
+
+module Ramaze
+  module Tool
+
+    # Create is a simple class used to create new projects based on the proto
+    # directory.
+    #
+    # It is primarly used for this command:
+    #
+    #   ramaze --create project
+    #
+    # where project is the directory you want the content put into.
+
+    class Create
+
+      # Default options passed to Create::create
+      #   :proto  is the directory to duplicate
+      #   :amend  no files may be overwritten but missing files will be added
+      #   :force  will overwrite existing files
+      #   :layout copy one subdirectory in +proto+
+
+      DEFAULT = {
+        :proto => File.join(::Ramaze::BASEDIR, 'proto'),
+        :amend => false,
+        :force => false,
+        :layout => '/',
+      }
+
+      # Using ProjectCreator to copy all files and directories from lib/proto
+      # to another location.
+      # +options+ are described in the DEFAULT constant and should be:
+      #   :force  => (true|false|nil)
+      #   :amend  => (true|false|nil)
+      #   :layout => (String|nil)
+      #   :proto  => String
+
+      def self.create(project, options = {})
+        options = DEFAULT.merge(options)
+        creator = ProjectCreator.new(project, options)
+        creator.create
+      end
+    end
+  end
+end

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