hobo 0.5.3 → 0.6

data/hobo_files/plugin/generators/hobo_user_model/USAGE

@@ -4,23 +4,13 @@ Description:
     The generator takes a model name as its argument.  The model name may be given in CamelCase or under_score and
     should not be suffixed with 'Model'.
 
-    As additional parameters, the generator will take attribute pairs described by name and type. These attributes will
-    be used to prepopulate the migration to create the table for the model and give you a set of predefined fixture.    
-    You don't have to think up all attributes up front, but it's a good idea of adding just the baseline of what's 
-    needed to start really working with the resource.
-
     The generator creates a model class in app/models, a test suite in test/unit, test fixtures in
-    test/fixtures/singular_name.yml, and a migration in db/migrate.
+    test/fixtures/singular_name.yml.
 
 Examples:
-    ./script/generate model account
+    ./script/generate hobo_model account
 
         This will create an Account model:
             Model:      app/models/account.rb
             Test:       test/unit/account_test.rb
             Fixtures:   test/fixtures/accounts.yml
-            Migration:  db/migrate/XXX_add_accounts.rb
-
-    ./script/generate model post title:string created_on:date body:text published:boolean
-    
-        Creates post model with predefined attributes.

data/hobo_files/plugin/generators/hobo_user_model/hobo_user_model_generator.rb

@@ -1,5 +1,4 @@
 class HoboUserModelGenerator < Rails::Generator::NamedBase
-  default_options :skip_migration => false
 
   def manifest
     record do |m|
@@ -15,24 +14,12 @@ class HoboUserModelGenerator < Rails::Generator::NamedBase
       m.template 'model.rb',      File.join('app/models', class_path, "#{file_name}.rb")
       m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
       m.template 'fixtures.yml',  File.join('test/fixtures', class_path, "#{table_name}.yml")
-
-      unless options[:skip_migration]
-        m.migration_template 'migration.rb', 'db/migrate', :assigns => {
-          :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
-        }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
-      end
     end
   end
 
   protected
     def banner
-      "Usage: #{$0} generate ModelName [field:type, field:type]"
+      "Usage: #{$0} #{spec.name} ModelName"
     end
 
-    def add_options!(opt)
-      opt.separator ''
-      opt.separator 'Options:'
-      opt.on("--skip-migration",
-             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
-    end
 end

data/hobo_files/plugin/generators/hobo_user_model/templates/fixtures.yml

@@ -1,11 +1,5 @@
 # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
 one:
   id: 1
-<% for attribute in attributes -%>
-  <%= attribute.name %>: <%= attribute.default %>
-<% end -%>
 two:
   id: 2
-<% for attribute in attributes -%>
-  <%= attribute.name %>: <%= attribute.default %>
-<% end -%>

data/hobo_files/plugin/generators/hobo_user_model/templates/model.rb

@@ -3,14 +3,21 @@ class <%= class_name %> < ActiveRecord::Base
   hobo_model
 
   include Hobo::AuthenticatedUser
+
+  fields do
+    username :string
+    timestamps
+  end
   
   set_login_attr :username
   
-  alias_attribute :display_name, :username
+  alias_attribute :to_s, :username
 
   # --- Hobo Permissions --- #
 
   def super_user?
+    # Return true to make this user exempt from permission restrictions
+    # e.g.
     # login == 'admin'
   end
 

data/hobo_files/plugin/init.rb

@@ -15,6 +15,8 @@ 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"
 
 
@@ -33,8 +35,10 @@ class ActionController::Base
 
 end
 
-def (ActiveRecord::Base).hobo_model
-  include Hobo::Model
+class ActiveRecord::Base
+  def self.hobo_model
+    include Hobo::Model
+  end
 end
 
 # Default settings

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

@@ -1,24 +1,25 @@
 module ActiveRecord::Associations
 
   class HasManyAssociation
+    
+    def hobo_has_many?
+      Hobo::Model.in?(@owner.class.included_modules)
+    end
 
-    def new(*args)
-      res = build(*args)
-      if @owner.new_record?
-        refl = @owner.class.reverse_reflection(@reflection.name)
-        if refl
-          bta = ActiveRecord::Associations::BelongsToAssociation.new(res, refl)
-          bta.replace(@owner)
-          res.instance_variable_set("@#{refl.name}", bta)
-        end
-      end
+    def build_with_reverse_reflection(*args)
+      res = build_without_reverse_reflection(*args)
+      set_reverse_association(res) if hobo_has_many?
       res
     end
+    alias_method_chain :build, :reverse_reflection
     
 
-    def new_without_appending(attributes = {})
+    def new(attributes = {})
       record = @reflection.klass.new(attributes)
-      set_belongs_to_association_for(record)
+      if hobo_has_many?
+        set_belongs_to_association_for(record)
+        set_reverse_association(record)
+      end
       record
     end
     
@@ -48,6 +49,16 @@ module ActiveRecord::Associations
     end
     alias_method_chain :find, :block
     
+    private
+    
+    def set_reverse_association(object)
+      if @owner.new_record? && (refl = @owner.class.reverse_reflection(@reflection.name))
+        bta = ActiveRecord::Associations::BelongsToAssociation.new(object, refl)
+        bta.replace(@owner)
+        object.instance_variable_set("@#{refl.name}", bta)
+      end      
+    end
+    
   end
 
 end

data/hobo_files/plugin/lib/extensions.rb

@@ -1,43 +1,3 @@
-module Kernel
-  
-  def extract_options_from_args!(args) #:nodoc:
-    args.last.is_a?(Hash) ? args.pop : {}
-  end
-
-end
-
-class Object
-
-  def in?(array)
-    array.include?(self)
-  end
-
-  def not_in?(array)
-    not array.include?(self)
-  end
-  
-  alias_method :is_a_without_multiple_args?, :is_a?
-  def is_a?(*args)
-    args.any? {|a| is_a_without_multiple_args?(a) }
-  end
-  
-  # metaid
-  def metaclass; class << self; self; end; end
-  def meta_eval &blk; metaclass.instance_eval &blk; end
-
-  # Adds methods to a metaclass
-  def meta_def name, &blk
-    meta_eval { define_method name, &blk }
-  end
-
-  # Defines an instance method within a class
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end
-
-end
-
-
 class Module
   
   def inheriting_attr_accessor(*names)
@@ -86,10 +46,70 @@ class Module
       EOS
     end
   end
+  
+  private
+  
+  def bool_attr_accessor(*args)
+    options = extract_options_from_args!(args)
+    (args + options.keys).each {|n| class_eval "def #{n}=(x); @#{n} = x; end" }
+    
+    args.each {|n| class_eval "def #{n}?; !!@#{n}; end" }
+
+    options.keys.each do |n|
+      class_eval %(def #{n}?
+                     if @#{n}.nil? && !instance_variables.include?("@\#{@#{n}}")
+                       @#{n} = #{options[n].inspect}
+                     else
+                       @#{n}
+                     end
+                   end)
+      set_field_type(n => TrueClass) if respond_to?(:set_field_type)
+    end
+  end
+
+end
+
+module Kernel
+  
+  def extract_options_from_args!(args) #:nodoc:
+    args.last.is_a?(Hash) ? args.pop : {}
+  end
+  
+end
+
+class Object
+
+  def in?(array)
+    array.include?(self)
+  end
+
+  def not_in?(array)
+    not array.include?(self)
+  end
+  
+  alias_method :is_a_without_multiple_args?, :is_a?
+  def is_a?(*args)
+    args.any? {|a| is_a_without_multiple_args?(a) }
+  end
+  
+  # metaid
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
 
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
 
 end
 
+
+
 module Enumerable
 
   def omap(method = nil, &b)
@@ -149,6 +169,24 @@ module Enumerable
     each_with_index {|x, i| res << yield(x, i)}
     res
   end
+  
+  def build_hash
+    res = {}
+    each do |x|
+      k, v = yield x
+      res[k] = v
+    end
+    res
+  end
+  
+  def map_hash
+    res = {}
+    each do |x|
+      v = yield x
+      res[x] = v
+    end
+    res
+  end
 
 end
 
@@ -202,8 +240,57 @@ class Hash
     [yes, no]
   end
   
+  def -(keys)
+    res = {}
+    each_pair {|k, v| res[k] = v unless k.in?(keys)}
+    res
+  end
+  
+  def &(keys)
+    res = {}
+    keys.each {|k| res[k] = self[k] if has_key?(k)}
+    res    
+  end
+  
+end
+
+
+class HashWithIndifferentAccess
+  
+  def -(keys)
+    res = {}
+    keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+    each_pair { |k, v| res[k] = v unless k.in?(keys) }
+    res
+  end
+  
+  def &(keys)
+    res = {}
+    keys.each do |k|
+      k = k.to_s if k.is_a?(Symbol)
+      res[k] = self[k] if has_key?(k)
+    end
+    res    
+  end
+  
+  def partition_hash(keys=nil)
+    keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+    yes = {}
+    no = {}
+    each do |k,v|
+      if block_given? ? yield(k,v) : keys.include?(k)
+        yes[k] = v
+      else
+        no[k] = v
+      end
+    end
+    [yes, no]
+  end
+
+
 end
 
+
 class <<ActiveRecord::Base
   alias_method :[], :find
 end
@@ -243,3 +330,10 @@ module PP::ObjectMixin
 
 end
 
+class Proc
+  
+  def call_with_block(*args, &b)
+    call(*args + [b])
+  end
+  
+end

data/hobo_files/plugin/lib/extensions/test_case.rb

@@ -13,7 +13,6 @@ class Test::Unit::TestCase
   module HoboTesting
 
     class HoboHelpers
-      include Hobo::ControllerHelpers
       
       def urlb
         "http://example.com"

data/hobo_files/plugin/lib/hobo.rb

@@ -5,11 +5,20 @@ module Hobo
   class RawJs < String; end
 
   @models = []
-
+  @field_types = HashWithIndifferentAccess.new
+  
   class << self
 
-    attr_accessor :current_theme
+    attr_accessor :current_theme, :field_types
     attr_writer :developer_features
+    
+    def symbolic_type_name(type)
+      field_types.index(type)
+    end
+    
+    def type_name(type)
+      symbolic_type_name(type) || type.name.underscore.gsub("/", "__")
+    end
 
     def developer_features?
       @developer_features
@@ -19,8 +28,8 @@ module Hobo
     def raw_js(s)
       RawJs.new(s)
     end
-
-
+    
+    
     def user_model=(model)
       @user_model = model && model.name
     end
@@ -39,7 +48,7 @@ module Hobo
     def models
       unless @models_loaded
         Dir.entries("#{RAILS_ROOT}/app/models/").map do |f|
-          f =~ /.rb$/ and f.sub(/.rb$/, '').camelize.constantize
+          f =~ /^[a-zA-Z_][a-zA-Z0-9_]*\.rb$/ and f.sub(/.rb$/, '').camelize.constantize
         end
         @models_loaded = true
       end
@@ -124,12 +133,15 @@ module Hobo
     end
 
     def add_routes(map)
+      ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
       require "#{RAILS_ROOT}/app/controllers/application" unless Object.const_defined? :ApplicationController
-
+      require "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
+      
       for model in Hobo.models
         controller_name = "#{model.name.pluralize}Controller"
-        controller = controller_name.constantize if
+        controller = controller_name.constantize if (Object.const_defined? controller_name) || 
           File.exists?("#{RAILS_ROOT}/app/controllers/#{controller_name.underscore}.rb")
+          
         if controller
           web_name = model.name.underscore.pluralize.downcase
 
@@ -156,7 +168,7 @@ module Hobo
             
             for view in controller.show_actions
               map.named_route("#{web_name.singularize}_#{view}",
-                              "#{web_name}/:id;#{view}",
+                              "#{web_name}/:id/#{view}",
                               :controller => web_name,
                               :action => view.to_s,
                               :conditions => { :method => :get })
@@ -210,10 +222,10 @@ module Hobo
     def can_create?(person, object)
       if object.is_a?(Class) and object < ActiveRecord::Base
         object = object.new
-        object.created_by(person)
+        object.set_creator(person)
       elsif Hobo.simple_has_many_association?(object)
-        object = object.new_without_appending
-        object.created_by(person)
+        object = object.new
+        object.set_creator(person)
       end
       check_permission(:create, person, object)
     end
@@ -225,34 +237,49 @@ module Hobo
 
 
     def can_edit?(person, object, field)
-      setter = "#{field}="
+      setter = "#{field.to_s.sub /\?$/, ''}=" 
       return false unless can_view?(person, object, field) and object.respond_to?(setter)
       
       refl = object.class.reflections[field.to_sym] if object.is_a?(ActiveRecord::Base)
       
       # has_many and polymorphic associations are not editable (for now)
-      return false if refl and (refl.macro == :has_many or refl.options[:polymorphic])
-
-      current = object.send(field)
-      new = object.duplicate
-      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)
-
-      begin
-        if object.new_record?
-          check_permission(:create, person, new)
-        else
-          check_permission(:update, person, object, new)
+      return false if refl and (refl.macro == :has_many or refl.options[:polymorphic] or refl.macro == :has_one)
+      
+      if object.respond_to?(:editable_by?)
+        check_permission(:edit, person, object, field.to_sym)
+      else
+        # Fake an edit test by setting the field in question to
+        # Hobo::Undefined and then testing for update permission
+        
+        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} 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
 
@@ -264,12 +291,12 @@ module Hobo
 
     # can_view? has special behaviour if it's passed a class or an
     # association-proxy -- it instantiates the class, or creates a new
-    # instance "in" the association (new_without_appending), and tests
-    # the permission of this object. This means the permission methods
-    # in models can't rely on the instance being properly initialised.
-    # But it's important that it works like this because, in the case
-    # of an association proxy, we don't want to loose the information
-    # that the object belongs_to the proxy owner.
+    # instance "in" the association, and tests the permission of this
+    # object. This means the permission methods in models can't rely
+    # on the instance being properly initialised.  But it's important
+    # that it works like this because, in the case of an association
+    # proxy, we don't want to loose the information that the object
+    # belongs_to the proxy owner.
     def can_view?(person, object, field=nil)
       if field
         field = field.to_sym if field.is_a? String
@@ -278,12 +305,8 @@ module Hobo
         # Special support for classes (can view instances?)
         if object.is_a?(Class) and object < ActiveRecord::Base
           object = object.new
-        elsif object.is_a?(Array)
-          if object.respond_to?(:new_without_appending)
-            object = object.new_without_appending
-          elsif object.respond_to?(:member_class)
-            object = object.member_class.new
-          end          
+        elsif Hobo.simple_has_many_association?(object)
+          object = object.new
         end
       end
       viewable = check_permission(:view, person, object, field)
@@ -309,10 +332,16 @@ module Hobo
     
     def static_tags
       @static_tags ||= begin
-                         path = File.join(File.dirname(__FILE__), "hobo/static_tags")
+                         path = if FileTest.exists?("#{RAILS_ROOT}/config/dryml_static_tags.txt")
+                                    "#{RAILS_ROOT}/config/dryml_static_tags.txt"
+                                else
+                                    File.join(File.dirname(__FILE__), "hobo/static_tags")
+                                end
                          File.readlines(path).omap{chop} 
                        end
     end
+    
+    attr_writer :static_tags
 
     
     private
@@ -327,6 +356,7 @@ module Hobo
                    when :create; :creatable_by?
                    when :update; :updatable_by?
                    when :delete; :deletable_by?
+                   when :edit;   :editable_by?
                    when :view;   :viewable_by?
                    end
       p = if object.respond_to?(obj_method)
@@ -349,5 +379,6 @@ module Hobo
     end
 
   end
+  
 
 end