hobo 0.7.0 → 0.7.1

data/hobo_files/plugin/init.rb

@@ -17,8 +17,6 @@ require 'hobo/dryml/taglib'
 require 'hobo/dryml/template_environment'
 require 'hobo/dryml/template_handler'
 
-require 'hobo/plugins'
-
 require 'extensions/test_case' if RAILS_ENV == "test"
 
 # Rich data types

data/hobo_files/plugin/lib/active_record/has_many_association.rb

@@ -24,15 +24,6 @@ module ActiveRecord::Associations
     end
     
     
-    def include?(record)
-      if loaded?
-        target.include?(record)
-      else
-        (r = find(record.id)) && r == record rescue false
-      end
-    end
-    
-    
     def member_class
       proxy_reflection.klass
     end

data/hobo_files/plugin/lib/active_record/has_many_through_association.rb

@@ -2,16 +2,6 @@ module ActiveRecord::Associations
 
   class HasManyThroughAssociation
 
-    def include?(record)
-      return false unless record.is_a? ActiveRecord::Base
-      
-      if loaded?
-        target.include?(record)
-      else
-        !!find_by_id(record.id)
-      end
-    end
-    
     def member_class
       proxy_reflection.klass
     end

data/hobo_files/plugin/lib/hobo.rb

@@ -47,7 +47,7 @@ module Hobo
     
     def models
       unless @models_loaded
-        Dir.entries("#{RAILS_ROOT}/app/models/").map do |f|
+        Dir.entries("#{RAILS_ROOT}/app/models/").each do |f|
           f =~ /^[a-zA-Z_][a-zA-Z0-9_]*\.rb$/ and f.sub(/.rb$/, '').camelize.constantize
         end
         @models_loaded = true
@@ -111,7 +111,8 @@ module Hobo
 
     def find_by_search(query)
       sql = Hobo.models.map do |model|
-        if model.superclass == ActiveRecord::Base # filter out STI subclasses
+        if model.superclass == ActiveRecord::Base && # filter out STI subclasses
+            ModelRouter.linkable?(nil, model, :show) # filter out non-linkables
           cols = model.search_columns
           if cols.blank?
             nil
@@ -208,54 +209,66 @@ module Hobo
 
 
     def can_edit?(person, object, field)
-      setter = "#{field.to_s.sub /\?$/, ''}=" 
-      return false unless can_view?(person, object, field) and object.respond_to?(setter)
+      # Can't view implies can't edit
+      return false if !can_view?(person, object, field)
       
-      refl = object.class.reflections[field.to_sym] if object.is_a?(ActiveRecord::Base)
-      
-      # has_one and polymorphic associations are not editable (for now)
-      return false if refl and (refl.options[:polymorphic] or refl.macro == :has_one)
-      
-      if object.has_hobo_method?(:editable_by?)
-        check_permission(:edit, person, object, field.to_sym)
-      elsif object.has_hobo_method?("#{field}_editable_by?")
-        object.send("#{field}_editable_by?", person)
+      if field.nil?
+        if respond_to?(:editable_by?)
+          object.editable_by?(person) 
+        else
+          object.updatable_by?(person, nil)
+        end
+        
       else
-        # Fake an edit test by setting the field in question to
-        # Hobo::Undefined and then testing for update permission
+        setter = "#{field.to_s.sub /\?$/, ''}=" 
+        return false if !object.respond_to?(setter)
         
-        # This technique is not suitable for has_many associations
-        return false if refl._?.macro == :has_many
+        refl = object.class.reflections[field.to_sym] if object.is_a?(ActiveRecord::Base)
         
-        current = object.send(field)
-        new = object.duplicate
-
-        begin
-          # Setting the undefined value can sometimes result in an
-          # UndefinedAccessError. In that case we have no choice but
-          # return false.
-          new.send(setter, if current == true
-                             false
-                           elsif current == false
-                             true
-                           elsif refl and refl.macro == :belongs_to
-                             Hobo::Undefined.new(refl.klass)
-                           else
-                             Hobo::Undefined.new
-                           end)
-        rescue Hobo::UndefinedAccessError
-          raise HoboError, ("#{object.class.name}##{field} does not support undefined assignements, " + 
-                            "define editable_by?(user, field)")
-        end
+        # has_one and polymorphic associations are not editable (for now)
+        return false if refl and (refl.options[:polymorphic] or refl.macro == :has_one)
         
-        begin
-          if object.new_record?
-            check_permission(:create, person, new)
-          else
-            check_permission(:update, person, object, new)
+        if object.has_hobo_method?("#{field}_editable_by?")
+          object.send("#{field}_editable_by?", person)
+        elsif object.has_hobo_method?(:editable_by?)
+          check_permission(:edit, person, object)
+        else
+          # Fake an edit test by setting the field in question to
+          # Hobo::Undefined and then testing for update permission
+          
+          # This technique is not suitable for has_many associations
+          return false if refl._?.macro == :has_many
+          
+          current = object.send(field)
+          new = object.duplicate
+
+          begin
+            # Setting the undefined value can sometimes result in an
+            # UndefinedAccessError. In that case we have no choice but
+            # return false.
+            new.send(setter, if current == true
+                               false
+                             elsif current == false
+                               true
+                             elsif refl and refl.macro == :belongs_to
+                               Hobo::Undefined.new(refl.klass)
+                             else
+                               Hobo::Undefined.new
+                             end)
+          rescue Hobo::UndefinedAccessError
+            raise HoboError, ("#{object.class.name}##{field} does not support undefined assignements, " + 
+                              "define editable_by?(user, field)")
+          end
+          
+          begin
+            if object.new_record?
+              check_permission(:create, person, new)
+            else
+              check_permission(:update, person, object, new)
+            end
+          rescue Hobo::UndefinedAccessError
+            false
           end
-        rescue Hobo::UndefinedAccessError
-          false
         end
       end
     end

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

@@ -0,0 +1,222 @@
+require 'extensions'
+
+module ::Hobo
+  
+  class Bundle
+    
+    @bundles = HashWithIndifferentAccess.new
+    
+    class << self
+      
+      attr_accessor :bundles, :plugin
+      
+      def inherited(base)
+        filename = caller[0].match(/^(.*):\d+/)[1]
+        dirname = filename.match(%r(^.*/plugins/[^/]+))[0]
+        base.plugin = File.basename(dirname)
+        
+        base.meta_eval do 
+          attr_accessor :models, :controllers
+        end
+        
+        base.models      = []
+        base.controllers = []
+        
+        eval_ruby_files(base, "#{dirname}/models")
+        eval_ruby_files(base, "#{dirname}/controllers") 
+      end
+      
+      
+      def bundle_model(name, &block)
+        models << [name, block]
+      end
+
+      
+      def bundle_model_controller(model_name, &block)
+        controllers << [model_name, block]
+      end
+      
+      
+      private
+      
+      def eval_ruby_files(base, dir)
+        Dir["#{dir}/*.rb"].each do |f|
+          base.instance_eval(File.read(f), f, 1)
+        end
+      end
+      
+    end
+    
+    def initialize(*args)
+      options = defaults.with_indifferent_access
+      options.update(args.extract_options!)
+      
+      self.name = args.first || self.class.name.match(/[^:]+$/)[0].underscore
+      Bundle.bundles[name] = self
+      
+      @renames, @options = separate_renames(options)
+      
+      includes
+
+      create_models
+      create_controllers
+      
+      init
+    end
+    
+    attr_accessor :renames, :options, :name
+    
+    # optionally overridden by the bundle subclass
+    def includes; end
+    def init;     end
+    def defaults; {}; end
+
+    
+    def plugin
+      self.class.plugin
+    end
+    
+    
+    def create_models
+      self.class.models.each do |name, block|
+        klass = make_class(new_name_for(name), ActiveRecord::Base) do
+          hobo_model
+        end
+        klass.class_eval(&block)
+      end
+    end
+    
+    
+    def create_controllers
+      bundle = self
+      self.class.controllers.each do |model_name, block|
+        klass = make_class("#{new_name_for(model_name).to_s.pluralize}Controller", ApplicationController) do 
+          hobo_model_controller
+        end
+        klass.class_eval(&block)
+      end
+    end
+    
+    
+    def make_class(name, base_class, &b)
+      bundle = self
+      klass = Class.new(base_class) do
+        # Nasty hack because blocks can't take blocks
+        # Roll on Ruby 1.9
+        def self.feature(name, &block)
+          _feature(name, block)
+        end
+      end
+      
+      klass.meta_def(:bundle) do 
+        bundle
+      end
+      
+      klass.meta_def(:_feature) do |feature, block|
+        has_feature = bundle.options[feature]
+        if has_feature
+          define_method("features_#{feature}?") { true }
+          meta_def("features_#{feature}?") { true }
+          block.call if block
+        else
+          define_method("features_#{feature}?") { false }
+          meta_def("features_#{feature}?") { false }
+        end      
+      end
+      silence_warnings { Object.const_set(name, klass) }
+      
+      klass.meta_def :method_missing do |name, *args|
+        if name.to_s =~ /^_.*_$/
+          bundle.magic_option(name)
+        else
+          super
+        end
+      end
+      
+      klass.class_eval(&b) if b
+      klass
+    end
+    
+    
+    def new_name_for(name)
+      while renames.has_key?(name)
+        name = renames[name] 
+        name2 = name.to_s.gsub(/_.*?_/) { |s| new_name_for(s[1..-2]) }
+        
+        # Make sure symbols stay symbols
+        name = name.is_a?(Symbol) ? name2.to_sym : name2
+      end
+      name
+    end
+    
+    
+    def separate_renames(options)
+      simple_options, renames = HashWithIndifferentAccess.new, HashWithIndifferentAccess.new
+      options.each do |k, v| 
+        if k.to_s =~ /^[A-Z]/
+          renames[k] = v.to_s
+          renames[k.to_s.underscore] = v.to_s.underscore.to_sym
+          renames[k.to_s.underscore.pluralize] = v.to_s.underscore.pluralize.to_sym
+        else
+          simple_options[k] = v
+        end
+      end
+      [renames, simple_options]
+    end
+    
+    
+    def customize(name, &block)
+      new_name_for(name).to_s.constantize.class_eval(&block)
+    end
+    
+    
+    def method_missing(name, *args)
+      if name.to_s =~ /^_.*_$/
+        magic_option(name)
+      else
+        super
+      end
+    end
+    
+    
+    # Returns the option value or renamed class name from a 'magic'
+    # name like _foo_ or _MyFoo_
+    def magic_option(name)
+      option_name = name.to_s[1..-2]
+      if option_name == "bundle"
+        self.name
+      elsif options.has_key?(option_name)
+        options[option_name]
+      else
+        new_name_for(option_name)
+      end 
+    end
+    
+    
+    def optional_bundle(*args)
+      local_options = args.extract_options!
+      class_name, option_name = args
+      option_name ||= class_name.to_s.underscore
+      _include_bundle(class_name, option_name, local_options) if self.options[option_name]
+    end
+    
+    
+    def include_bundle(*args)
+      local_options = args.extract_options!
+      class_name, option_name = args
+      option_name ||= class_name.to_s.underscore
+      _include_bundle(class_name, option_name, local_options)
+    end
+    
+    
+    def _include_bundle(class_name, option_name, local_options)
+      external_options = self.options[option_name]
+      external_options = {} if external_options.nil? || external_options == true
+      name = "#{self.name}_#{option_name}"
+      class_name.to_s.constantize.new(name, external_options.merge(local_options).merge(renames))
+      self.options["#{option_name}_bundle"] = name
+    end
+
+  end
+  
+end

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

@@ -32,12 +32,9 @@ module Hobo
       attr_reader :included_taglibs
 
       def include_taglib(src, options={})
-        @included_taglibs << if options[:from_plugin]
-                               'plugins/' + options[:from_plugin] + '/taglibs/' + src
-                             else
-                               src.to_s
-                             end
+        @included_taglibs << options.merge(:src => src)
       end
+      
     end
 
     

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

@@ -24,8 +24,8 @@ module Hobo
 
     EMPTY_PAGE = "[tag-page]"
 
-    APPLICATION_TAGLIB = "taglibs/application"
-    CORE_TAGLIB = "plugins/hobo/tags/core"
+    APPLICATION_TAGLIB = { :src => "taglibs/application" }
+    CORE_TAGLIB        = { :src => "core", :plugin => "hobo" }
     
     DEFAULT_IMPORTS = [Hobo::HoboHelper, ApplicationHelper]
 
@@ -61,10 +61,11 @@ module Hobo
         page ||= view.instance_variable_get('@hobo_template_path')
 
         prepare_view!(view)
-        included_taglibs = ([subsite_taglib(page)] + controller_taglibs(page)).compact
+        included_taglibs = ([subsite_taglib(page)] + controller_taglibs(view.controller.class)).compact
 
         if page.ends_with?(EMPTY_PAGE)
-          controller_class = controller_class_for(page)
+          # DELETE ME: controller_class = controller_class_for(page)
+          controller_class = view.controller.class
           @tag_page_renderer_classes[controller_class.name] ||= 
             make_renderer_class("", page, local_names, DEFAULT_IMPORTS, included_taglibs)
           @tag_page_renderer_classes[controller_class.name].new(page, view)
@@ -87,14 +88,14 @@ module Hobo
       end
       
       
+      # TODO: Delete this - not needed (use view.controller.class)
       def controller_class_for(page)
         controller, view = Controller.controller_and_view_for(page)
         "#{controller.camelize}Controller".constantize
       end
       
       
-      def controller_taglibs(page)
-        controller_class = controller_class_for(page)
+      def controller_taglibs(controller_class)
         (controller_class.respond_to?(:included_taglibs) && controller_class.included_taglibs) || []
       end
       
@@ -103,7 +104,7 @@ module Hobo
         parts = page.split("/")
         if parts.length == 3
           subsite = parts.first
-          "taglibs/#{subsite}" if File.exists?("#{RAILS_ROOT}/app/views/taglibs/#{subsite}.dryml")
+          { :src => "taglibs/#{subsite}" } if File.exists?("#{RAILS_ROOT}/app/views/taglibs/#{subsite}.dryml")
         end
       end