ramaze 0.0.7 → 0.0.8

data/lib/ramaze/snippets/kernel/silently.rb

@@ -1,13 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-module Kernel
-
-  # sets $VERBOSE temporarily to nil so you can redefine constants in peace
-
-  def silently
-    old_verbose, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-end

data/lib/ramaze/snippets/thread/deadQUESTIONMARK.rb

@@ -1,11 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-class Thread
-
-  # check if the thread is not alive (not alive?)
-
-  def dead?
-    not alive?
-  end
-end

data/lib/ramaze/template/haml/actionview_stub.rb

@@ -1,20 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# stub, in case the requires for that active_* stuff of Haml doesn't fail
-# but we are not running Rails ;)
-
-module ActionView
-  class Base
-
-    # stub
-
-    def concat
-    end
-
-    # stub
-
-    def form_tag
-    end
-  end
-end

data/lib/ramaze/template/ramaze.rb

@@ -1,177 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'digest/sha1'
-require 'ramaze/template/ramaze/element'
-require 'ramaze/template/ramaze/morpher'
-
-module Ramaze::Template
-
-  # The usual Template for use of Ramaze.
-  # It supports erb-style interpolation and a pipeline for the transform
-
-  class Ramaze < Template
-
-    # Actions consist of both templates and methods on the controller.
-    trait :actionless => false
-
-    # Usual extensions for templates.
-    trait :template_extensions => %w[rmze xhtml rhtml html]
-
-    # Each Object in this Array will be called :transform upon.
-    trait :transform_pipeline => [ Element, Morpher, self ]
-
-    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.
-
-      def handle_request(action, *params)
-        controller = self.new
-        controller.send(:render, action, *params)
-      end
-
-      # in case someone wants to call directly (pipeline)
-
-      def transform(template, bound)
-        self.new.send(:transform, template, bound)
-      end
-    end
-
-    private
-
-    # render an action
-    # this looks up the file depending on your Global.template_root
-    # and also takes the mapping of the controller in account.
-    # To use the exception of method_missing as flow-control might seem odd,
-    # but it works perfect for method_missing defined in the controller...
-    # otherwise one has to modify respond_to?... maybe add a special take-all method?
-    #
-    # for example:
-    # / => FooController, /main => MainController
-    # an action to /bar would search directly in the template_root for a file called bar
-    # and the extensions rmze, xhtml or html (in that order)
-    # if it finds a file it will transform it and return the result
-    # otherwise nothing happens
-    #
-    # TODO:
-    #   - maybe add some way to define a custom template-file per action via traits
-    #     trait :methodname_template => :foo
-    #     would point to the template-file of action :foo - template_root/foo.ext
-    #   - add extensive tests!
-    #
-
-    def render(action, *params)
-      alternate = render_template(params.last) if params.size == 1 and action == 'index'
-      file_template = render_template(action, *params)
-      ctrl_template = render_action(action, *params)
-
-      pipeline(alternate || file_template || ctrl_template)
-    end
-
-    # Render an action, usually a method on the controller.
-
-    def render_action(action, *params)
-      ctrl_template = send(action, *params).to_s
-    rescue => e
-      Informer.error e unless e.message =~ /undefined method `#{Regexp.escape(action.to_s)}'/
-
-      unless caller.select{|bt| bt[/`render_action'/]}.size > 3
-        Dispatcher.respond_action([action, *params].join('/'))
-        ctrl_template = response.out
-      end
-    end
-
-    # Render the template.
-
-    def render_template(action, *params)
-      File.read(find_template(action)) rescue nil
-    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]
-
-    def pipeline(template)
-      transform_pipeline = ancestral_trait[:transform_pipeline]
-
-      transform_pipeline.inject(template) do |memo, current|
-        current.transform(memo, binding)
-      end
-    end
-
-    # transform a String to a final xhtml
-    #
-    # 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.
-    #
-    # Warning:
-    # the variables used in here have the schema _variable_ to make it harder to break stuff
-    # however, you should take care.
-    # At the time of writing, the variables used are:
-    # _start_heredoc_, _end_heredoc_, _template_, _out_, _file_ and _bufadd_
-    # However, you may reuse _ivs_ if you desperatly need it and just can't live without.
-    #
-
-    def transform(_template_, _binding_ = binding)
-      _start_heredoc_ = "T" << Digest::SHA1.hexdigest(_template_)
-      _start_heredoc_, _end_heredoc_ = "\n<<#{_start_heredoc_}\n", "\n#{_start_heredoc_}\n"
-      _bufadd_ = "_out_ << "
-
-      _file_, _template_ = _template_, File.read(_template_) if File.file?(_template_)
-
-      _template_.gsub!(/<%\s+(.*?)\s+%>/m,
-          "#{_end_heredoc_} \\1; #{_bufadd_} #{_start_heredoc_}")
-      _template_.gsub!(/<\?r\s+(.*?)\s+\?>/m,
-          "#{_end_heredoc_} \\1; #{_bufadd_} #{_start_heredoc_}")
-
-      _template_.gsub!(/<%=\s+(.*?)\s+%>/m,
-          "#{_end_heredoc_} #{_bufadd_} (\\1); #{_bufadd_} #{_start_heredoc_}")
-
-
-      # this one should not be used until we find and solution
-      # that allows for stuff like
-      # #[@foo]!
-      # we just don't allow anything except space or newline
-      # after the expression #[] to make it sane
-      #_template_.gsub!(/#\[(.*?)\]\s*$/) do |m|
-      #  "#{_end_heredoc_} #{_bufadd_} (#{$1}); #{_bufadd_} #{_start_heredoc_}"
-      #end
-
-      _template_ = [_bufadd_, _start_heredoc_, _template_, _end_heredoc_].join(' ')
-      _out_ = eval(*["_out_ = []; #{_template_}; _out_", _binding_, _file_].compact)
-
-      _out_.map! do |line|
-        line.to_s.chomp
-      end
-
-      _template_ = _out_.join.strip
-    rescue Object => ex
-      Informer.error "something bad happened while transformation"
-      Informer.error ex
-      #raise Error::Template, "Problem during transformation for: #{request.request_path}"
-      {ex.message => _template_}.inspect
-    end
-
-  end
-end

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

@@ -1,166 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-
-  # an Element is almost like an Controller, however, instead
-  # of connecting actions to templates it is only used in
-  # Ramaze::Template::Ramaze and can be used inside the
-  # templates of the Controller as a simple wrapper.
-  #
-  # Example:
-  #
-  # Your Element called Page:
-  #
-  #   class Page < Element
-  #     def render
-  #       %{
-  #        <html>
-  #          <h1>
-  #            #{@hash['title']}
-  #          </h1>
-  #          #{content}
-  #        </html>
-  #        }
-  #     end
-  #   end
-  #
-  # and one called SideBar
-  #
-  #   class SideBar < 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 Element
-    extend Ramaze::Helper
-
-    helper :link, :redirect
-
-    attr_accessor :content
-
-    # 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.
-      #
-      # It also sets a instance-variable for you called @hash, which
-      # contains the parameters you gave the <Element> tag.
-      # See above for an example of writing and using them.
-
-      def transform string = '', binding = nil
-        string = string.to_s
-        matches = string.scan(/<([A-Z][a-zA-Z0-9]*)(.*?)?>/)
-
-        matches.each do |(klass, params)|
-          transformer = (params[-1,1] == '/' ? :without : :with)
-          string = send("transform_#{transformer}_content", string, klass)
-        end
-        string
-      end
-
-      # transforms elements like:
-      #   <Page> some content </Page>
-
-      def transform_with_content(string, klass)
-        string.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(string, klass)
-        string.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 set an instance-variable
-      # called @hash to hold the parameters passed to the element.
-      #
-      # Parameters look like:
-      #   <Page foo="true"> bar </Page>
-      #   <Page foo="true" />
-
-      def finish_transform(klass, params, content)
-        instance = constant(klass).new(content) rescue nil
-
-        return unless instance and instance.respond_to?(:render)
-
-        hash = demunge_passed_variables(params)
-        instance.instance_variable_set("@hash", hash)
-
-        instance.render
-      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(string)
-        string.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
-end

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

@@ -1,156 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-
-  # 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::Ramaze.trait[:transform_pipeline]
-  # or do:
-  #   Ramaze::Morpher.trait[:morphs] = {}
-  #
-  # 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.trait[:morphs]
-  #
-  # For Example:
-  #
-  #   Morpher.trait[: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 Morpher
-
-    # Use this trait to define your custom morphs.
-    trait :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, bound = nil
-      morphs =
-        trait[:morphs].map{|k,v| [k.to_s, v.to_s]}.select do |(k,v)|
-        template.to_s.include?("#{k}=")
-        end
-
-      morphs = Hash[*morphs.flatten]
-
-      return template if morphs.empty?
-
-      require 'hpricot'
-
-      hp = Hpricot(template)
-      hp.each_child do |child|
-        if child.elem?
-          morphs.each_pair do |morph, replacement|
-            if expression = child[morph]
-              old = child.to_html
-              child.remove_attribute(morph)
-
-              replacement = replacement.dup.
-                gsub('%morph',      morph).
-                gsub('%expression', expression).
-                gsub('%content',    child.to_html)
-
-              template.gsub!(old, replacement)
-            end
-          end
-        end
-      end
-
-      template
-
-    rescue LoadError => ex
-      error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
-
-      # replace this method with a stub that only returns the template.
-
-      self.class_eval do
-        def self.transform(template, bound = nil)
-          template
-        end
-      end
-
-      template
-    end
-  end
-end