hobo 1.0.3 → 1.1.0.pre0

data/lib/hobo/dryml/template_handler.rb

@@ -1,187 +0,0 @@
-module Hobo::Dryml
-
-  class TemplateHandler < ActionView::TemplateHandler
-    
-    def compile(*args)
-      # Ignore - we handle compilation ourselves
-    end
-    
-    # Pre Rails 2.2
-    def render(template)
-      renderer = Hobo::Dryml.page_renderer_for_template(@view, template.locals.keys, template)
-      this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || template.locals[:this])
-      s = renderer.render_page(this, template.locals)
-      # Important to strip whitespace, or the browser hangs around for ages (FF2)
-      s.strip
-    end
-    
-    def render_for_rails22(template, view, local_assigns)
-      renderer = Hobo::Dryml.page_renderer_for_template(view, local_assigns.keys, template)
-      this = view.controller.send(:dryml_context) || local_assigns[:this]
-      @view._?.instance_variable_set("@this", this)
-      s = renderer.render_page(this, local_assigns)
-
-      # Important to strip whitespace, or the browser hangs around for ages (FF2)
-      s.strip
-    end
-
-  end
-
-end
-
-module ActionController
-
-  class Base
-
-    def dryml_context
-      @this
-    end
-
-    def dryml_fallback_tag(tag_name)
-      @dryml_fallback_tag = tag_name
-    end
-
-
-    def call_dryml_tag(tag, options={})
-      @template.send(:_evaluate_assigns_and_ivars)
-
-      # TODO: Figure out what this bit is all about :-)
-      if options[:with]
-        @this = options[:with] unless options[:field]
-      else
-        options[:with] = dryml_context
-      end
-
-      Hobo::Dryml.render_tag(@template, tag, options)
-    end
-
-
-    # TODO: This is namespace polution, should be called render_dryml_tag
-    def render_tag(tag, attributes={}, options={})
-      text = call_dryml_tag(tag, attributes)
-      text && render({:text => text, :layout => false }.merge(options))
-    end
-    
-    # DRYML fallback tags -- monkey patch this method to attempt to render a tag if there's no template
-    def render_for_file_with_dryml(template, status = nil, layout = nil, locals = {})
-      # in rails 2.2, "template" is actually "template_path"
-      
-      # if we're passed a MissingTemplateWrapper, see if there's a
-      # dryml tag that will render the page
-      if template.respond_to? :original_template_path
-        # this is the Rails 2.3 path
-        tag_name = @dryml_fallback_tag || "#{File.basename(template.original_template_path).dasherize}-page"
-        
-        text = call_dryml_tag(tag_name)
-        if text
-          return render_for_text(text, status)
-        else
-          template.raise_wrapped_exception
-        end
-      else
-        begin
-          result = render_for_file_without_dryml(template, status, layout, locals)
-        rescue ActionView::MissingTemplate => ex
-          # this is the Rails 2.2 path
-          tag_name = @dryml_fallback_tag || "#{File.basename(template).dasherize}-page"
-          
-          text = call_dryml_tag(tag_name)
-          if text
-            return render_for_text(text, status)
-          else
-            raise ex
-          end
-        end
-      end
-    end
-    alias_method_chain :render_for_file, :dryml
-      
-  end
-end
-
-class ActionView::Template
-  
-  def render_with_dryml(view, local_assigns = {})
-    if handler == Hobo::Dryml::TemplateHandler
-      render_dryml(view, local_assigns)
-    else
-      render_without_dryml(view, local_assigns)
-    end
-  end
-  alias_method_chain :render, :dryml
-  
-  # We've had to copy a bunch of logic from Renderable#render, because we need to prevent Rails
-  # from trying to compile our template. DRYML templates are each compiled as a class, not just a method,
-  # so the support for compiling templates that Rails provides is innadequate.
-  def render_dryml(view, local_assigns = {})
-    if view.instance_variable_defined?(:@_render_stack)
-      # Rails 2.2
-      stack = view.instance_variable_get(:@_render_stack)
-      stack.push(self)
- 
-      # This is only used for TestResponse to set rendered_template
-      unless is_a?(ActionView::InlineTemplate) || view.instance_variable_get(:@_first_render)
-        view.instance_variable_set(:@_first_render, self)
-      end
-
-      view.send(:_evaluate_assigns_and_ivars)
-      view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
- 
-      result = Hobo::Dryml::TemplateHandler.new.render_for_rails22(self, view, local_assigns)
- 
-      stack.pop
-      result
-    else
-      # Rails 2.3      
-      compile(local_assigns)
-
-      view.with_template self do
-        view.send(:_evaluate_assigns_and_ivars)
-        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
-        
-        Hobo::Dryml::TemplateHandler.new.render_for_rails22(self, view, local_assigns)      
-      end
-    end
-  end
-  
-end
-
-# this is only used in Rails 2.3
-class MissingTemplateWrapper
-  attr_reader :original_template_path
-  
-  def initialize(exception, path)
-    @exception = exception
-    @original_template_path = path
-  end
-
-  def method_missing(*args)
-    raise @exception
-  end
-
-  def render
-    raise @exception
-  end
-end
-  
-    
-module ActionView
-  class PathSet < Array
-    # this is only used by Rails 2.3
-    def find_template_with_dryml(original_template_path, format = nil, html_fallback = true)
-      begin
-        find_template_without_dryml(original_template_path, format, html_fallback)
-      rescue ActionView::MissingTemplate => ex
-        # instead of throwing the exception right away, hand back a
-        # time bomb instead.  It'll blow if mishandled...
-        return MissingTemplateWrapper.new(ex, original_template_path)
-      end
-    end
-
-    if method_defined? "find_template"
-      # only rails 2.3 has this function
-      alias_method_chain :find_template, :dryml
-    end
-  end
-end
-        

data/lib/hobo/static_tags

@@ -1,98 +0,0 @@
-abbr
-acronym
-address
-applet
-article
-audio
-b
-basefont
-bdo
-big
-blockquote
-body
-button
-canvas
-caption
-center
-cite
-code
-colgroup
-command
-datagrid
-datalist
-dd
-del
-details
-dfn
-dialog
-dir
-div
-dl
-dt
-em
-embed
-fieldset
-figure
-font
-frameset
-h1
-h2
-h3
-h4
-h5
-h6
-head
-hgroup
-i
-iframe
-ins
-isindex
-kbd
-label
-legend
-li
-map
-mark
-menu
-meter
-nav
-noframes
-noscript
-object
-ol
-optgroup
-option
-output
-p
-pre
-progress
-q
-rp
-rt
-ruby
-s
-samp
-script
-select
-small
-source
-span
-strike
-strong
-style
-sub
-sup
-tbody
-td
-textarea
-tfoot
-th
-thead
-time
-title
-tr
-tt
-u
-ul
-var
-video

data/taglibs/core.dryml

@@ -1,104 +0,0 @@
-<!-- Core DRYML tags. These are included implicitly and are always available. Contains mainly control-flow tags. -->
-
-<!-- Call the tag given by the `tag` attribute. This lets you call tags dynamically based on some runtime value.
-  It's the DRYML equivalent of Ruby's `send` method.
--->
-<def tag="call-tag" attrs="tag">
-  <%= send(tag.gsub('-', '_'), attributes, parameters) %>
-</def>
-
-
-<!-- Wrap the body in the tag specified by the `tag` attribute, iff `when` is true.
-
-Using regular DRYML conditional logic it is rather akward to conditionally wrap some tag in another tag. This tag makes it easy to do that.
-
-### Usage
-
-For example, you might want to wrap an `<img>` tag in an `<a>` tag but only under certain conditions. Say the current context has an `href` attribute that may or may not be nil. We want to wrap the img in `<a>` if `href` is not nil:
-  
-    <wrap when="&this.href.present?" tag="a" href="&this.href"><img src="&this.img_filename"/></wrap>
-{: .dryml}  
--->
-<def tag="wrap" attrs="tag, when, parameter">
-  <% parameter ||= :default %>
-  <%= when_ ? send(tag, attributes, { parameter.to_sym => parameters[:default] }) : parameters.default %>
-</def>
-
-
-<!-- DRYML version of `render(:partial => 'my_partial')`
-
-### Usage
-
-    <partial name="my-partial" locals="&{:x => 10, :y => 20}"/>
--->
-<def tag="partial" attrs="name, locals"><%= 
-   locals ||= {}
-   render(:partial => name, :locals => locals.merge(:this => this))
-%></def>
-
-
-<!-- Repeat a section of mark-up. The context should be a collection (anything that responds to `each`). The content of the call to `<repeat>` will be repeated for each item in the collection, and the context will be set to each item in turn.
-
-### Attributes
-
- - join: The value of this attribute, if given, will be inserted between each of the items (e.g. `join=", "` is very common).  
--->
-<def tag="repeat" attrs="join"><if><%= 
-  raise ArgumentError, "Cannot <repeat> on #{this.inspect}" unless this.respond_to? :each
-  context_map do
-    parameters.default
-  end.join(join)
-%></if></def>
-
-
-<!-- The 'do nothing' tag. Used to add parameters or change context without adding any markup -->
-<def tag="do"><%= parameters.default %></def>
-
-<!-- Alias of `do` -->
-<def tag="with" alias-of="do"/>
-
-<!-- DRYML's 'if' test
-
-### Usage
-
-    <if test="&current_user.administrtator?">Logged in as administrator</if>
-    <else>Logged in as normal user</else>
-    
-**IMPORTANT NOTE**: `<if>` tests for non-blank vs. blank (as defined by ActiveSuport), not true vs. false. 
-
-If you do not give the `test` attribute, uses the current context instead. This allows a nice trick like this:
-
-    <if:comments>...</if>
-    
-This has the double effect of changing the context to the `this.comments`, and only evaluating the body if there are comments (because an empty
-collection is considered blank)  
--->
-<def tag="if" attrs="test"><%= 
-  test = all_attributes.fetch(:test, this)
-  res = (cond = !test.blank?) ? parameters.default : ""
-  Hobo::Dryml.last_if = cond
-  res
-%></def>
-
-<!-- General purpose `else` clause.
-
-`<else>` works with various tags such as `<if>` and `<repeat>` (the else clause will be output if the collection was empty). It simply outputs its content if `Hobo::Dryml.last_if` is false. This is pretty much a crazy hack which violates many good principles of language design, but it's very useful : )
--->
-<def tag="else"><%= parameters.default unless Hobo::Dryml.last_if %></def>
-
-
-<!-- Same behaviour as `<if>`, except the test is negated. -->
-<def tag="unless" attrs="test"><%= 
-  test = all_attributes.fetch(:test, this)     
-  res = (cond = test.blank?) ? parameters.default : ""
-  Hobo::Dryml.last_if = cond
-  res
-%></def>
-
-
-<!-- nodoc. -->
-<def tag="fake-field-context" attrs="fake-field, context"><%=
-  res = ""
-  new_field_context(fake_field, context) { res << parameters.default }
-  res
-%></def>