hobo 0.7.0 → 0.7.1

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

@@ -64,7 +64,7 @@ module Hobo::Dryml
 
     def build(local_names, auto_taglibs)
 
-      auto_taglibs.each{|t| import_taglib(t)}
+      auto_taglibs.each { |t| import_taglib(t) }
     
       @build_instructions.each do |instruction|
         name = instruction[:name]
@@ -82,7 +82,7 @@ module Hobo::Dryml
           @environment.class_eval(method_src, template_path, instruction[:line_num])
           
         when :include
-          import_taglib(name, instruction[:as])
+          import_taglib(instruction)
           
         when :module
           import_module(name.constantize, instruction[:as])
@@ -102,24 +102,13 @@ module Hobo::Dryml
     end
     
 
-    def expand_template_path(path)
-      base = if path.starts_with? "plugins"
-               "vendor/" + path
-             elsif path.include?("/")
-               "app/views/#{path}"
-             else
-               template_dir = File.dirname(template_path)
-               "#{template_dir}/#{path}"
-             end
-       base + ".dryml"
-    end
-
-
-    def import_taglib(src_path, as=nil)
-      path = expand_template_path(src_path)
-      unless template_path == path
-        taglib = Taglib.get(RAILS_ROOT + (path.starts_with?("/") ? path : "/" + path))
-        taglib.import_into(@environment, as)
+    def import_taglib(options)
+      if options[:module]
+        import_module(options[:module].constantize, options[:as])
+      else
+        template_dir = File.dirname(template_path)
+        taglib = Taglib.get(options.merge(:template_dir => template_dir))
+        taglib.import_into(@environment, options[:as])
       end
     end
 
@@ -133,7 +122,7 @@ module Hobo::Dryml
     def set_theme(name)
       if Hobo.current_theme.nil? or Hobo.current_theme == name
         Hobo.current_theme = name
-        import_taglib("taglibs/themes/#{name}/application")
+        import_taglib(:src => "taglibs/themes/#{name}/application")
       end
     end
   end

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

@@ -1,95 +1,122 @@
-module Hobo::Dryml
+module Hobo
+  
+  module Dryml
 
-  class Taglib
-
-    @cache = {}
-
-    class << self
-
-      def get(path)
-        raise DrymlException, "No such taglib: #{path}" unless File.exists?(path)
-        file = File.new(path)
-
-        taglib = @cache[file.path]
-        if taglib
-          taglib.reload
-        else
-          taglib = Taglib.new(file)
-          @cache[file.path] = taglib
+    class Taglib
+     
+      @cache = {}
+     
+      class << self
+     
+        def get(options)
+          file = taglib_file(options)
+     
+          taglib = @cache[options]
+          if taglib
+            taglib.reload
+          else
+            renames = (bundle = options[:bundle] and
+                       Bundle.bundles[bundle]._?.renames)
+     
+            taglib = Taglib.new(file, renames)
+            @cache[options] = taglib
+          end
+          taglib
         end
-        taglib
-      end
-      
-      def clear_cache
-        @cache = {}
-      end
-
-    end
-
-    def initialize(file)
-      @file = file
-      load
-    end
-
-    def reload
-      load if @file.mtime > @last_load_time
-    end
-
-    def load
-      @module = Module.new do
         
-        @tag_attrs = {}
-        @tag_aliases = {}
+        def clear_cache
+          @cache = {}
+        end
+        
+        private
         
-        class << self
+        def taglib_file(options)
+          base = if (plugin = options[:plugin])
+                   "vendor/plugins/#{plugin}/taglibs"
+                 elsif (bundle_name = options[:bundle])
+                   bundle = Bundle.bundles[bundle_name]
+                   "vendor/plugins/#{bundle.plugin}/taglibs"
+                 elsif options[:src] =~ /\//
+                   "app/views"
+                 else
+                   options[:template_dir]
+                 end
           
-          def included(base)
-            @tag_aliases.each do |tag, feature|
-              base.send(:alias_method_chain, tag, feature)
-            end
-          end
-
-          def _register_tag_attrs(tag, attrs)
-            @tag_attrs[tag] = attrs
-          end
-          attr_reader :tag_attrs
+          filename = "#{RAILS_ROOT}/#{base}/#{options[:src]}.dryml"
+          raise DrymlException, "No such taglib: #{options.inspect} #{filename}" unless File.exists?(filename)
+          File.new(filename)
+        end
+     
+      end
+     
+      def initialize(file, renames)
+        @file = file
+        @renames = renames
+        load
+      end
+     
+      def reload
+        load if @file.mtime > @last_load_time
+      end
+     
+      def load
+        @module = Module.new do
+          
+          @tag_attrs = {}
+          @tag_aliases = {}
           
-          def delayed_alias_method_chain(tag, feature)
-            @tag_aliases[tag] = feature
+          class << self
+            
+            def included(base)
+              @tag_aliases.each do |tag, feature|
+                base.send(:alias_method_chain, tag, feature)
+              end
+            end
+     
+            def _register_tag_attrs(tag, attrs)
+              @tag_attrs[tag] = attrs
+            end
+            attr_reader :tag_attrs
+            
+            def delayed_alias_method_chain(tag, feature)
+              @tag_aliases[tag] = feature
+            end
+            
           end
           
         end
-        
+        @file.rewind
+        template = Template.new(@file.read, @module, @file.path, @renames)
+        template.compile([], [])
+        @last_load_time = @file.mtime
       end
-      @file.rewind
-      template = Template.new(@file.read, @module, @file.path)
-      template.compile([], [])
-      @last_load_time = @file.mtime
-    end
-
-    def import_into(class_or_module, as)
-      if as
-        # Define a method on class_or_module named whatever 'as'
-        # is. The first time the method is called it creates and
-        # returns an object that provides the taglib's tags as
-        # methods. On subsequent calls the object is cached in an
-        # instance variable "@_#{as}_taglib"
-        
-        taglib_module = @module
-        ivar = "@_#{as}_taglib"
-        class_or_module.send(:define_method, as) do 
-          instance_variable_get(ivar) or begin
-                                           as_class = Class.new(TemplateEnvironment) { include taglib_module }
-                                           as_object = as_class.new
-                                           as_object.copy_instance_variables_from(self)
-                                           instance_variable_set(ivar, as_object)
-                                         end
+     
+      def import_into(class_or_module, as)
+        if as
+          # Define a method on class_or_module named whatever 'as'
+          # is. The first time the method is called it creates and
+          # returns an object that provides the taglib's tags as
+          # methods. On subsequent calls the object is cached in an
+          # instance variable "@_#{as}_taglib"
+          
+          taglib_module = @module
+          ivar = "@_#{as}_taglib"
+          class_or_module.send(:define_method, as) do 
+            instance_variable_get(ivar) or begin
+                                             as_class = Class.new(TemplateEnvironment) { include taglib_module }
+                                             as_object = as_class.new
+                                             as_object.copy_instance_variables_from(self)
+                                             instance_variable_set(ivar, as_object)
+                                           end
+          end
+        else
+          class_or_module.send(:include, @module)
+          class_or_module.tag_attrs.update(@module.tag_attrs) if @module.respond_to?(:tag_attrs)
         end
-      else
-        class_or_module.send(:include, @module)
-        class_or_module.tag_attrs.update(@module.tag_attrs) if @module.respond_to?(:tag_attrs)
       end
+     
     end
-
+    
   end
+  
 end

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

@@ -28,12 +28,11 @@ module Hobo::Dryml
       end
     end
 
-    def initialize(src, environment, template_path)
+    def initialize(src, environment, template_path, renames={})
       @src = src
-
       @environment = environment # a class or a module
-
       @template_path = template_path.sub(/^#{Regexp.escape(RAILS_ROOT)}/, "")
+      @class_renames = renames
 
       @builder = Template.build_cache[@template_path] || DRYMLBuilder.new(@template_path)
       @builder.set_environment(environment)
@@ -41,7 +40,7 @@ module Hobo::Dryml
       @last_element = nil
     end
 
-    attr_reader :tags, :template_path
+    attr_reader :tags, :template_path, :class_renames
     
     def compile(local_names=[], auto_taglibs=[])
       now = Time.now
@@ -144,7 +143,8 @@ module Hobo::Dryml
 
       when "include"
         include_element(el)
-        # return nothing - the include has no presence in the erb source
+        # return just the newlines to keep line-number matching - the
+        # include has no presence in the erb source
         tag_newlines(el)
         
       when "set-theme"
@@ -179,15 +179,11 @@ module Hobo::Dryml
     def include_element(el)
       require_toplevel(el)
       require_attribute(el, "as", /^#{DRYML_NAME}$/, true)
-      if el.attributes["src"]
-        @builder.add_build_instruction(:include, 
-                                       :name => el.attributes["src"], 
-                                       :as => el.attributes["as"])
-      elsif el.attributes["module"]
-        @builder.add_build_instruction(:module, 
-                                       :name => el.attributes["module"], 
-                                       :as => el.attributes["as"])
+      options = {}
+      %w(src module plugin bundle as).each do |attr|
+        options[attr.to_sym] = el.attributes[attr] if el.attributes[attr]
       end
+      @builder.add_build_instruction(:include, options)
     end
     
 
@@ -247,9 +243,12 @@ module Hobo::Dryml
       unsafe_name = el.attributes["tag"]
       name = Hobo::Dryml.unreserve(unsafe_name)
       if (for_type = el.attributes['for'])
-        type_name = if for_type =~ /^[a-z]/
+        type_name = case for_type
+                    when /^[a-z]/
                       # It's a symbolic type name - look up the Ruby type name
                       Hobo.field_types[for_type].name
+                    when /^_.*_$/
+                      rename_class(for_type)
                     else
                       for_type
                     end.underscore.gsub('/', '__')
@@ -420,9 +419,9 @@ module Hobo::Dryml
                            # holding a proc
                            param_restore_local_name(name)
                          elsif (call_type = polymorphic_call_type(el))
-                           "find_polymorphic_tag(:#{name.underscore}, #{call_type})"
+                           "find_polymorphic_tag(:#{ruby_name name}, #{call_type})"
                          else
-                           ":#{name.underscore}"
+                           ":#{ruby_name name}"
                          end
                "call_tag_parameter(#{to_call}, #{args})"
              else
@@ -430,9 +429,11 @@ module Hobo::Dryml
                  # The tag is a proc available in a local variable
                  "#{param_restore_local_name(name)}.call(#{attributes}, #{parameters})"
                elsif (call_type = polymorphic_call_type(el))
-                 "send(find_polymorphic_tag(:#{name.underscore}, #{call_type}), #{attributes}, #{parameters})"
+                 "send(find_polymorphic_tag(:#{ruby_name name}, #{call_type}), #{attributes}, #{parameters})"
+               elsif attributes == "{}" && parameters == "{}"
+                 "#{ruby_name name}.to_s"
                else
-                 "#{name.underscore}(#{attributes}, #{parameters})"
+                 "#{ruby_name name}(#{attributes}, #{parameters})"
                end
              end
 
@@ -524,7 +525,7 @@ module Hobo::Dryml
     
     
     def param_restore_local_name(name)
-      "_#{name.underscore}_restore"
+      "_#{ruby_name name}_restore"
     end
     
     
@@ -549,7 +550,7 @@ module Hobo::Dryml
     
     
     def param_content_local_name(name)
-      "_#{name.underscore}__default_content"
+      "_#{ruby_name name}__default_content"
     end
     
         
@@ -767,6 +768,12 @@ module Hobo::Dryml
       @gensym_counter += 1
       "#{name}_#{@gensym_counter}"
     end
+    
+    def rename_class(name)
+      name = name[1..-2]
+      name = class_renames[name] while class_renames.has_key?(name)
+      name
+    end
 
   end
 

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

@@ -31,7 +31,7 @@ module Hobo
       end
       
       def inspect
-        "#<EnumString #{(values || []) * ' '}>"
+        name.blank? ? "#<EnumString #{(values || []) * ' '}>" : name
       end
       alias_method :to_s, :inspect
       

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

@@ -16,6 +16,13 @@ module Hobo
     def field(name, *args)
       type = args.shift
       options = args.extract_options!
+      
+      @model.name_attribute            = name.to_sym if options.delete(:name)
+      @model.primary_content_attribute = name.to_sym if options.delete(:description)
+      @model.creator_attribute         = name.to_sym if options.delete(:creator)
+
+      @model.send(:login_attribute=, name.to_sym, options.delete(:validate)) if @model < User && options.delete(:login)
+      
       @model.send(:set_field_type, name => type) unless
         type.in?(@model.connection.native_database_types.keys - [:text])
       @model.field_specs[name] = FieldSpec.new(@model, name, type, options)

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

@@ -15,6 +15,10 @@ module Hobo
     def super_user?
       false
     end
+    
+    def administrator?
+      false
+    end
 
   end
 

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

@@ -54,8 +54,8 @@ module Hobo
       # TODO - what if you want if_available as a query param?
       if_available = params.delete(:if_available)
       return nil if if_available && 
-        ((action.nil? && obj.respond_to?(:typed_id) && !linkable?(obj.class, :show, subsite)) ||
-         (action.nil? && obj.is_a?(Class) &&           !linkable?(obj, :index, subsite)))
+        ((action.nil? && obj.respond_to?(:typed_id) && !linkable?(obj.class, :show,  :subsite => subsite)) ||
+         (action.nil? && obj.is_a?(Class) &&           !linkable?(obj,       :index, :subsite => subsite)))
       
       base = subsite.blank? ? base_url : "/#{subsite}#{base_url}"
       
@@ -195,7 +195,11 @@ module Hobo
      
     def can_edit?(*args)
       if args.empty?
-        this_parent && this_field && can_edit?(this_parent, this_field)
+        if this_parent && this_field
+          can_edit?(this_parent, this_field)
+        else
+          can_edit?(this, nil)
+        end
       else
         object, field = args.length == 2 ? args : [this, args.first]
         
@@ -300,10 +304,11 @@ module Hobo
     end
      
      
-    def create_model(model)
-      n = model.new
-      n.set_creator(current_user)
-      n
+    def new_for_current_user(model_or_assoc=nil)
+      model_or_assoc ||= this
+      record = model_or_assoc.new
+      record.set_creator(current_user)
+      record
     end
     
     
@@ -356,11 +361,34 @@ module Hobo
       end
     end
     
-    def linkable?(obj, action, subsite=self.subsite)
-      Hobo::ModelRouter.linkable?(subsite, obj, action)
+    def linkable?(*args)
+      options = args.extract_options!
+      target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
+      action = args.first
+
+      if target.is_a?(Class)
+        klass = target
+        action ||= :index
+      elsif target.respond_to?(:member_class)
+        klass = target.member_class
+        action ||= :show
+      else
+        klass = target.class
+        action ||= :show
+      end      
+      
+      Hobo::ModelRouter.linkable?(subsite, klass, action.to_sym)
     end
    
     
+    # Convenience helper for the default app
+    
+    def front_models
+      Hobo.models.select {|m| linkable?(m) && !(m < Hobo::User)}
+    end
+    
+    
+    
     # debugging support
      
     def abort_with(*args)