ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/store/default.rb

@@ -1,109 +0,0 @@
-#          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

@@ -1,44 +0,0 @@
-#          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") || {}
-          action.instance.extend ::Amrita2::Runtime if data.kind_of? Binding
-          template.render_with(data)
-        end
-
-        def compile(action, template)
-          ::Amrita2::Template.new(template)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/builder.rb

@@ -1,28 +0,0 @@
-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

@@ -1,35 +0,0 @@
-#          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 ]
-
-      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 = ::Erubis::Eruby.new(template)
-          eruby.init_evaluator(:filename => (action.template || __FILE__))
-          eruby
-        end
-      end
-    end
-  end
-end

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

@@ -1,169 +0,0 @@
-#          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

@@ -1,76 +0,0 @@
-#          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

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

@@ -1,135 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-begin
-  require 'hpricot'
-rescue LoadError => ex
-  Ramaze::Log.error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
-  puts ex
-end
-
-# This applies a morphing-replace for the template.
-#
-# To use the functionality of Morpher you will need to have hpricot
-# installed, you will get one error in case you don't and the method
-# will be replaced by a stub that simply returns the template.
-#
-# The method first checks if you use any morphers and just skips
-# the step if you don't, this should give quite some speedup for
-# smaller templates that don't use this functionality at all.
-# the check works by searching the morphs with appended '='
-# in the template. There may be a few cases where this won't work
-# since we cannot make any assumptions on the format.
-#
-# If you want to turn this functionality off, either remove Morpher
-# from:
-#   Ramaze::Template::Ezamar::TRANSFORM_PIPELINE
-# or do:
-#   Ramaze::Morpher::MORPHS.clear
-#
-# The latter is a tad slower, but i mention the possibility in case you
-# find good use for it.
-#
-# You can add your own morphers in Ramaze::Morpher::MORPHS
-#
-# For Example:
-#
-#   Morpher::MORPHS['if'] = '<?r %morph %expression ?>%content<?r end ?>'
-#
-# Now, assuming that some tag in your template is '<a if="@foo">x</a>'
-#
-# %morph stands for the name of your morph: 'if'
-# %expression is the stuff you write in the attribute: '@foo'
-# %content is the tag without the attribute (and all inside): '<a>x</a>'
-
-class Ezamar::Morpher
-
-  # Use this trait to define your custom morphs.
-  MORPHS = {
-            'if'     => '<?r %morph %expression ?>%content<?r end ?>',
-            'unless' => '<?r %morph %expression ?>%content<?r end ?>',
-            'for'    => '<?r %morph %expression ?>%content<?r end ?>',
-            'each'   => '<?r %expression.%morph do |_e| ?>%content<?r end ?>',
-            'times'  => '<?r %expression.%morph do |_t| ?>%content<?r end ?>',
-  }
-
-  # Since the functionality is best explained by examples, here they come.
-  #
-  # Example:
-  #
-  # if:
-  #   <div if="@name">#@name</div>
-  # morphs to:
-  #   <?r if @name ?>
-  #     <div>#@name</div>
-  #   <?r end ?>
-  #
-  # unless:
-  #   <div unless="@name">No Name</div>
-  # morphs to:
-  #   <?r unless @name ?>
-  #     <div>No Name</div>
-  #   <?r end ?>
-  #
-  # for:
-  #   <div for="name in @names">#{name}</div>
-  # morphs to:
-  #   <?r for name in @names ?>
-  #     <div>#{name}</div>
-  #   <?r end ?>
-  #
-  # times:
-  #   <div times="3">#{_t}<div>
-  # morphs to:
-  #   <?r 3.times do |_t| ?>
-  #     <div>#{_t}</div>
-  #   <?r end ?>
-  #
-  # each:
-  #   <div each="[1,2,3]">#{_e}</div>
-  # morphs to:
-  #   <?r [1,2,3].each do |_e| ?>
-  #     <div>#{_e}</div>
-  #   <?r end ?>
-  #
-  # The latter two examples show you also one standard introduced by a
-  # limitation of the replacement-system.
-  #
-  # When you yield a value, please name it by the first character(s) of
-  # the morphs name, with an underscore prefixed.
-  #
-  # for each an _e, for times a _t.
-  #
-  # This is by far not the best way to handle it and might lead to problems
-  # due to the lack of proper scoping in ruby (if you define an _e or _t
-  # before the block it will be overwritten).
-  #
-  # So please be careful, I tried to come up with something that is both easy
-  # to write and doesn't look outright awful while keeping an easy to remember
-  # mnemonic.
-  #
-  # TODO:
-  #   - Add pure Ruby implementation as a fall-back.
-
-  def self.transform(template)
-    template = template.to_s
-    hp = Hpricot(template)
-
-    MORPHS.each do |morph, replacement|
-      hp.search("[@#{morph}]") do |elem|
-        expr = elem[morph]
-
-        elem.remove_attribute(morph)
-
-        repl = replacement.
-          sub('%morph', morph).
-          sub('%expression', expr).
-          sub('%content', elem.to_html)
-
-        elem.swap(repl)
-      end
-    end
-
-    hp.to_html
-  end
-end

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

@@ -1,31 +0,0 @@
-#          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/template/ezamar/engine'
-require 'ramaze/helper/partial'
-
-module Ezamar
-
-  # A transformer for <render /> tags.
-
-  class RenderPartial
-    extend Ramaze::Helper::Partial
-
-    # 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)
-      template.gsub!(/<render (.*?) \/>/) do |m|
-        args = Hash[*$1.scan(/(\S+)=["'](.*?)["']/).flatten]
-        if src = args.delete('src')
-          render_partial(src, args)
-        end
-      end
-
-      template
-    end
-
-  end
-end

data/lib/ramaze/template/ezamar.rb

@@ -1,42 +0,0 @@
-#          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/template/ezamar/engine'
-require 'ramaze/template/ezamar/render_partial'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Ezamar templating engine.
-
-    class Ezamar < Template
-
-      ENGINES[self] = %w[ xhtml zmr ]
-
-      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
-
-      class << self
-
-        # Transforms an action into the XHTML code for parsing and returns
-        # the result
-        def transform action
-          ezamar = wrap_compile(action)
-          ezamar.result(action.binding)
-        end
-
-        # 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
-
-          ::Ezamar::Template.new(template, :file => file)
-        end
-      end
-    end
-  end
-end