hobo 0.8.5 → 0.8.6

data/lib/hobo/model_support.rb

@@ -1,44 +0,0 @@
-module Hobo
-
-  module ModelSupport
-
-    # This module provides methods common to both Hobo::Model and Hobo::CompositeModel
-
-    def self.included(base)
-      base.extend(ClassMethods) if base.is_a? Class
-    end
-
-    module ClassMethods
-
-      def delegate_and_compose(*methods)
-        options = methods.pop
-        unless options.is_a?(Hash) && to = options[:to]
-          raise ArgumentError, ("Delegation needs a target. Supply an options hash " +
-                                "with a :to key as the last argument (e.g. delegate :hello, :to => :greeter).")
-        end
-        use = options[:use]
-
-        methods.each do |method|
-          module_eval(<<-EOS, "(__COMPOSED_DELEGATION__)", 1)
-            def #{method}
-              @__#{method}_result__ ||= begin
-                                          obj = #{to}.__send__(#{method.inspect})
-                                          return nil if obj.nil?
-
-                                          if obj.nil?
-                                            nil
-                                          elsif obj.is_a?(Array)
-                                            obj.map {|o| self.compose_with(o, #{use.inspect})}
-                                          else
-                                            self.compose_with(obj, #{use.inspect})
-                                          end
-                                        end
-            end
-          EOS
-        end
-      end
-
-    end
-
-  end
-end

data/tasks/fix_dryml.rake

@@ -1,143 +0,0 @@
-require 'fileutils'
-
-def restore_erb_scriptlets(scriptlets, src)
-  src.gsub(/\[!\[HOBO-ERB(\d+)\s*\]!\]/m) {|s| "<%#{scriptlets[$1.to_i]}%>" }
-end
-
-
-def fix_nodes(nodes)
-  nodes.map{|x| fix_element(x) if x.is_a?(REXML::Element) }
-end
-
-
-def start_tag_replace(el, repl)
-  i, len = el.source_offset, el.start_tag_source.length
-  @src[i..i+len-1] = repl
-end
- 
- 
-def classes?
-  ENV['CLASS']
-end
-
-def ids?
-  ENV['ID']
-end
-
-
-def string_interpolate_safe_dasherize(s)
-  token = "[[MAKE_ME_A_DASH!]]"
-  s.gsub("_", token).
-    gsub(/\#\{.*?\}/) {|s2| s2.gsub(token, "_") }.
-    gsub(token, "-")
-end
-
-
-def fix_children(element, template_params)
-  element.elements.to_a.reverse.each do |e|
-    # recurse first - we're going backwards
-    is_template_call = e.dryml_name =~ /^[A-Z]/ && !e.attribute("replace")
-    fix_children(e, is_template_call)
-    
-    fixed = fix_element(e, template_params)
-    start_tag_replace(e, fixed)
-  end
-end
-
-
-def fix_element(e, template_param)
-  tag = e.start_tag_source.dup
-
-  if e.dryml_name == "tagbody"
-    tag.sub!("<tagbody", '<do param="default"')
-  elsif e.dryml_name == "default_tagbody"
-    tag.sub!("<default_tagbody", '<param-content')
-  else
-    tag.sub!("<#{e.dryml_name}", "<#{e.dryml_name.underscore.dasherize}#{':' if template_param}")
-  end
-  
-  start = e.expanded_name.length+1
-  tag[start..-1] = tag[start..-1].gsub(/([A-Za-z_]+)(\s*=\s*("(.*?)"|'(.*?)'))?/) do |s|
-    _, name, _, value = *Regexp.last_match
-    
-    s.sub!(/^#{name}/, name.dasherize)
-    
-    if value 
-      # underscore / dasherize the values of various attributes
-      
-      if e.name == "def" && name.in?(%w(tag attrs alias_of extend_with))
-        s.sub!(/#{Regexp.escape(value)}$/) {|v| v.underscore.dasherize}
-      
-      elsif name.in?(%w(part update)) || (classes? && name == 'class') || (ids? && name == 'id')
-        s.sub!(/#{Regexp.escape(value)}$/) {|v| string_interpolate_safe_dasherize(v) }
-
-      elsif name == "param"
-        s.sub!(/#{Regexp.escape(value)}$/) {|v| string_interpolate_safe_dasherize(v.underscore) }
-      end
-      
-    end
-    s
-  end
-  tag
-end
-
-
-def fix_file(filename)
-  puts "Fixing #{filename}"
-  src = File.read(filename)
-
-  # Ripped from Hobo::Dryml::Template - hide erb scriptlets and parse with REXML
-  scriptlets = {}
-  src = src.gsub(/<%(.*?)%>/m) do
-    _, scriptlet = *Regexp.last_match
-    id = scriptlets.size + 1
-    scriptlets[id] = scriptlet
-    newlines = "\n" * scriptlet.count("\n")
-    "[![HOBO-ERB#{id}#{newlines}]!]"
-  end
-
-  # DRYML doesn't have to have a single root - add one to keep REXML
-  # happy
-  @src = "<root>" + src + "</root>"
-  begin
-    doc = Hobo::Dryml::Parser::Document.new(Hobo::Dryml::Parser::Source.new(@src))
-  rescue REXML::ParseException => e
-    raise Exception, "File: #{@template_path}\n#{e}"
-  end
-  
-  fix_children(doc[0], false)
-  
-  #Fix close tags
-  @src.gsub!(/<\/[^:>]*/) { |s| s.underscore.dasherize }
-  @src.gsub!(/<\/tagbody\s*>/, "</do>")
-  
-  # Strip the root tag we added
-  @src.sub!(/^<root>/, "")
-  @src.sub!(/<\/root>$/, "")
-  
-  fixed = restore_erb_scriptlets(scriptlets, @src)
-  File.open(filename, 'w') { |f| f.write(fixed) }
-end
-
-
-namespace :hobo do
-
-  desc "Replace old-style DRYML source code with CamelCaseTags and underscores with new DRYML syntax"
-  task :fixdryml => :environment do
-    
-    dir = ENV['DIR']._?.sub(/\/$/, '') || "app/views"
-    
-    # Make a backup
-    backup_dir = "#{dir.gsub('../', '').gsub('/', '_')}_before_fixdryml"
-    if File.exist?(backup_dir)
-      puts "Backup (#{backup_dir}) already exists - be careful! (nothing changed)"
-      exit
-    end
-    FileUtils.cp_r(dir, backup_dir)
-   
-    Dir["#{dir}/**/*.dryml"].each do |f|
-      fix_file(f)
-    end
-  end
-  
-end

data/tasks/generate_tag_reference.rake

@@ -1,192 +0,0 @@
-require 'fileutils'
-
-ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__) + "/../lib"
-
-require 'rexml/xpath'
-XPath = REXML::XPath
-
-def tag_title(tag, link=false)
-  if tag.is_a? String
-    name = tag
-    anchor = tag
-  else
-    for_attr = tag.attributes['for'] and for_decl = %( for=`"#{for_attr}"`)
-    name = tag.attributes['tag']
-    anchor = tag_anchor(tag)
-  end
-
-  title = "&lt;#{name}#{for_decl}&gt;"
-
-  if link
-    "[#{title}](##{anchor})"
-  else
-    title
-  end
-end
-
-
-def link_to_tag(tag)
-  tag_title(tag, true)
-end
-
-
-def tag_anchor(element)
-  for_attr = element.attributes['for']
-  name = element.attributes['tag']
-
-  if for_attr
-    "#{name}--for-#{for_attr}"
-  else
-    name
-  end
-end
-
-
-def comment_for_tag(element)
-  space = element.previous_sibling and
-    space.to_s.blank? && space.to_s.count("\n") == 1 and
-    comment = space.previous_sibling
-
-  comment.to_s.strip if comment.is_a?(REXML::Comment)
-end
-
-
-def doc_for_tag(tagdef)
-  comment = comment_for_tag(tagdef)
-
-  params_merged_with = XPath.first(tagdef, ".//*[@merge|@merge-params]")._?.name
-  params_merged_with &&= "(merged with #{link_to_tag params_merged_with})"
-
-  attrs_merged_with = XPath.first(tagdef, ".//*[@merge|@merge-attrs]")._?.name
-  attrs_merged_with &&= "(merged with #{link_to_tag attrs_merged_with})"
-
-  attrs = tagdef.attributes['attrs'] || []
-  attrs = attrs.split(/,\s*/).where_not.blank?.map { |a| " * #{a}\n" }.join
-
-  parameters = params_to_list(get_parameters(tagdef))
-<<-END
----
-
-<a name="#{tag_anchor tagdef}">&nbsp;</a>
-##  #{tag_title tagdef}
-
-#{comment}
-
-### Attributes #{attrs_merged_with}
-
-#{attrs.blank? ? 'None' : attrs}
-
-### Parameters #{params_merged_with}
-
-#{parameters.blank? ? 'None' : parameters}
-END
-end
-
-
-def get_parameters(elem)
-  result = []
-  elem.elements.each do |e|
-    if e.attributes['param']
-      result << [e, get_parameters(e)]
-    else
-      result.concat(get_parameters(e))
-    end
-  end
-  result
-end
-
-
-def params_to_list(params, indent=" ")
-  items = params.map do |elem, sub_params|
-    p_attr = elem.attributes['param']
-    entry = if p_attr == "&true"
-              "&lt;#{elem.name}:&gt;"
-            elsif p_attr =~ /#\{/
-                "(dynamic parameter) (&lt;#{elem.name}&gt;)"
-            else
-              "&lt;#{p_attr}:&gt; (&lt;#{elem.name}&gt;)"
-            end
-    sub_list = params_to_list(sub_params, indent + ' ') unless sub_params.empty?
-    "<li>#{entry}\n#{sub_list}</li>\n"
-  end.join
-
-  items.any? ? "<ul>#{items}</ul>" : ""
-end
-
-
-def contents(root)
-  tags = XPath.match(root, '/*/*[@tag]')
-  tags.map { |tag| " * #{link_to_tag tag}\n" }.join
-end
-
-
-def doc_for_taglib(title, root)
-  tags = XPath.match(root, '/*/*[@tag]').map { |e| doc_for_tag(e) }.join("\n\n")
-
-  "# #{title}\n\n" + contents(root) + "\n\n" + tags
-end
-
-def index_page(output_files, output_dir)
-  markdown = "# Tag Documentation\n\n" + output_files.map do |f|
-    link = f.gsub(output_dir+'/', '')
-    link_text = link.gsub('_', '\_').gsub(/\.html$/, '')
-    "* [#{link_text}](#{link})"
-  end.join("\n")
-
-  html = Maruku.new(markdown).to_html
-  
-  File.open("#{output_dir}/index.html", 'w') { |f| f.write(html) }
-end
-
-def process_directory(src, output_dir, output_format)
-  raise RuntimeError, "#{output_dir} is not a directory" if File.exists?(output_dir) && !File.directory?(output_dir)
-
-  FileUtils.mkdir output_dir unless File.exists? output_dir
-
-  dryml_files = File.directory?(src) ? Dir["#{src}/*"] : [src]
-
-  output_files = []
-
-  dryml_files.each do |f|
-    if File.directory?(f)
-      output_files += process_directory(f, "#{output_dir}/#{File.basename(f)}", output_format)
-    elsif f =~ /\.dryml$/
-      basename = File.basename(f).sub(/\.dryml$/, '')
-      title = basename.titleize
-
-      doc = Hobo::Dryml::Parser::Document.new(File.read(f), f)
-
-      output = doc.restore_erb_scriptlets(doc_for_taglib(title, doc))
-      output = Maruku.new(output).to_html.gsub('&amp;', '&') if output_format == 'html'
-
-      output_file = "#{output_dir}/#{basename}.#{output_format}"
-      puts output_file
-      File.open(output_file, 'w') { |f| f.write(output) }
-      output_files << output_file
-    end
-  end
-  output_files
-end
-
-  
-
-namespace :hobo do
-
-  desc "Generate markdown formatted reference docs automatically from DRYML taglibs"
-  task :generate_tag_reference => :environment do
-    gem 'maruku'
-    require 'maruku'
-
-    src = ENV['src']
-
-    output_dir = ENV['output'] || "taglib-docs"
-    
-    output_format = ENV['format'] || "markdown"
-    
-    output_files = process_directory(src, output_dir, output_format)
-    
-    index_page(output_files, output_dir)
-  end
-
-end
-

data/test/dryml/complilation_test.rb

@@ -1,261 +0,0 @@
-require "#{File.dirname __FILE__}/dryml_test_case"
-
-class CompilationTest < DrymlTestCase
-  
-  should "compile tag calls as method calls" do
-    assert_compiles_to "<% _output(foo.to_s) %>", "<foo/>"
-  end
-
-  should "convert dashes in tag names to underscores in compiled method calls" do
-    assert_compiles_to "<% _output(foo_baa.to_s) %>", "<foo-baa/>"
-  end
-
-  should "compile attributes as keyword parameters" do
-    assert_compiles_to '<% _output(foo({:a => "1", :b => "2"}, {})) %>', "<foo a='1' b='2'/>"
-  end
-
-  should "convert attribute names with dashes in tag calls to symbols with underscores" do
-    assert_compiles_to "<% _output(foo({:my_attribute => \"1\"}, {})) %>", "<foo my-attribute='1'/>"
-  end
-
-  should "compile code attributes as ruby code" do
-    assert_compiles_to '<% _output(foo({:a => (1 + 2)}, {})) %>', "<foo a='&1 + 2'/>"
-  end
-
-  should "compile attributes with no RHS as passing `true`" do
-    assert_compiles_to '<% _output(foo({:a => (true)}, {})) %>', "<foo a/>"
-  end
-
-  should "compile content of a tag call as the default parameter" do
-    assert_compiles_to "<% _output(foo({}, { :default => proc { |_foo__default_content| new_context { %>the body<% } }, })) %>", 
-                       "<foo>the body</foo>"
-  end
-
-  should "support <param_content/> inside the content of a tag" do
-    src = "<foo>!!<param-content/>??</foo>"
-    assert_compiles_to "<% _output(foo({}, { :default => proc { |_foo__default_content| new_context { %>!!<%= _foo__default_content && _foo__default_content.call %>??<% } }, })) %>", src
-  end
-
-  should "support the 'for' attribute on <param-content/>" do
-    src = "<x><y>123<param-content for='x'/>456</y></x>"
-    assert_compiles_to(
-      "<% _output(x({}, { :default => proc { |_x__default_content| new_context { %><% _output(y({}, { :default => proc { |_y__default_content| new_context { %>" +
-      "123<%= _x__default_content && _x__default_content.call %>456" +
-      "<% } }, })) %><% } }, })) %>", src)
-  end
-
-  should "allow :foo as a shorthand for field='foo' on tags" do
-    assert_compiles_to '<% _output(foo({:field => "name"}, {})) %>', "<foo:name/>"
-  end
-
-  should "allow static tag names like :title as a shorthand for field='title'" do
-    assert_compiles_to  '<% _output(foo({:field => "name"}, {})) %>', "<foo:name/>"
-  end
-
-  should "allow close tags to ommit the :field_name part" do
-    assert_compiles_to '<% _output(foo({:field => "name"}, { :default => proc { |_foo__default_content| new_context { %><% } }, })) %>', "<foo:name></foo>"
-      
-  end
-
-  should "compile tag calls with merge-attrs" do
-    assert_compiles_to "<% _output(foo(merge_attrs({},(attributes) || {}), {})) %>",          "<foo merge-attrs/>"
-    assert_compiles_to '<% _output(foo(merge_attrs({:a => "1"},(attributes) || {}), {})) %>', "<foo a='1' merge-attrs/>"
-  end
-
-
-  # --- Compilation: Defining Tags --- #
-
-  should "compile defs" do
-    assert_compiles_to(
-      "<% def foo(all_attributes={}, all_parameters={}); " +
-      "parameters = Hobo::Dryml::TagParameters.new(all_parameters, []); " +
-      "all_parameters = Hobo::Dryml::TagParameters.new(all_parameters); " +
-      "_tag_context(all_attributes) do attributes, = _tag_locals(all_attributes, []) %>" +
-      "<% _erbout; end; end %>",
-      
-      "<def tag='foo'></def>")
-      
-  end
-
-  should "compile attrs in defs as local variables" do
-    assert_compiles_to(
-      "<% def foo(all_attributes={}, all_parameters={}); " +
-      "parameters = Hobo::Dryml::TagParameters.new(all_parameters, []); " +
-      "all_parameters = Hobo::Dryml::TagParameters.new(all_parameters); " +
-      "_tag_context(all_attributes) do " +
-      "a, my_attr, attributes, = _tag_locals(all_attributes, [:a, :my_attr]) %>" +
-      "<% _erbout; end; end %>",
-      
-      "<def tag='foo' attrs='a, my-attr'></def>")
-  end
-
-  should "dissallow `param` outside of tag definitions" do
-    assert_raise(DrymlException) { compile_dryml("<foo param/>") }
-  end
-
-  should "compile param-tag calls as calls to `call_tag_parameter`" do
-    assert_compiles_to '<% _output(call_tag_parameter(:foo, {:a => "1"}, {}, all_parameters, :foo)) %>',  
-                       "<foo param a='1'/>",
-                       :in_def
-  end
-
-  should "compile with support for named params" do
-    assert_compiles_to "<% _output(call_tag_parameter(:foo, {}, {}, all_parameters, :zap)) %>", "<foo param='zap'/>", :in_def
-  end
-
-  should "compile a param tag-call with a body" do
-    assert_compiles_to "<% _output(call_tag_parameter(:foo, {}, { :default => proc { |_foo__default_content| new_context { %>abc<% } }, }, all_parameters, :foo)) %>",
-                       "<foo param>abc</foo>",
-                       :in_def
-  end
-
-  should "compile a param tag-call with a body and a call to <param_content/>" do
-    assert_compiles_to "<% _output(call_tag_parameter(:foo, {}, { :default => proc { |_foo__default_content| new_context { %>!!<%= _foo__default_content && _foo__default_content.call %>!!<% } }, }, all_parameters, :foo)) %>",
-                       "<foo param>!!<param-content/>!!</foo>",
-                       :in_def
-                       
-  end
-
-  should "compile param template-calls as calls to `call_tag_parameter`" do
-    assert_compiles_to "<% _output(call_tag_parameter(:foo, {}, {}, all_parameters, :foo)) %>",
-                       "<foo param/>",
-                       :in_def
-  end
-
-  should "compile param tag calls with parameters as calls to `call_tag_parameter`" do
-    assert_compiles_to '<% _output(call_tag_parameter(:foo, {}, {:a => proc { [{:x => "1"}, {}] }, }, all_parameters, :foo)) %>',
-                       "<foo param><a: x='1'/></foo>",
-                       :in_def
-  end
-
-  should "compile parameters with param" do
-    assert_compiles_to '<% _output(foo({}, {:abc => merge_tag_parameter(proc { [{}, {}] }, all_parameters[:abc]), })) %>',
-                       "<foo><abc: param/></foo>",
-                       :in_def
-  end
-
-  should "compile tag parameters with named params" do
-    assert_compiles_to '<% _output(foo({}, {:abc => merge_tag_parameter(proc { [{}, {}] }, all_parameters[:x]), })) %>', 
-                       "<foo><abc: param='x'/></foo>",
-                       :in_def
-  end
-
-  should "compile tag parameters with param and attributes" do
-    assert_compiles_to '<% _output(foo({}, {:abc => merge_tag_parameter(proc { [{:a => "b"}, {}] }, all_parameters[:x]), })) %>',
-                       "<foo><abc: param='x' a='b'/></foo>",
-                       :in_def
-  end
-
-  should "compile tag parameters with param and a tag body" do
-    assert_compiles_to(
-      '<% _output(foo({}, {:abc => merge_tag_parameter(' +
-      'proc { [{}, { :default => proc { |_abc__default_content| new_context { %>ha!<% } }, }] }, all_parameters[:abc]), })) %>',
-      "<foo><abc: param>ha!</abc></foo>",
-      :in_def)
-      
-  end
-
-  should "compile tag parameters with param and nested parameters" do
-    assert_compiles_to(
-      '<% _output(foo({}, {:baa => merge_tag_parameter(' +
-      'proc { [{}, {:x => proc { [{}, { :default => proc { |_x__default_content| new_context { %>hello<% } }, }] }, }] }, all_parameters[:baa]), })) %>',
-      "<foo><baa: param><x:>hello</x:></baa:></foo>",
-      :in_def)
-  end
-
-  # --- Compilation: Calling tags with parameters --- #
-
-  should "compile tag parameters as procs" do
-    assert_compiles_to(
-      '<% _output(foo({}, {' +
-      ':x => proc { [{}, { :default => proc { |_x__default_content| new_context { %>hello<% } }, }] }, ' +
-      ':y => proc { [{}, { :default => proc { |_y__default_content| new_context { %>world<% } }, }] }, })) %>',
-      "<foo><x:>hello</x><y:>world</y:></foo>"
-      )
-  end
-
-  should "compile tag parameters with attributes" do
-    assert_compiles_to(
-      '<% _output(foo({}, {:abc => proc { [{:x => "1"}, { :default => proc { |_abc__default_content| new_context { %>hello<% } }, }] }, })) %>',
-      "<foo><abc: x='1'>hello</abc></foo>"
-      )
-  end
-
-  should "allow :foo as a shorthand for field='foo' on template tags" do
-    assert_compiles_to '<% _output(foo({:field => "name"}, {})) %>', "<foo:name/>"
-  end
-
-  should "compile template parameters which are themselves templates" do
-    # Tag parameters with nested tag parameters are procs that return
-    # a pair of hashes, the first is the attributes, the second is the
-    # sub-template procs
-    assert_compiles_to(
-      '<% _output(foo({}, ' +
-      '{:baa => proc { [{:x => "1"}, {:a => proc { [{}, { :default => proc { |_a__default_content| new_context { %>hello<% } }, }] }, }] }, })) %>',
-      "<foo><baa: x='1'><a:>hello</a></baa></foo>")
-  end
-
-  should "compile 'replace' parameters" do
-    # A replace parameter is detected at runtime by the arity of the
-    # block == 1 (for a normal parameter it would be 0). See
-    # TemplateEnvironment#call_tag_parameter
-    assert_compiles_to(
-      '<% _output(page({}, {:head_replacement => proc { |_head_restore| new_context { %>abc<% } }, })) %>',
-      "<page><head: replace>abc</head></page>"
-      )
-  end
-
-  should "compile 'replace' parameters where the restore contains a default parameter call" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head_replacement => proc { |_head_restore| new_context { %>abc ' +
-      '<% _output(_head_restore.call({}, { :default => proc { |_head__default_content| new_context { %>blah<% } }, })) %>' +
-      '<% } }, })) %>',
-      
-      "<page><head: replace>abc <head restore>blah</head></head></page>"
-      )
-  end
-
-  should "compile 'replace' tag parameters with a default parameter call" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head_replacement => proc { |_head_restore| new_context { %>abc ' +
-      '<% _output(_head_restore.call({}, {})) %>' +
-      '<% } }, })) %>',
-      "<page><head: replace>abc <head restore/></head></page>")
-  end
-
-
-  # --- Compilation: Syntax sugar for before, after, append, prepend --- #
-
-  should "compile 'before' parameters" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head_replacement => proc { |_head_restore| new_context { %>abc' +
-      '<% _output(_head_restore.call({}, {})) %>' +
-      '<% } }, })) %>',
-      "<page><before-head:>abc</before-head></page>")
-  end
-
-  should "compile 'after' parameters" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head_replacement => proc { |_head_restore| new_context { %>' +
-      '<% _output(_head_restore.call({}, {})) %>' +
-      'abc<% } }, })) %>',
-      "<page><after-head:>abc</after-head></page>")
-  end
-
-  should "compile 'apppend' parameters" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head => proc { [{}, { :default => proc { |_head__default_content| new_context { %>' +
-      '<%= _head__default_content && _head__default_content.call %>:o)' +
-      '<% } } } ] }, })) %>',
-      "<page><append-head:>:o)</append-head></page>")
-  end
-
-  should "compile 'prepend' parameters" do
-    assert_compiles_to(
-      '<% _output(page({}, {:head => proc { [{}, { :default => proc { |_head__default_content| new_context { %>' +
-      ':o)<%= _head__default_content && _head__default_content.call %>' +
-      '<% } } } ] }, })) %>',
-      "<page><prepend-head:>:o)</prepend-head></page>")
-  end
-  
-end