ptomato-ramaze 2009.02

data/lib/ramaze/spec.rb

@@ -0,0 +1 @@
+require 'ramaze/spec/helper'

data/lib/ramaze/store/default.rb

@@ -0,0 +1,109 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'yaml/store'
+
+module Ramaze
+
+  # Namespace for Stores in Ramaze
+
+  module Store
+
+    # A simple wrapper around YAML::Store
+
+    class Default
+      include Enumerable
+
+      attr_accessor :db
+
+      # create a new store with a filename
+
+      def initialize filename = 'db.yaml'
+        FileUtils.touch(filename)
+        @db = YAML::Store.new(filename)
+      end
+
+      # yield a block in a transaction, identical to #db.transaction{}
+
+      def transaction
+        @db.transaction do
+          yield
+        end
+      end
+
+      # pass on all methods inside a transaction
+
+      def method_missing(meth, *args, &block)
+        read_only = (meth == :[])
+
+        @db.transaction(read_only) do
+          @db.send(meth, *args, &block)
+        end
+      end
+
+      # the actual content of the store in YAML format
+
+      def to_yaml
+        dump(:x)
+      end
+
+      # loads the #to_yaml
+
+      def original
+        YAML.load(to_yaml)
+      end
+
+      # available keys of the store
+
+      def keys
+        (original || {}).keys
+      end
+
+      # is the Store empty? (no keys)
+
+      def empty?
+        keys.empty?
+      end
+
+      # nondestructive merge on #original
+
+      def merge hash = {}
+        original.merge(hash)
+      end
+
+      # destructive #merge
+
+      def merge! hash = {}
+        hash.each do |key, value|
+          transaction do
+            @db[key] = value
+          end
+        end
+
+        original
+      end
+
+      # delete all entries
+
+      def clear
+        keys.each do |key|
+          delete key
+        end
+      end
+
+      # number of #keys
+
+      def size
+        keys.size
+      end
+
+      # Iterate over #original and pass the key and value to a block.
+
+      def each
+        original.each do |key, value|
+          yield key, value
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/amrita2.rb

@@ -0,0 +1,49 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'amrita2'
+
+class Amrita2::Template
+
+  # Ramaze helpers are available in template contexts.
+
+  include Ramaze::Helper::Methods
+  helper :link, :sendfile, :flash, :cgi
+end
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Amrita2 templating engine.
+    # Can be found at: http://rubyforge.org/projects/amrita2
+
+    class Amrita2 < Template
+
+      ENGINES[self] = %w[ amrita amr a2html ]
+
+      class << self
+
+        # Takes an Action
+        # The result or file is rendered using Amrita2::Template.
+        #
+        # The context data are set to @data in the controller before expansion.
+
+        def transform(action)
+          template = wrap_compile(action)
+
+          data = action.instance.instance_variable_get("@data") || {}
+          binding = action.instance.instance_variable_get("@binding")
+
+          action.instance.extend(::Amrita2::Runtime)
+
+          template.render_with(data, binding)
+        end
+
+        # Compile a template, return instance of Amrita2::Template
+        def compile(action, template)
+          ::Amrita2::Template.new(template)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/builder.rb

@@ -0,0 +1,28 @@
+require 'builder'
+
+module Ramaze
+  module Template
+
+      class Builder < Template
+        ENGINES[self] = %w[ builder rxml ]
+
+        class << self
+          def transform action
+            if response = Response.current
+              response['Content-Type'] = "application/xml"
+            end
+
+            template = wrap_compile(action)
+            action.instance.instance_eval(template, action.template || __FILE__)
+          end
+
+          def compile action, template
+            "xml = ::Builder::XmlMarkup.new(:indent => 2)\n" +
+            template +
+            "\nxml.target!\n"
+          end
+        end
+      end
+
+  end
+end

data/lib/ramaze/template/erubis.rb

@@ -0,0 +1,41 @@
+#          Copyright (c) 2008 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 Template
+
+    # Is responsible for compiling a template using the Erubis templating engine.
+    # Can be found at: http://rubyforge.org/projects/erubis
+
+    class Erubis < Template
+
+      ENGINES[self] = %w[ rhtml ]
+
+      # Allow for swapping in a differnt Erubis engine (it supplies several) and
+      # passing options to the engine.
+      trait[:engine] ||= ::Erubis::Eruby
+      trait[:options] ||= {}
+
+      class << self
+
+        # Entry-point for Action#render
+
+        def transform action
+          eruby = wrap_compile(action)
+          eruby.result(action.binding)
+        end
+
+        # Creates an instance of ::Erubis::Eruby, sets the filename
+        # from the template and returns the instance.
+
+        def compile(action, template)
+          eruby = ancestral_trait[:engine].new(template, ancestral_trait[:options])
+          eruby.init_evaluator(:filename => (action.template || __FILE__))
+          eruby
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# an Element is almost like an Controller, however, instead
+# of connecting actions to templates it is only used in
+# Ramaze::Template::Ezamar and can be used inside the
+# templates of the Controller as a simple wrapper.
+#
+# Example:
+#
+# Your Element called Page:
+#
+#   class Page < Ezamar::Element
+#     def render
+#       %{
+#        <html>
+#          <h1>
+#            #@title
+#          </h1>
+#          #{content}
+#        </html>
+#        }
+#     end
+#   end
+#
+# and one called SideBar
+#
+#   class SideBar < Ezamar::Element
+#     def render
+#       %{
+#         <a href="http://something.com">something</a>
+#        }
+#      end
+#    end
+#
+# and your template (any template for any action):
+#
+#   <Page title="Test">
+#     <SideBar />
+#     <p>
+#       Hello, World!
+#     </p>
+#   </Page>
+#
+# would result in:
+#
+#   <html>
+#     <h1>
+#       Test
+#     </h1>
+#     <p>
+#       Hello, World!
+#     </p>
+#   </html>
+
+class Ezamar::Element
+  attr_accessor :content
+
+  include Ramaze::Helper::Methods
+
+  helper :redirect, :link
+
+  # this will be called by #transform, passes along the
+  # stuff inside the tags for the element
+
+  def initialize(content)
+    @content = content
+  end
+
+  # The method that will be called upon to render the things
+  # inside the element, you can access #content from here, which
+  # contains the contents between the tags.
+  #
+  # It should answer with a String.
+
+  def render *args
+    @content
+  end
+
+  class << self
+    # transforms all <Element> tags within the string, takes also
+    # a binding to be compatible to the transform-pipeline, won't have
+    # any use for it though.
+
+    def transform template
+      matches = template.scan(/<([A-Z][a-zA-Z0-9]*)(.*?)?>/)
+
+      matches.each do |(klass, params)|
+        transformer = (params[-1,1] == '/' ? :without : :with)
+        template = send("transform_#{transformer}_content", template, klass)
+      end
+      template
+    end
+
+    # transforms elements like:
+    #   <Page> some content </Page>
+
+    def transform_with_content(template, klass)
+      template.gsub(/<#{klass}( .*?)?>(.*?)<\/#{klass}>/m) do |m|
+        params, content = $1.to_s, $2.to_s
+        finish_transform(klass, params, content)
+      end
+    end
+
+    # transforms elements like:
+    #   <Page />
+
+    def transform_without_content(template, klass)
+      template.gsub(/<#{klass}( .*?)?\/>/) do |m|
+        params = $1.to_s
+        finish_transform(klass, params, content = '')
+      end
+    end
+
+    # find the element, create an instance, pass it the content
+    # check if it responds to :render and sets instance-variables
+    # that are named after the keys and hold the values of the parameters
+    # you passed to the Element
+    #
+    # Parameters look like:
+    #   <Page foo="true"> bar </Page>
+    #   <Page foo="true" />
+
+    def finish_transform(klass, params, content)
+      scope =
+        if Ramaze::Action.current
+          Ramaze::Action.current.controller
+        else
+          self.class
+        end
+      instance = scope.constant(klass).new(content)
+
+      demunge_passed_variables(params).each do |key, value|
+        instance.instance_variable_set("@#{key}", value)
+      end
+
+      instance.render
+    rescue => ex
+      Ramaze::Log.debug(ex.message)
+      ''
+    end
+
+    # basically processes stuff like
+    #   'foo="bar" foobar="baz"'
+    # do NOT pass actual objects that cannot be simply read as a string
+    # here, the information will be lost.
+    #
+    # Exceptions are true, false, Integers and Floats. They will appear
+    # in their real form (this again is also valid for strings that contain
+    # these values in a way that makes Integer/Float possible to parse them)
+    #
+    # Just remember, walk like a duck, talk like a duck.
+
+    def demunge_passed_variables(template)
+      template.scan(/\s?(.*?)=["'](.*?)["']/).inject({}) do |hash, (key, value)|
+        value =
+          case value
+          when 'true'
+            true
+          when 'false'
+            false
+          else
+            Integer(value) rescue Float(value) rescue value
+          end
+        hash.merge key => value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'digest/sha1'
+
+# Ezamar is a very simple (and at no means complete) reimplementation of the
+# Templating-engine found in Nitro.
+#
+# Since Nitros templating is based on REXML and Ezamar is not there are vast
+# differences, but it tries to keep the look and feel as close as possible.
+
+module Ezamar
+
+  require 'ramaze/template/ezamar/element'
+
+  # This class is responsible for initializing and compiling the template.
+
+  class Template
+
+    # Take a template (anything that responds to ::to_str) and options.
+    # At the moment the only option used is :file, which is used to tell
+    # Kernel::eval how to produce better backtraces.
+
+    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}")
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m,
+            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
+      temp.gsub!(/<%=\s*(.*?)\s*%>/m,
+            "#{end_heredoc} #{bufadd} (\\1); #{bufadd} #{start_heredoc}")
+
+      @compiled = "_out_ = ''
+      #{bufadd} #{start_heredoc} #{temp} #{end_heredoc}
+      _out_"
+    end
+
+    # Takes a binding and evals it with the previously set options.
+
+    def result(binding)
+      eval(@compiled, binding, @options[:file]).strip
+    end
+  end
+end