hobo 0.5.3 → 0.6

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

@@ -0,0 +1,5 @@
+class Hobo::EmailAddress < String
+  
+  COLUMN_TYPE = :string
+
+end

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

@@ -0,0 +1,66 @@
+module Hobo
+  
+  class FieldSpec
+    
+    class UnknownSqlTypeError < RuntimeError; end
+  
+    def initialize(model, name, type, options={})
+      raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
+      self.model = model
+      self.name = name.to_sym
+      self.type = type.to_sym
+      self.options = options
+      self.position = model.field_specs.length
+    end
+    
+    attr_accessor :model, :name, :type, :position, :options
+    
+    def sql_type
+      options[:sql_type] or begin
+                              sql_types = model.connection.native_database_types.keys - [:primary_key]
+                              if type.in?(sql_types)
+                                type
+                              elsif options[:length]
+                                :string
+                              else
+                                Hobo.field_types[type]::COLUMN_TYPE or raise UnknownSqlTypeError, type
+                              end
+                            end
+    end
+    
+    def limit
+      options[:limit] || types[sql_type][:limit]
+    end
+    
+    def precision
+      options[:precision]
+    end
+    
+    def scale
+      options[:scale]
+    end
+    
+    def null
+      :null.in?(options) ? options[:null] : true
+    end
+    
+    def default
+      options[:default]
+    end
+    
+    def different_to?(col_spec)
+      [:limit, :precision, :scale, :null, :default].any? do |k|
+        # puts "#{col_spec.send(k).inspect} --- #{self.send(k).inspect} : #{col_spec.send(k) != self.send(k)}"
+        col_spec.send(k) != self.send(k)
+      end || sql_type != col_spec.type
+    end
+    
+    private
+    
+    def types
+      @types ||= model.connection.native_database_types
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,325 @@
+module Hobo
+  
+  module HoboHelper
+  
+    def self.add_to_controller(controller)
+      controller.send(:include, self)
+      controller.hide_action(self.instance_methods)
+    end
+     
+    protected
+     
+    def current_user
+      # simple one-hit-per-request cache
+      @current_user or
+        @current_user = if Hobo.user_model and session and id = session[:user]
+                               Hobo.user_model.find(id)
+                             else 
+                               Guest.new
+                             end 
+    end
+     
+     
+    def logged_in?
+      not current_user.guest?
+    end
+      
+      
+    def base_url
+      request.relative_url_root
+    end
+     
+     
+    def controller_for(obj)
+      if obj.is_a? Class
+        obj.name.underscore.pluralize
+      else
+        obj.class.name.underscore.pluralize
+      end
+    end
+     
+     
+    def object_url(obj, action=nil, *param_hashes)
+      action &&= action.to_s
+      
+      controller_name = controller_for(obj)
+      
+      parts = if obj.is_a? Class
+                [base_url, controller_name]
+                
+              elsif obj.is_a? Hobo::CompositeModel
+                [base_url, controller_name, obj.id]
+                
+              elsif obj.is_a? ActiveRecord::Base
+                if obj.new_record?
+                  [base_url, controller_name]
+                else
+                  raise HoboError.new("invalid object url: new for existing object") if action == "new"
+     
+                  klass = obj.class
+                  id = if klass.id_name?
+                         obj.id_name(true)
+                       else
+                         obj.id
+                       end
+                  
+                  [base_url, controller_name, id]
+                end
+                
+              elsif obj.is_a? Array    # warning - this breaks if we use `case/when Array`
+                owner = obj.proxy_owner
+                new_model = obj.proxy_reflection.klass
+                [object_url(owner), obj.proxy_reflection.name]
+                
+              else
+                raise HoboError.new("cannot create url for #{obj.inspect} (#{obj.class})")
+              end
+      basic = parts.join("/")
+      
+      controller = (controller_name.camelize + "Controller").constantize rescue nil
+      url = case action
+            when "new"
+              basic + "/new"
+            when "destroy"
+              basic + "?_method=DELETE"
+            when "update"
+              basic + "?_method=PUT"
+            when nil
+              basic
+            else
+              basic + "/" + action
+            end
+      params = make_params(*param_hashes)
+      params.blank? ? url : url + "?" + params
+    end
+     
+     
+    def _as_params(name, obj)
+      if obj.is_a? Array
+        obj.map {|x| _as_params("#{name}[]", x)}.join("&")
+      elsif obj.is_a? Hash
+        obj.map {|k,v| _as_params("#{name}[#{k}]", v)}.join("&")
+      elsif obj.is_a? Hobo::RawJs
+        "#{name}=' + #{obj} + '"
+      else
+        v = if obj.is_a?(ActiveRecord::Base) or obj.is_a?(Array)
+              "@" + dom_id(obj)
+            else
+              obj.to_s.gsub("'"){"\\'"}
+            end
+        "#{name}=#{v}"
+      end
+    end
+     
+     
+    def make_params(*hashes)
+      hash = {}
+      hashes.each {|h| hash.update(h) if h}
+      hash.map {|k,v| _as_params(k, v)}.join("&")
+    end
+     
+     
+    def dom_id(*args)
+      if args.length == 0
+        Hobo.dom_id(this)
+      else
+        Hobo.dom_id(*args)
+      end
+    end
+    
+    
+    def type_name(type=nil)
+      Hobo.type_name(type || this.class)
+    end
+    
+    
+    def type_and_field(*args)
+      if args.empty?
+        this_parent && this_field && "#{Hobo.type_name(this_parent.class)}_#{this_field}"
+      else
+        type, field = args
+        "#{type_name(type)}_#{field}"
+      end
+    end
+     
+     
+    def map_this
+      res = []
+      this.each_index {|i| new_field_context(i) { res << yield } }
+      Dryml.last_if = !this.empty?
+      res
+    end
+    alias_method :collect_this, :map_this
+     
+     
+    def comma_split(x)
+      case x
+      when nil
+        []
+      when Symbol
+        x.to_s
+      when String
+        x.split(/\s*[, ]\s*/)
+      else
+        x.compact.map{|e| comma_split(e)}.flatten
+      end
+    end
+     
+     
+    def can_create?(object=nil)
+      Hobo.can_create?(current_user, object || this)
+    end
+     
+     
+    def can_update?(object, new)
+      Hobo.can_update?(current_user, object, new)
+    end
+     
+     
+    def can_edit?(*args)
+      if args.empty?
+        this_parent && this_field && can_edit?(this_parent, this_field)
+      else
+        object, field = args.length == 2 ? args : [this, args.first]
+        
+        if !field and object.respond_to?(:proxy_reflection)
+          Hobo.can_edit?(current_user, object.proxy_owner, object.proxy_reflection.name)
+        else
+          Hobo.can_edit?(current_user, object, field)
+        end
+      end
+    end
+     
+     
+    def can_delete?(object=nil)
+      Hobo.can_delete?(current_user, object || this)
+    end
+     
+     
+    def can_view?(object=nil, field=nil)
+      if object.nil? && field.nil?
+        if this_parent && this_field
+          object, field = this_parent, this_field
+        else
+          object = this
+        end
+      end
+      
+      if !field and object.respond_to?(:proxy_reflection)
+        Hobo.can_view?(current_user, object.proxy_owner, object.proxy_reflection.name)
+      else
+        Hobo.can_view?(current_user, object, field)
+      end
+    end
+     
+     
+    def select_viewable(collection)
+      collection.select {|x| can_view?(x)}
+    end
+     
+     
+    def theme_asset(path)
+      theme_path = Hobo.current_theme ? "hobothemes/#{Hobo.current_theme}/" : ""
+      "#{base_url}/#{theme_path}#{path}"
+    end
+     
+    def js_str(s)
+      if s.is_a? Hobo::RawJs
+        s.to_s
+      else
+        "'" + s.gsub("'"){"\\'"} + "'"
+      end
+    end
+     
+     
+    def make_params_js(*args)
+      ("'" + make_params(*args) + "'").sub(/ \+ ''$/,'')
+    end
+     
+     
+    def render_params(*args)
+      parts = args.map{|x| x.split(/, */) if x}.compact.flatten
+      { :part_page => view_name,
+        :render => parts.map do |part_id|
+          { :object => Hobo::RawJs.new("hoboParts.#{part_id}"),
+            :part => part_id }
+        end
+      }
+    end
+     
+     
+    def nl_to_br(s)
+      s.to_s.gsub("\n", "<br/>") if s
+    end
+     
+     
+    def param_name_for(object, field_path)
+      field_path = field_path.to_s.split(".") if field_path.is_a?(String, Symbol)
+      attrs = field_path.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
+      "#{object.class.name.underscore}#{attrs}"
+    end
+     
+     
+    def param_name_for_this(foreign_key=false)
+      return "" unless form_this
+      name = if foreign_key and this_type.respond_to?(:macro) and this_type.macro == :belongs_to
+               param_name_for(form_this, form_field_path[0..-2] + [this_type.primary_key_name])
+             else
+               param_name_for(form_this, form_field_path)
+             end
+      register_form_field(name)
+      name
+    end
+     
+     
+    def selector_type
+      if this.is_a? ActiveRecord::Base
+        this.class
+      elsif this.respond_to? :member_class
+        this.member_class
+      elsif this == @this
+        @model
+      end
+    end
+     
+     
+    def transpose_with_field(field, collection=nil)
+      collection ||= this
+      matrix = collection.map {|obj| obj.send(field) }
+      max_length = matrix.every(:length).max
+      matrix = matrix.map do |a|
+        a + [nil] * (max_length - a.length)
+      end
+      matrix.transpose
+    end
+     
+     
+    def create_model(model)
+      n = model.new
+      n.set_creator(current_user)
+      n
+    end
+    
+    
+    def defined_route?(r)
+      @view.respond_to?("#{r}_url")
+    end
+     
+     
+    # debugging support
+     
+    def abort_with(*args)
+      raise args.map{|arg| PP.pp(arg, "")}.join("-------\n")
+    end
+     
+    def log_debug(*args)
+      logger.debug("\n### DRYML Debug ###")
+      logger.debug(args.map {|a| PP.pp(a, "")}.join("-------\n"))
+      logger.debug("DRYML THIS = #{Hobo.dom_id(this) rescue this.inspect}")
+      logger.debug("###################\n")
+      args.first unless args.empty?
+    end
+    
+  end
+
+end

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

@@ -1,3 +1,5 @@
 class Hobo::HtmlString < String
+  
+  COLUMN_TYPE = :text
 
 end

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

@@ -8,6 +8,7 @@ class Hobo::LazyHash < Hash
     end
   end
   
+  
   def [](key)
     val = super
     if val.is_a?(Proc)
@@ -17,10 +18,21 @@ class Hobo::LazyHash < Hash
     end
   end
   
+  
+  def delete(key)
+    val = super
+    val.is_a?(Proc) ? val.call : val
+  end
+  
+  
   def inspect
-    "#<LazyHash:#{object_id} #{keys.inspect}>"
+    pairs = map do |k, v|
+      "#{k.inspect} => #{v.is_a?(Proc) ? '??' : v.inspect}"
+    end
+    "{#{pairs * ', '}}"
   end
   
+  
   def to_s
     inspect
   end

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

@@ -1,7 +1,9 @@
 class Hobo::MarkdownString < String
   
+  COLUMN_TYPE = :text
+  
   def to_html
-    self.blank? ? "" : BlueCloth.new(self).to_html
+    blank? ? "" : BlueCloth.new(self).to_html
   end
 
 end

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

@@ -2,12 +2,31 @@ module Hobo
 
   module Model
     
+    Hobo.field_types.update({ :html          => HtmlString,
+                              :markdown      => MarkdownString,
+                              :textile       => TextileString,
+                              :password      => PasswordString,
+                              :text          => Hobo::Text,
+                              :boolean       => TrueClass,
+                              :date          => Date,
+                              :datetime      => Time,
+                              :integer       => Fixnum,
+                              :big_integer   => BigDecimal,
+                              :float         => Float,
+                              :string        => String,
+                              :email_address => EmailAddress
+                            })
+    
     def self.included(base)
       Hobo.register_model(base)
       base.extend(ClassMethods)
-      base.set_field_type({})
+      base.class_eval do
+        @field_specs  = HashWithIndifferentAccess.new
+        set_field_type({})
+      end
       class << base
         alias_method_chain :has_many, :defined_scopes
+        alias_method_chain :belongs_to, :foreign_key_declaration
       end
     end
 
@@ -16,43 +35,72 @@ module Hobo
       # include methods also shared by CompositeModel
       include ModelSupport::ClassMethods
       
+      private
+      
+      def return_type(type)
+        @next_method_type = type
+      end
+      
       def method_added(name)
-        # avoid error when running model generators before
-        # db exists
-        return unless connected? 
+        if @next_method_type
+          set_field_type(name => @next_method_type)
+          @next_method_type = nil
+        end
+      end
+      
+      
+      class FieldDeclarationsDsl
         
-        aliased_name = "#{name}_without_hobo_type"
-        return if name.to_s.ends_with?('without_hobo_type') or aliased_name.in?(instance_methods)
+        def initialize(model)
+          @model = model
+        end
         
-        type_wrapper = self.field_type(name)
-        if type_wrapper && type_wrapper.is_a?(Class) && type_wrapper < String
-          aliased_name = "#{name}_without_hobo_type"
-          alias_method aliased_name, name
-          define_method name do
-            res = send(aliased_name)
-            if res.nil?
-              nil
-            elsif res.respond_to?(:hobo_undefined?) && res.hobo_undefined?
-              res
-            else
-              type_wrapper.new(res)
-            end
-          end
+        attr_reader :model
+        
+        def timestamps
+          field(:created_at, :datetime)
+          field(:updated_at, :datetime)
+        end
+        
+        def field(name, *args)
+          type = args.shift
+          options = extract_options_from_args!(args)
+          @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)
+        end
+        
+        def method_missing(name, *args)
+          field(name, *args)
         end
+        
       end
       
+      
+      def fields(&b)
+        FieldDeclarationsDsl.new(self).instance_eval(&b)
+      end
+      
+      
+      def belongs_to_with_foreign_key_declaration(name, *args, &block)
+        res = belongs_to_without_foreign_key_declaration(name, *args, &block)
+        refl = reflections[name]
+        fkey = refl.primary_key_name
+        field_specs[fkey] ||= FieldSpec.new(self, fkey, :integer)
+        if refl.options[:polymorphic]
+          type_col = "#{name}_type"
+          field_specs[type_col] ||= FieldSpec.new(self, type_col, :string)
+        end
+        res
+      end
+      
+      
+      attr_reader :field_specs
+      public :field_specs
+      
       def set_field_type(types)
         types.each_pair do |field, type|
-          
-          # TODO: Make this extensible
-          type_class = case type
-                       when :html; HtmlString
-                       when :markdown; MarkdownString
-                       when :textile; TextileString
-                       when :password; PasswordString
-                       else type
-                       end
-          
+          type_class = Hobo.field_types[type] || type
           field_types[field] = type_class
         end
       end
@@ -75,10 +123,10 @@ module Hobo
         @hobo_never_show.concat(fields.omap{to_sym})
       end
 
-
       def never_show?(field)
         @hobo_never_show and field.to_sym.in?(@hobo_never_show)
       end
+      public :never_show?
 
       def set_creator_attr(attr)
         class_eval %{
@@ -143,12 +191,12 @@ module Hobo
           underscore
       end
 
-
+      public
+      
       def id_name?
         respond_to?(:find_by_id_name)
       end
 
-
       attr_reader :id_name_column
 
       
@@ -156,15 +204,24 @@ module Hobo
       def field_type(name)
         name = name.to_sym
         field_types[name] or
-          reflections[name] or
-          ((col = columns.find {|c| c.name == name.to_s}) and case col.type
-                                                              when :boolean
-                                                                TrueClass
-                                                              when :text
-                                                                Hobo::Text
-                                                              else
-                                                                col.klass
-                                                              end)
+          reflections[name] or begin
+                                 col = columns.find {|c| c.name == name.to_s} rescue nil
+                                 return nil if col.nil?
+                                 case col.type
+                                 when :boolean
+                                   TrueClass
+                                 when :text
+                                   Hobo::Text
+                                 else
+                                   col.klass
+                                 end
+                               end
+      end
+
+      
+      def nilable_field?(name)
+        col = columns.find {|c| c.name == name.to_s} rescue nil
+        col.nil? || col.null
       end
       
       
@@ -244,20 +301,35 @@ module Hobo
       
       class ScopedProxy
         def initialize(klass, scope={})
-          @klass, @scope = klass, scope
+          @klass = klass
+          
+          # If there's no :find, or :create specified, assume it's a find scope
+          @scope = if scope.has_key?(:find) || scope.has_key?(:create)
+                     scope
+                   else
+                     { :find => scope }
+                   end
         end
         
         def method_missing(name, *args, &block)
-          klass.with_scope(@scope) do
+          @klass.send(:with_scope, @scope) do
             @klass.send(name, *args, &block)
           end
         end
+        
+        def all
+          self.find(:all)
+        end
+        
+        def first
+          self.find(:first)
+        end
       end
       (Object.instance_methods + 
        Object.private_instance_methods +
        Object.protected_instance_methods).each do |m|
         ScopedProxy.send(:undef_method, m) unless
-          m.in?(%w{initialize method_missing}) || m.starts_with?('_')
+          m.in?(%w{initialize method_missing send}) || m.starts_with?('_')
       end
       
       attr_accessor :defined_scopes
@@ -278,24 +350,35 @@ module Hobo
         attr_accessor :reflections
         
         def method_missing(name, *args, &block)
-          scopes = proxy_reflection.klass.defined_scopes
-          scope = scopes && scopes[name.to_sym]
-          if scope
-            scope = scope.call(*args) if scope.is_a?(Proc)
-            
-            # Calling directly causes self to get loaded
+          scope = (proxy_reflection.klass.respond_to?(:defined_scopes) and
+                   scopes = proxy_reflection.klass.defined_scopes and 
+                   scopes[name.to_sym])
+          
+          scope = scope.call(*args) if scope.is_a?(Proc)
+          
+          # If there's no :find, or :create specified, assume it's a find scope
+          find_scope = if scope && (scope.has_key?(:find) || scope.has_key?(:create))
+                         scope[:find]
+                       else
+                         scope
+                       end
+          
+          if find_scope
+            # Calling instance_variable_get directly causes self to
+            # get loaded, hence this trick
             assoc = Kernel.instance_method(:instance_variable_get).bind(self).call("@#{name}")
+            
             unless assoc
               options = proxy_reflection.options
-              has_many_conditions = options.has_key?(:condition)
-              scope_conditions = scope.delete(:conditions)
+              has_many_conditions = options.has_key?(:conditions)
+              scope_conditions = find_scope.delete(:conditions)
               conditions = if has_many_conditions && scope_conditions
                              "(#{scope_conditions}) AND (#{has_many_conditions})"
                            else
                              scope_conditions || has_many_conditions
                            end
               
-              options = options.merge(scope).update(:conditions => conditions,
+              options = options.merge(find_scope).update(:conditions => conditions,
                                                     :class_name => proxy_reflection.klass.name,
                                                     :foreign_key => proxy_reflection.primary_key_name)
               r = ActiveRecord::Reflection::AssociationReflection.new(:has_many,
@@ -336,18 +419,7 @@ module Hobo
     end
     
     
-    def method_missing(name, *args, &b)
-      val = super
-      if val.nil?
-        nil
-      else
-        type_wrapper = self.class.field_type(name)
-        (type_wrapper && type_wrapper.is_a?(Class) && type_wrapper < String) ? type_wrapper.new(val) : val
-      end
-    end
-
-
-    def created_by(user)
+    def set_creator(user)
       self.creator ||= user if self.class.has_creator? and not user.guest?
     end
 
@@ -381,11 +453,58 @@ module Hobo
       CompositeModel.new_for([self, object])
     end
     
+    def created_date
+      created_at.to_date
+    end
     
+    def modified_date
+      modified_at.to_date
+    end
+
     def typed_id
       id ? "#{self.class.name.underscore}_#{self.id}" : nil
     end
     
+    def to_s
+      if respond_to? :title
+        title
+      elsif respond_to? :name
+        name
+      else
+        "#{self.class.name.humanize} #{id}"
+      end
+    end
+    
   end
 end
 
+
+# Hack AR to get Hobo type wrappers in
+
+module ActiveRecord::AttributeMethods::ClassMethods
+
+  # Define an attribute reader method.  Cope with nil column.
+  def define_read_method(symbol, attr_name, column)
+    cast_code = column.type_cast_code('v') if column
+    access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+
+    unless attr_name.to_s == self.primary_key.to_s
+      access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+    end
+
+    # This is the Hobo hook - add a type wrapper around the field
+    # value if we have a special type defined
+    src = if connected? && respond_to?(:field_type) && (type_wrapper = field_type(symbol)) &&
+              type_wrapper.is_a?(Class) && type_wrapper < String
+            "val = begin; #{access_code}; end; " +
+              "if val.nil?; nil; " +
+              "elsif val.respond_to?(:hobo_undefined?) && val.hobo_undefined?; val; " + 
+              "else; #{type_wrapper}.new(val); end"
+          else
+            access_code
+          end
+    
+    evaluate_attribute_method(attr_name, 
+                              "def #{symbol}; @attributes_cache['#{attr_name}'] ||= begin; #{src}; end; end")
+  end
+end