hobo 0.6 → 0.6.1

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

@@ -258,10 +258,6 @@ module Hobo::Dryml
       dryml_exception("def cannot have both alias_of and alias_current_as", el) if alias_of && alias_current
       dryml_exception("def with alias_of must be empty", el) if alias_of and el.size > 0
       
-      # If we're redefining, we need a statement in the method body
-      # that does the alias_method on the fly.
-      re_alias = ""
-      
       if alias_of || alias_current
         old_name = alias_current ? name : alias_of
         new_name = alias_current ? alias_current : name
@@ -270,12 +266,12 @@ module Hobo::Dryml
       end
       
       res = if alias_of
-              "#{re_alias}<% #{tag_newlines(el)} %>"
+              "<% #{tag_newlines(el)} %>"
             else
               src = if template_name?(name)
-                      template_method(name, re_alias, el)
+                      template_method(name, el)
                     else
-                      tag_method(name, re_alias, el)
+                      tag_method(name, el)
                     end
               src << "<% _register_tag_attrs(:#{name}, #{declared_attributes(el).inspect}) %>"
               
@@ -312,7 +308,7 @@ module Hobo::Dryml
     end
     
     
-    def template_method(name, re_alias, el)
+    def template_method(name, el)
       param_names = param_names_in_template(el)
       
       "<% def #{name}(all_attributes={}, all_parameters={}, &__block__); " +
@@ -322,7 +318,7 @@ module Hobo::Dryml
     end
     
     
-    def tag_method(name, re_alias, el)
+    def tag_method(name, el)
       "<% def #{name}(all_attributes={}, &__block__); " +
         "parameters = nil; " +
         tag_method_body(el) + 
@@ -386,13 +382,16 @@ module Hobo::Dryml
       part_name  = el.attributes['part']
       dom_id = el.attributes['id'] || part_name
       
-      part_src = "<% def #{part_name}_part #{tag_newlines(el)}; new_context do %>" +
+      part_locals = el.attributes["part_locals"]
+      
+      part_src = "<% def #{part_name}_part(#{part_locals}) #{tag_newlines(el)}; new_context do %>" +
         content +
         "<% end; end %>"
       @builder.add_part(part_name, restore_erb_scriptlets(part_src), element_line_num(el))
 
       newlines = "\n" * part_src.count("\n")
-      "<%= call_part(#{attribute_to_ruby(dom_id)}, :#{part_name}) #{newlines} %>"
+      args = [attribute_to_ruby(dom_id), ":#{part_name}", "nil", part_locals].compact
+      "<%= call_part(#{args * ', '}) #{newlines} %>"
     end
     
     

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

@@ -7,61 +7,13 @@ module Hobo::Dryml
         subclass.compiled_local_names = []
       end
       attr_accessor :load_time, :compiled_local_names
-      
-      # --- Local Tags --- #
-      
-      def start_redefine_block(method_names)
-        @_preserved_methods_for_redefine ||= []
-        @_redef_impl_names ||= []
-        
-        methods = {}
-        method_names.each {|m| methods[m] = m.in?(self.methods) && instance_method(m) }
-        @_preserved_methods_for_redefine.push(methods)
-        @_redef_impl_names.push []
-      end
-      
-      
-      def end_redefine_block
-        methods = @_preserved_methods_for_redefine.pop
-        methods.each_pair do |name, method|
-          if method
-            define_method(name, method)
-          else
-            remove_method(name)
-          end
-        end
-        to_remove = @_redef_impl_names.pop
-        to_remove.each {|m| remove_method(m) }
-      end
-      
-      
-      def redefine_nesting
-        @_preserved_methods_for_redefine.length
-      end
-      
-      
-      def redefine_tag(name, proc)
-        impl_name = "#{name}_redefined_#{redefine_nesting}"
-        define_method(impl_name, proc)
-        class_eval "def #{name}(options={}, &b); #{impl_name}(options, b); end"
-        @_redef_impl_names.push(impl_name)
-      end
-      
-      def redefine_template(name, proc)
-        impl_name = "#{name}_redefined_#{redefine_nesting}"
-        define_method(impl_name, proc)
-        class_eval "def #{name}(options={}, template_parameters={}, &b); " +
-          "#{impl_name}(options, template_parameters, b); end"
-        @_redef_impl_names.push(impl_name)
-      end
-
-      # --- end local tags --- #
-      
+           
       
       def _register_tag_attrs(tag_name, attrs)
         @tag_attrs ||= {}
         @tag_attrs[tag_name] = attrs
       end
+     
       
       def tag_attrs
         @tag_attrs ||= {}
@@ -123,6 +75,7 @@ module Hobo::Dryml
 
     
     def merge_attrs(attrs, overriding_attrs)
+      return {}.update(attrs) if overriding_attrs.nil?
       attrs = attrs.with_indifferent_access unless attrs.is_a?(HashWithIndifferentAccess)
       classes = overriding_attrs[:class]
       attrs = add_classes(attrs, *classes.split) if classes
@@ -148,8 +101,8 @@ module Hobo::Dryml
       end
     end
 
-
-    def part_context_model_id
+    
+    def context_id
       if this_parent and this_parent.is_a?(ActiveRecord::Base) and this_field
         this_field_dom_id
       elsif this.respond_to?(:typed_id)
@@ -161,18 +114,18 @@ module Hobo::Dryml
       end
     end
 
-
-    def call_part(dom_id, part_id, part_this=nil)
+    
+    def call_part(dom_id, part_name, part_this=nil, *locals)
       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")
+          @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals)
+          res = send("#{part_name}_part", *locals)
         end
       else
         new_context do
-          @_part_contexts[dom_id] = [part_id, part_context_model_id]
-          res = send("#{part_id}_part")
+          @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals)
+          res = send("#{part_name}_part", *locals)
         end
       end
       res
@@ -326,18 +279,6 @@ module Hobo::Dryml
     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(attributes, locals)
       attributes.symbolize_keys!
       #ensure with and field are not in attributes
@@ -437,7 +378,7 @@ module Hobo::Dryml
     # single hash
     def merge_option_procs(general_proc, overriding_proc)
       if overriding_proc
-        proc { general_proc.call.merge(overriding_proc.call) }
+        proc { merge_attrs(general_proc.call, overriding_proc.call) }
       else
         general_proc
       end
@@ -456,8 +397,24 @@ module Hobo::Dryml
     end
     
     
+    def part_contexts_storage_tag
+      storage = part_contexts_storage
+      storage.blank? ? "" : "<script>\nvar hoboParts = {}\n#{storage}</script>\n"
+    end
+    
+    
+    def part_contexts_storage
+      PartContext.client_side_storage(@_part_contexts, session)
+    end
+    
+    
     def render_tag(tag_name, attributes)
-      (send(tag_name, attributes) + part_contexts_js).strip
+      (send(tag_name, attributes) + part_contexts_storage_tag).strip
+    end
+    
+    
+    def session
+      @view ? @view.session : {}
     end
     
 

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

@@ -12,16 +12,16 @@ module Hobo
     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 
+        @current_user = if session and id = session[:user]
+                          Hobo.object_from_dom_id(id)
+                        else 
+                          Guest.new
+                        end 
     end
      
      
     def logged_in?
-      not current_user.guest?
+      !(current_user.respond_to?(:guest?) && current_user.guest?)
     end
       
       
@@ -128,17 +128,18 @@ module Hobo
     end
     
     
-    def type_name(type=nil)
-      Hobo.type_name(type || this.class)
+    def type_id(type=nil)
+      type ||= this.is_a?(Class) ? this : this_type
+      type == NilClass ? "" : Hobo.type_id(type || this.class)
     end
     
     
     def type_and_field(*args)
       if args.empty?
-        this_parent && this_field && "#{Hobo.type_name(this_parent.class)}_#{this_field}"
+        this_parent && this_field && "#{Hobo.type_id(this_parent.class)}_#{this_field}"
       else
         type, field = args
-        "#{type_name(type)}_#{field}"
+        "#{Hobo.type_id(type)}_#{field}"
       end
     end
      

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

@@ -0,0 +1,12 @@
+module Hobo::Migrations
+  
+  class << self
+    attr_accessor :ignore_tables
+    attr_accessor :ignore_models
+    attr_accessor :ignore
+  end
+  self.ignore_tables = []
+  self.ignore_models = []
+  self.ignore = []
+  
+end

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

@@ -120,7 +120,7 @@ module Hobo
 
       def never_show(*fields)
         @hobo_never_show ||= []
-        @hobo_never_show.concat(fields.omap{to_sym})
+        @hobo_never_show.concat(fields.every(:to_sym))
       end
 
       def never_show?(field)
@@ -142,7 +142,7 @@ module Hobo
       def set_search_columns(*columns)
         class_eval %{
           def self.search_columns
-            %w{#{columns.omap{to_s} * ' '}}
+            %w{#{columns.every(:to_s) * ' '}}
           end
         }
       end
@@ -276,7 +276,7 @@ module Hobo
       end
 
       def search_columns
-        cols = columns.omap{name}
+        cols = columns.every(:name)
         %w{name title body content}.select{|c| c.in?(cols) }
       end
       

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

@@ -8,7 +8,7 @@ module Hobo
 
     VIEWLIB_DIR = "taglibs"
     
-    GENERIC_PAGE_TAGS = [:index, :show, :new, :edit, :show_collection, :new_in_collection]
+    GENERIC_PAGE_TAGS = [:index, :show, :new, :edit, :show_collection, :new_in_collection, :login, :signup]
 
     class << self
 
@@ -295,7 +295,7 @@ module Hobo
         attributes = params[model.name.underscore]
         type_attr = params['type']
         create_model = if 'type'.in?(model.column_names) and 
-                           type_attr and type_attr.in?(model.send(:subclasses).omap{name})
+                           type_attr and type_attr.in?(model.send(:subclasses).every(:name))
                          type_attr.constantize
                        else
                          model
@@ -556,7 +556,7 @@ module Hobo
 
 
     def with_data_filter(operation, *args, &block)
-      filter_param = params.keys.ofind {starts_with? "where_"}
+      filter_param = params.keys.find &it.starts_with?("where_")
       proc = filter_param && self.class.data_filter(filter_param[6..-1].to_sym)
       if proc
         filter_args = params[filter_param]

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

@@ -9,8 +9,8 @@ module Hobo::RapidHelper
     js_options['form']          = options[:form] if options[:form]
     js_options['params']        = make_params_js(options[:params]) if options[:params]
     js_options['resultUpdate']  = js_result_updates(options[:result_update]) if options[:result_update]
-    js_options['resetForm']     = false if options[:reset_form] == false
-    js_options['refocusForm']   = false if options[:refocus_form] == false
+    js_options['resetForm']     = options[:reset_form] if options.has_key?(:reset_form)
+    js_options['refocusForm']   = options[:refocus_form] if options.has_key?(:refocus_form)
     
     js_options.empty? ? nil : options_for_javascript(js_options)
   end
@@ -26,7 +26,7 @@ module Hobo::RapidHelper
   def js_result_updates(updates)
     return '[]' unless updates
     updates = [updates] unless updates.is_a? Array
-    pairs = comma_split(updates).omap{split(/\s*=\s*/)}
+    pairs = comma_split(updates).map &it.split(/\s*=\s*/)
     '[' + pairs.map{|p| "{id: #{js_str(p[0])}, result: #{js_str(p[1])}}"}.join(", ") + ']'
   end
 

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

@@ -0,0 +1,80 @@
+module Hobo
+
+  module UserController
+
+    @user_models = []
+
+    class << self
+      attr_reader :user_models
+      
+      def included(base)
+        base.filter_parameter_logging "password"
+        user_models << base.model
+      end
+    end
+    
+    def login; hobo_login; end
+    
+    def signup; hobo_signup; end
+    
+    def logout; hobo_logout; end
+    
+    def hobo_login(options={})
+      options = options.reverse_merge(:success_notice => "You have logged in.",
+                                      :failure_notice => "You did not provide a valid login and password.",
+                                      :redirect_to => {:action => "index"})
+      
+      if request.post?
+        user = model.authenticate(params[:login], params[:password])
+        if user
+          self.current_user = user
+          if params[:remember_me] == "1"
+            current_user.remember_me
+            create_auth_cookie
+          end
+          redirect_back_or_default(options[:redirect_to])
+          flash[:notice] = options[:success_notice]
+        else
+          flash[:notice] = options[:failure_notice]
+          hobo_render
+        end
+      else
+        hobo_render
+      end
+    end
+
+    
+    def hobo_signup(options={})
+      options = options.reverse_merge(:notice => "Thanks for signing up!",
+                                      :redirect_to => {:action => "index"})
+      if request.post?
+        begin
+          @user = model.new(params[:user])
+          @this = @user
+          @user.save!
+          self.current_user = @user
+          redirect_back_or_default(options[:redirect_to])
+          flash[:notice] = options[:notice]
+        rescue ActiveRecord::RecordInvalid
+          hobo_render
+        end
+      else
+        hobo_render
+      end
+    end
+
+    
+    def hobo_logout(options={})
+      options = options.reverse_merge(:notice => "You have been logged out.",
+                                      :redirect_to => {:action => "index"})
+        
+      current_user.forget_me if logged_in?
+      cookies.delete :auth_token
+      reset_session
+      flash[:notice] = options[:notice]
+      redirect_back_or_default(options[:redirect_to])
+    end
+    
+  end
+  
+end

data/hobo_files/plugin/tags/rapid.dryml

@@ -35,14 +35,31 @@
 </def>
 
 
-<def tag="Table">
-  <table merge_attrs unless="&this.empty?">
-    <thead if="&all_parameters[:thead]" param/>
+<def tag="Table" attrs="fields, field_tag">
+  <% field_tag ||= "view" %>
+  <table merge_attrs="&attributes - attrs_for(:with_fields)" unless="&this.empty?">
+    <thead if="&all_parameters[:thead] || fields" param>
+      <tr param="field_heading_row">
+        <with_field_names merge_attrs="&all_attributes & attrs_for(:with_fields)">
+          <th param="#{this.underscore}_heading"><%= this.titleize %></th>
+        </with_field_names>
+        <th if="&all_parameters[:controls]" class="controls"/>
+      </tr>
+    </thead>
     <tbody>
       <repeat>
         <tr param if="&can_view?"
             class="#{scope.even_odd} #{this_type.name.underscore}"
             hobo_model_id="#{dom_id(this)}">
+          <if test="&fields">
+            <with_fields merge_attrs="&all_attributes & attrs_for(:with_fields)">
+              <td><call_tag tag="&field_tag"/></td>
+            </with_fields>
+            <td class="controls" param="controls" if="&all_parameters[:controls]">
+              <a param="edit_link">Edit</a>
+              <delete_button param/>
+            </td>
+          </if>
         </tr>
       </repeat>      
     </tbody>
@@ -68,7 +85,7 @@
 
 <def tag="card">
   <%= poly = call_polymorphic_tag('card', attributes) %>
-  <div class="card" unless="&poly"><human_type/>: <a/></div>
+  <div class="card" unless="&poly"><type_name/>: <a/></div>
 </def>
   
 
@@ -120,6 +137,19 @@
   end
 %></def>
 
+<def tag="type_name" attrs="type, plural, lowercase"><%=
+  type ||= if this.is_a?(Class)
+             this
+           elsif this.respond_to? :proxy_reflection
+             this.proxy_reflection.klass
+           else
+             this.class
+           end
+  name = type.name.titleize
+  name = name.pluralize if plural
+  name = name.downcase if lowercase
+  name
+%></def>
 
 <def tag="a" attrs="action, to, params, resource_type, href"><%=
   content = tagbody.call if tagbody
@@ -174,7 +204,7 @@
       has_many_view(attributes)
     end
   else
-    attrs = add_classes(attributes, "view", type_name, type_and_field)
+    attrs = add_classes(attributes, "view", type_id, type_and_field)
     attrs[:hobo_model_id] = this_field_dom_id if this_parent && this_parent.respond_to?(:typed_id)
 
     view_tag = find_polymorphic_tag("view")
@@ -210,7 +240,7 @@
 
 <def tag="view" for="Date"><%= this.to_s(:long) %></def>
 
-<def tag="view" for="Time"><%= this.to_s(:long) %></def>
+<def tag="view" for="Time" attrs="format"><%= format ? this.strftime(format) : this.to_s(:long) %></def>
 
 <def tag="view" for="Numeric" attrs="format"><%= format ? format % this : this.to_s %></def>
 
@@ -228,20 +258,6 @@
 
 <def tag="view" for="TrueClass"><%= this ? 'Yes' : 'No' %></def>
 
-<def tag="human_type" attrs="style"><%= 
-      if can_view?
-        res = if this.respond_to? :proxy_reflection
-                this.proxy_reflection.klass.name.pluralize
-              elsif this.is_a? Class
-                this.name
-              else
-                this.class.name
-              end
-        res.underscore.humanize.send(style || :titleize)
-      end
-%></def>
-
-
 <def tag="count" attrs="label, prefix, unless_none"><%=
   raise Exception.new("asked for count of a string") if this.is_a?(String)