hobo 0.5.3

data/hobo_files/plugin/lib/hobo/dryml/template_environment.rb

@@ -0,0 +1,302 @@
+module Hobo::Dryml
+
+  class TemplateEnvironment
+
+    class << self
+      def inherited(subclass)
+        subclass.compiled_local_names = []
+      end
+      attr_accessor :load_time, :compiled_local_names
+    end
+
+    for mod in ActionView::Helpers.constants.grep(/Helper$/).map {|m| ActionView::Helpers.const_get(m)}
+      include mod
+    end
+
+    def initialize(view_name, view)
+      @view = view
+      @view_name = view_name
+      @erb_binding = binding
+      @part_contexts = {}
+      @stack = [nil]
+
+      # Make sure the "assigns" from the controller are available (instance variables)
+      if view
+        view.assigns.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+
+        # copy view instance variables over
+        view.instance_variables.each do |iv|
+          instance_variable_set(iv, @view.instance_variable_get(iv))
+        end
+      end
+    end
+
+    attr_accessor :erb_binding, :part_contexts, :view_name
+
+    attr_reader :this_parent, :this_field, :this_type, :form_field_path, :form_this, :form_field_names
+    
+    def this; @_this; end
+    
+    def attr_extension(s)
+      AttributeExtensionString.new(s)
+    end
+    
+    
+    def this_field_dom_id
+      Hobo.dom_id(this_parent, this_field)
+    end
+
+
+    def part_context_model_id
+      if this_parent and this_parent.is_a?(ActiveRecord::Base) and this_field
+        this_field_dom_id
+      elsif this.respond_to?(:typed_id)
+        this.typed_id
+      elsif this.is_a?(Array) and !this.respond_to?(:proxy_reflection)
+        "nil"
+      else
+        Hobo.dom_id(this)
+      end
+    end
+
+
+    def call_part(dom_id, part_id, part_this=nil)
+      res = ''
+      if part_this
+        new_object_context(part_this) do
+          @part_contexts[dom_id] = [part_id, part_context_model_id]
+          res = send("#{part_id}_part")
+        end
+      else
+        new_context do
+          @part_contexts[dom_id] = [part_id, part_context_model_id]
+          res = send("#{part_id}_part")
+        end
+      end
+      res
+    end
+
+
+    def _erbout
+      @output
+    end
+
+
+    def new_context
+      ctx = @output, @_this, @this_parent, @this_field, @this_type, @form_field_path
+      @output = ""
+      res = yield
+      @output, @_this, @this_parent, @this_field, @this_type, @form_field_path = ctx
+      res.to_s
+    end
+
+
+    def new_object_context(new_this)
+      new_context do
+        @this_parent,@this_field,@this_type = if new_this.respond_to?(:proxy_reflection)
+                                                refl = new_this.proxy_reflection
+                                                [new_this.proxy_owner, refl.name, refl]
+                                              else
+                                                [nil, nil, new_this.class]
+                                              end
+        @_this = new_this
+        yield
+      end
+    end
+
+
+    def new_field_context(field_path, tag_this=nil)
+      new_context do
+        path = if field_path.is_a? Array
+                 field_path
+               elsif field_path.is_a? String
+                 field_path.split('.')
+               else
+                 [field_path]
+               end
+
+        obj = tag_this || this
+        for field in path
+          parent = obj
+          obj = Hobo.get_field(parent, field)
+        end
+
+        type = if (obj.nil? or obj.respond_to?(:proxy_reflection)) and
+                   parent.class.respond_to?(:field_type) and field_type = parent.class.field_type(field)
+                 field_type
+               else
+                 obj.class
+               end
+        
+
+        @_this, @this_parent, @this_field, @this_type = obj, parent, field, type
+        @form_field_path += path if @form_field_path
+        yield
+      end
+    end
+
+
+    def _tag_context(options, tagbody_proc)
+      tagbody = tagbody_proc && proc do |*args|
+        res = ''
+        block_options = args.length > 0 && args.first
+        if block_options and block_options.has_key?(:obj)
+          new_object_context(block_options[:obj]) { res = tagbody_proc.call }
+        elsif block_options and block_options.has_key?(:attr)
+          new_field_context(block_options[:attr]) { res = tagbody_proc.call }
+        else
+          new_context { res = tagbody_proc.call }
+        end
+        res
+      end
+      
+      obj = options[:obj] == "page" ? @this : options[:obj]
+
+      if options.has_key?(:attr)
+        new_field_context(options[:attr], obj) { yield tagbody }
+      elsif options.has_key?(:obj)
+        new_object_context(obj) { yield tagbody }
+      else
+        new_context { yield tagbody }
+      end
+    end
+
+
+    def with_form_context
+      @form_this = this
+      @form_field_path = []
+      @form_field_names = []
+      res = yield
+      field_names = @form_field_names
+      @form_this = @form_field_path = @form_field_names = nil
+      [res, field_names]
+    end
+    
+    
+    def register_form_field(name)
+      @form_field_names << name
+    end
+
+
+    def part_contexts_js
+      return "" if part_contexts.empty?
+
+      assigns = part_contexts.map do |dom_id, p|
+        part_id, model_id = p
+        "hoboParts.#{dom_id} = ['#{part_id}', '#{model_id}']\n"
+      end
+
+      "<script>\nvar hoboParts = {}\n" + assigns.join + "</script>\n"
+    end
+
+
+    def _tag_locals(options, attrs, inner_tag_names)
+      options = Hobo::Dryml.hashify_options(options)
+      options.symbolize_keys!
+      #ensure obj and attr are not in options
+      options.delete(:obj)
+      options.delete(:attr)
+      
+      inner_tag_options, options = options.partition_hash(inner_tag_names.omap{to_sym})
+
+      # positional arguments never appear in the options hash
+      stripped_options = {}.update(options)
+      attrs.each {|a| stripped_options.delete(a.to_sym) }
+      attrs.map {|a| options[a.to_sym]} + [stripped_options, inner_tag_options]
+    end
+    
+    
+    def call_replaceable_tag(name, options, external_param, &b)
+      options.delete(:replace_option)
+      
+      if external_param.is_a? Hash
+        before = external_param.delete(:before_content)
+        after = external_param.delete(:after_content)
+        top = external_param.delete(:top_content)
+        bottom = external_param.delete(:bottom_content)
+        content = external_param.delete(:content)
+        options = Hobo::Dryml.merge_tag_options(options, external_param)
+      elsif !external_param.nil?
+        return external_param.to_s
+      end
+
+      tag = if respond_to?(name)
+              body = if content
+                       proc { content }
+                     elsif b  && (top || bottom)
+                       proc { top.to_s + b.call + bottom.to_s }
+                     else
+                       b
+                     end
+              send(name, options, &body)
+            else
+              body = if content
+                       content
+                     elsif b
+                       top.to_s + new_context { b.call } + bottom.to_s
+                     else
+                       top.to_s + bottom.to_s
+                     end
+              content_tag(name, body, options)
+            end
+      before.to_s + tag.to_s + after.to_s
+    end
+    
+    
+    def call_replaceable_content_tag(name, options, external_param, &b)
+      options.delete(:content_option)
+      
+      if external_param.is_a? Hash
+        content = external_param.delete(:content)
+        top     = external_param.delete(:top_content)
+        bottom  = external_param.delete(:bottom_content)
+        external_param.delete(:before_content)
+        external_param.delete(:after_content)
+        options = Hobo::Dryml.merge_tag_options(options, external_param)
+      elsif !external_param.nil?
+        content = external_param.to_s
+      end
+      
+      # If there's no body, and no content provided externally, remove
+      # the tag altogether
+      return if b.nil? and content.nil?
+
+      tag = if respond_to?(name)
+              body = if content
+                       proc { content }
+                     elsif b  && (top || bottom)
+                       proc { top.to_s + b.call + bottom.to_s }
+                     else
+                       b
+                     end
+              send(name, options, &body)
+            else
+              body = if content
+                       content
+                     elsif b
+                       top.to_s + new_context { b.call } + bottom.to_s
+                     else
+                       top.to_s + bottom.to_s
+                     end
+              content_tag(name, body, options)
+            end
+      tag.to_s
+    end
+
+
+    def render_tag(tag_name, options)
+      (send(tag_name, options) + part_contexts_js).strip
+    end
+    
+    
+    def method_missing(name, *args)
+      @view.send(name, *args)
+    end
+    
+
+  end
+  
+
+end

data/hobo_files/plugin/lib/hobo/dryml/template_handler.rb

@@ -0,0 +1,19 @@
+module Hobo::Dryml
+
+  class TemplateHandler
+
+    def initialize(view)
+      @view = view
+    end
+
+    def render(src, local_assigns)
+      renderer = Hobo::Dryml.page_renderer(@view, local_assigns.keys)
+      s = renderer.render_page(@view.assigns["this"] || local_assigns[:this], local_assigns)
+      # Important to strip whitespace, or the browser hangs around for ages (FF2)
+
+      s.strip
+    end
+
+  end
+
+end

data/hobo_files/plugin/lib/hobo/generator.rb

@@ -0,0 +1,25 @@
+require 'find' 
+
+class Hobo::Generator < Rails::Generator::Base
+
+  def with_source_in(path)
+    root = source_path(path)
+    Find.find(root) do |f|
+      Find.prune if File.basename(f) == ".svn"
+      full_path = f[(source_root.length)..-1]
+      rel_path = f[(root.length)..-1]
+      yield full_path, rel_path
+    end
+  end
+
+  def create_all(m, src, dest)
+    with_source_in(src) do |full, rel|
+      if File.directory?(source_path(full))
+        m.directory File.join(dest, rel)
+      else
+        m.file full, File.join(dest, rel)
+      end
+    end
+  end
+
+end

data/hobo_files/plugin/lib/hobo/html_string.rb

@@ -0,0 +1,3 @@
+class Hobo::HtmlString < String
+
+end

data/hobo_files/plugin/lib/hobo/lazy_hash.rb

@@ -0,0 +1,28 @@
+class Hobo::LazyHash < Hash
+  
+  def initialize(hash=nil)
+    if hash.is_a?(Hash)
+      update(hash)
+    else
+      super
+    end
+  end
+  
+  def [](key)
+    val = super
+    if val.is_a?(Proc)
+      self[val] = val.call
+    else
+      val
+    end
+  end
+  
+  def inspect
+    "#<LazyHash:#{object_id} #{keys.inspect}>"
+  end
+  
+  def to_s
+    inspect
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/mapping_tags.rb

@@ -0,0 +1,262 @@
+module Hobo
+  module MappingTags
+  
+    class InvalidMappingError < RuntimeError; end
+     
+    class TagOrSelector
+      
+      def initialize(name, all_mappings)
+        @_name = name
+        @_dot_names = []
+        @_selectors = []
+        
+        # Keep a reference to the set of mappings for the whole
+        # mapping_tags do ... end, so we can remove self if it turns out
+        # to be an AttributeValueSelector
+        @all_mappings = all_mappings
+      end
+      
+      attr_accessor :_name, :_selectors, :_dot_names
+     
+      def method_missing(name)
+        raise NoMethodError.new("undefined method: #{name}") if name.to_s =~ /^_|[!?=]$/
+        _dot_names << name
+        self
+      end
+      
+      
+      def [](*selectors)
+        raise InvalidMappingError.new unless _selectors.empty?
+        
+        @_selectors = selectors.omap {_to_selector}
+        self
+      end
+      
+      
+      def _to_selector
+        raise InvalidMappingError.new unless _dot_names.empty? and _selectors.empty?
+        AttributeSelector.new(_name)
+      end
+      
+      
+      def ==(rhs)
+        raise InvalidMappingError.new unless _selectors.empty? and _dot_names.empty?
+        AttributeValueSelector.new(_name, rhs)
+      end
+      
+      
+      def >>(rhs)
+        @all_mappings << Mapping.new(self, rhs)
+        nil
+      end
+      
+    end
+     
+    class AttributeSelector
+      
+      def initialize(attribute)
+        @attribute = attribute
+      end
+      
+      
+      def compile
+        "options[:#{@attribute}]"
+      end
+    end
+     
+    class AttributeValueSelector
+      
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+      
+      attr_reader :name, :value
+      
+      def compile
+        "(options[:#{@name}] == #{@value.inspect})"
+      end
+      
+      def _to_selector
+        self
+      end
+      
+    end
+     
+     
+    class Mapping
+      
+      def initialize(pattern, result)
+        raise InvalidMappingError.new unless result._selectors.empty? and pattern._dot_names.length <= 1
+        @pattern = pattern
+        @result = result
+      end
+      
+      attr_reader :pattern, :result
+      
+      
+      def pattern_tag_name
+        pattern._name
+      end
+      
+      
+      def pattern_predicate
+        clauses = (pattern._selectors || []).omap{compile}
+        type_name = pattern._dot_names.first
+        clauses << "selector_type && (#{type_name.to_s.camelize} <= selector_type)" if type_name
+        !clauses.empty? && "proc {|options| #{clauses.join(' and ')}}"
+      end
+      
+      
+      def result_tag_name
+        result._name
+      end
+      
+      
+      def result_css_classes
+        result._dot_names
+      end
+      
+      
+    end
+     
+     
+    class MappingDSL
+     
+      def initialize
+        @_mappings = []
+      end
+      
+      attr_reader :_mappings
+
+      def standard_mappings
+        instance_eval do
+          intro   >> div.intro
+          maincol >> div.maincol
+          sidecol >> div.sidecol
+          panel   >> div.panel
+          section >> div.section.foo
+          
+          fields >> table.fields
+          field  >> tr.field
+          fl     >> td.field_label
+          fd     >> td.field_data  
+        end
+      end
+      
+      def method_missing(name, &b)
+        raise NoMethodError.new("undefined method: #{name}") if name.to_s =~ /^_|[!?=]$/
+        TagOrSelector.new(name, @_mappings)
+      end
+      
+    end
+     
+    (Object.instance_methods +
+     Object.private_instance_methods +
+     Object.protected_instance_methods).each do |m|
+      MappingDSL.send(:undef_method, m) unless
+        %w{initialize method_missing instance_eval standard_mappings}.include?(m) || m.starts_with?('_')
+    end
+     
+     
+    def self.define_mapping_tag(mapping, mod)
+      def_name           = mapping.pattern_tag_name
+      pred               = mapping.pattern_predicate
+      result_tag_name    = mapping.result_tag_name
+      result_css_classes = mapping.result_css_classes
+      
+      static_tag_name = result_tag_name if result_tag_name.to_s.in?(Hobo.static_tags)
+        
+      if def_name == result_tag_name
+        result_tag_name = "#{def_name}_unmapped"
+        if def_name.to_s.in?(mod.instance_methods) and result_tag_name.not_in?(mod.instance_methods)
+          mod.send(:alias_method, result_tag_name, def_name) 
+        end
+        
+        if pred and !mod.predicate_has_default?(def_name)
+          # Make sure the old tag method is called when the predicate is false
+          mod.module_eval "defp(:#{def_name}) { |options, block| #{result_tag_name}(options, &block) }"
+        end
+      end
+      
+      # puts "map: #{def_name}[#{pred}] -> #{result_tag_name} (#{result_css_classes * ' '}) #{static_tag_name}"
+      
+      def_line = if !pred.blank?
+                   "defp :#{def_name}, (#{pred}) do |options, block|"
+                 elsif mod.predicate_method?(def_name)
+                   # be sure not to overwrite the predicate dispatch method
+                   "defp :#{def_name} do |options, block|"
+                 else
+                   "def #{def_name}(options={}, &block)"
+                 end
+      
+      add_classes = if result_css_classes.empty?
+                      ""
+                    else
+                      "options = add_classes(options, *#{result_css_classes.inspect})"
+                    end
+      
+      no_method_fallback = if static_tag_name
+                             "content_tag('#{static_tag_name}', tagbody && tagbody.call, options)"
+                           else
+                             "raise NoMethodError.new('undefined method: #{result_tag_name}')"
+                           end
+      
+      mod.module_eval(x = <<-END, __FILE__, __LINE__+1)
+        #{def_line}
+          _tag_context(options, block) do |tagbody|
+            #{add_classes}
+            if respond_to?('#{result_tag_name}')
+              #{result_tag_name}(options, &block)
+            else
+              #{no_method_fallback}
+            end
+          end
+        end
+      END
+    end
+    
+    
+    def self.make_mappings(&b)
+      d = MappingDSL.new
+      d.instance_eval(&b)
+      d._mappings
+    end
+     
+
+    def self.map(&b)
+      @mappings = make_mappings(&b)
+    end
+    
+    
+    def self.apply_mappings(mod)
+      mod.send(:include, PredicateDispatch) unless PredicateDispatch.in?(mod.included_modules)
+      @mappings.each {|m| define_mapping_tag(m, mod) }
+    end
+    
+    
+    def self.apply_standard_mappings(mod)
+      mod.send(:include, PredicateDispatch) unless PredicateDispatch.in?(mod.included_modules)      
+      standard_mappings = make_mappings do
+        intro   >> div.intro
+        main    >> div.main
+        maincol >> div.maincol
+        sidecol >> div.sidecol
+        panel   >> div.panel
+        section >> div.section
+        
+        fields >> table.fields
+        field  >> tr.field
+        fl     >> td.field_label
+        fd     >> td.field_data  
+      end
+                                     
+      for mapping in standard_mappings
+        define_mapping_tag(mapping, mod) unless mapping.pattern_tag_name.to_s.in?(mod.instance_methods)
+      end
+
+    end
+  
+  end
+  
+end