hobo 0.5.3

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

@@ -0,0 +1,92 @@
+module Hobo
+
+  class ModelQueries
+
+    def initialize(model)
+      @model = model
+    end
+
+
+    attr_reader :model
+
+    def not_(fragment)
+      WhereFragment.new("not (#{fragment.to_sql})")
+    end
+
+
+    def is_in(association)
+      association = Hobo.object_from_dom_id(association) if association.is_a? String
+      refl = association.proxy_reflection
+      raise HoboError.new("association #{refl.name} is not a collection of #{model.name.pluralize}") unless
+        refl.klass == model and refl.macro == :has_many
+
+      WhereFragment.new(_association_finder_sql(association))
+    end
+    
+    
+    def not_in(association)
+      not_(is_in(association))
+    end
+
+
+    def method_missing(name, *args)
+      check_column = proc do |col|
+        raise HoboError.new("no such column '#{col}' in query") unless
+          model.columns.every(:name).include? col
+      end
+
+      m, field = *name.to_s.match(/^(.*)_is$/)
+      if m
+        if (refl = model.reflections[field.to_sym]) and refl.macro == :belongs_to
+          field = refl.primary_key_name
+          val = args[0] && args[0].id
+          raise HoboError.new("don't use self in query blocks") if val == self
+        else 
+          check_column[field]
+          val = args[0]
+        end
+        return (if val.nil?
+                  WhereFragment.new("#{field} IS NULL")
+                else
+                  WhereFragment.new("#{field} = ?", val)
+                end)
+      end
+
+      m, field = *name.to_s.match(/^(.*)_contains$/)
+      if m
+        check_column[field]
+        return WhereFragment.new("#{field} like ?", "%#{args[0]}%")
+      end
+
+      m, field = *name.to_s.match(/^(.*)_starts$/)
+      if m
+        check_column[field]
+        return WhereFragment.new("#{field} like ?", "#{args[0]}%")
+      end
+
+      m, field = *name.to_s.match(/^(.*)_ends$/)
+      if m
+        check_column[field]
+        return WhereFragment.new("#{field} like ?", "%#{args[0]}")
+      end
+
+      return WhereFragment.new(@model.send(name, *args))
+    end
+
+    def _association_finder_sql(assoc)
+      refl = assoc.proxy_reflection
+      if refl.through_reflection
+        conditions = assoc.send(:construct_conditions)
+        from       = assoc.send(:construct_from)
+        joins      = assoc.send(:construct_joins)
+
+        table = "#{model.table_name}"
+        "id in (select #{table}.id from #{table} #{joins} where #{conditions})"
+      else
+        Object.instance_method(:instance_variable_get).bind(assoc).call("@finder_sql")
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,44 @@
+module Hobo
+  
+  module ModelSupport
+    
+    # This module provides methods common to both Hobo::Model and Hobo::CompositeModel
+    
+    def self.included(base)
+      base.extend(ClassMethods) if base.is_a? Class
+    end
+    
+    module ClassMethods
+      
+      def delegate_and_compose(*methods)
+        options = methods.pop
+        unless options.is_a?(Hash) && to = options[:to]
+          raise ArgumentError, ("Delegation needs a target. Supply an options hash " +
+                                "with a :to key as the last argument (e.g. delegate :hello, :to => :greeter).")
+        end
+        use = options[:use]
+    
+        methods.each do |method|
+          module_eval(<<-EOS, "(__COMPOSED_DELEGATION__)", 1)
+            def #{method}
+              @__#{method}_result__ ||= begin
+                                          obj = #{to}.__send__(#{method.inspect})
+                                          return nil if obj.nil?
+                                           
+                                          if obj.nil?
+                                            nil
+                                          elsif obj.is_a?(Array)
+                                            obj.map {|o| self.compose_with(o, #{use.inspect})}
+                                          else
+                                            self.compose_with(obj, #{use.inspect})
+                                          end
+                                        end
+            end
+          EOS
+        end
+      end
+        
+    end
+    
+  end
+end

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

@@ -0,0 +1,3 @@
+class Hobo::PasswordString < String
+
+end

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

@@ -0,0 +1,78 @@
+module Hobo::PredicateDispatch
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    def default_method_for(method)
+      "_default_#{method}"
+    end
+    
+    def defp(name, predicate=nil, &block)
+      ivar = "@@#{name}_predicates"
+      default_method_name = default_method_for(name).to_sym
+      methods = ivar.in?(class_variables) && class_variable_get(ivar)
+
+      if !methods
+        # It's the first defp for this name...
+
+        methods = class_variable_set(ivar, [])
+        
+        if name.to_s.in?(instance_methods) and predicate
+          # There's already a normal method with this name - it
+          # becomes the default.
+          alias_method default_method_name, name
+        end
+        
+      end
+      
+      if predicate
+        pname = "#{name}_p#{methods.length}"
+        methods << [pname, predicate.arity == 1, block.arity == 2]
+        define_method(pname, block)
+        define_method(pname + "_predicate", &predicate)
+      else
+        # It's the default - if there's already one, overwrite it
+        define_method(default_method_name, block)
+      end
+      
+      module_eval <<-END, __FILE__, __LINE__+1
+        def #{name}(options={}, &block)
+          methods = #{ivar}
+          for method_name, predicate_wants_options, wants_block in methods
+            pred = method_name + "_predicate"
+            if (predicate_wants_options ? send(pred, options) : send(pred))
+              return (if wants_block
+                        send(method_name, options, block)
+                      else
+                        send(method_name, options) 
+                      end)
+            end
+          end
+          if respond_to?(:#{default_method_name})
+            if method(:#{default_method_name}).arity == 2
+               #{default_method_name}(options, block) 
+            else
+               #{default_method_name}(options) 
+            end
+          end
+        end
+      END
+    end
+    
+    alias :p :proc
+    
+    def predicate_method?(method_name)
+      "@@#{method_name}_predicates".in?(class_variables)
+    end
+    
+    def predicate_has_default?(method_name)
+      default_method_for(method_name).in?(instance_methods)
+    end
+    
+  end
+  
+  
+end

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

@@ -0,0 +1,32 @@
+module Hobo
+
+  class ProcBinding
+
+    def self.eval(proc, self_, locals)
+      ProcBinding.new(self_, locals).instance_eval(&proc)
+    end
+
+    def initialize(self_, locals)
+      @self_ = self_
+      @locals = locals
+      locals.symbolize_keys!
+    end
+
+    def method_missing(name, *args, &block)
+      if @locals.has_key?(name)
+        @locals[name]
+      else
+        @self_.send(name, *args, &block)
+      end
+    end
+
+  end
+
+  (Object.instance_methods + 
+   Object.private_instance_methods +
+   Object.protected_instance_methods).each do |m|
+    ProcBinding.send(:undef_method, m) unless
+      %w{initialize method_missing send instance_eval}.include?(m) || m.starts_with?('_')
+  end
+
+end

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

@@ -0,0 +1,447 @@
+module Hobo::Rapid
+
+  include Hobo::DefineTags
+
+  TYPE_NAMES = { 
+    Hobo::HtmlString     => :html,
+    Hobo::Text           => :textarea,
+    TrueClass            => :boolean,
+    FalseClass           => :boolean,
+    Date                 => :date,
+    Time                 => :datetime,
+    Hobo::PasswordString => :password_string,
+    Fixnum               => :integer,
+    BigDecimal           => :integer,
+    Float                => :float,
+    String               => :string 
+  }
+  
+  def options_for_hobo_ajax(options)
+    js_options = build_callbacks(options)
+
+    js_options['asynchronous']  = false if options[:type] == :synchronous
+    js_options['method']        = method_option_to_s(options[:method]) if options[:method]
+    js_options['evalScripts']   = false if options[:script] == false
+    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.empty? ? nil : options_for_javascript(js_options)
+  end
+
+  
+  def js_updates(updates)
+    return '[]' unless updates
+    updates = [updates] unless updates.is_a? Array
+    '[' + comma_split(updates).map{|u| js_str(u)}.join(', ') + ']'
+  end
+  
+  
+  def js_result_updates(updates)
+    return '[]' unless updates
+    updates = [updates] unless updates.is_a? Array
+    pairs = comma_split(updates).omap{split(/\s*=\s*/)}
+    '[' + pairs.map{|p| "{id: #{js_str(p[0])}, result: #{js_str(p[1])}}"}.join(", ") + ']'
+  end
+
+
+  def ajax_updater(url_or_form, message, update, options={})
+    options ||= {}
+    target = if url_or_form == :post_form
+               target = "this"
+             else
+               js_str(url_or_form)
+             end
+    js_options = options_for_hobo_ajax(options)
+    args = [target, js_str(message || "..."), js_updates(update), js_options].compact
+    
+    confirm = options.delete(:confirm)
+    
+    func = "Hobo.ajaxRequest(#{args * ', '})"
+    if confirm
+      "if (confirm(#{js_str(confirm)})) { #{func} }"
+    else
+      func
+    end
+  end
+
+
+  def a_or_an(word)
+    if word =~ /^[aeiouh]/
+      "an #{word}"
+    else
+      "a #{word}"
+    end
+  end
+
+
+  def no_break(s)
+    s = new_context { yield } if block_given?
+    s.gsub(' ', ' ')
+  end
+
+
+  def_tag :if_current_user_in do
+    if_(:q => current_user_in?(this)) { tagbody.call }
+  end
+
+
+  def_tag :edit, :in_place do
+    if can_view_this?
+      if not can_edit_this?
+        show
+      elsif this_parent.new_record? or in_place == false
+        form_field(options)
+      else
+        editor(options)
+      end
+    end
+  end
+  
+  
+  def type_name(klass)
+    TYPE_NAMES[klass]
+  end
+
+
+  def_tag :form_field do
+    raise HoboError.new("Not allowed to edit") unless can_edit_this?
+    if this_type.respond_to?(:macro)
+      if this_type.macro == :belongs_to
+        belongs_to_field(options)
+      elsif this_type.macro == :has_many
+        has_many_field(options)
+      end
+      
+    else
+      tag = type_name(this_type).to_s + "_field"
+      if respond_to?(tag)
+        options[:name] ||= param_name_for_this
+        tag_src = send(tag, options)
+        if this_parent.errors[this_field]
+          "<div class='field_with_errors'>#{tag_src}</div>"
+        else
+          tag_src
+        end
+      else
+        raise HoboError, ("No form field tag for #{this_field}:#{this_type} (this=#{this.inspect})")
+      end
+    end
+  end
+  
+  def_tag :has_many_field do
+    raise NotImplementedError, "form field for has_many associations not implemented"
+  end
+  
+  def_tag :belongs_to_field do
+    belongs_to_menu_field(options)
+  end
+  
+  def_tag :textarea_field, :name do 
+    text_area_tag(name, this, options)
+  end
+  
+  
+  def_tag :boolean_field, :name do
+    check_box_tag(name, '1', this, options)
+  end
+  
+  def_tag :password_string_field, :name do
+    password_field_tag(name, this)
+  end
+  
+  def_tag :html_field, :name do
+    text_area_tag(name, this, add_classes(options, :tiny_mce))
+  end
+  
+  def_tag :date_field do
+    select_date(this || Time.now, :prefix => param_name_for_this)
+  end
+
+  def_tag :datetime_field do
+    select_datetime(this || Time.now, :prefix => param_name_for_this)
+  end
+
+  def_tag :integer_field, :name do
+    text_field_tag(name, this, options)
+  end
+
+  def_tag :float_field, :name do
+    text_field_tag(name, this, options)
+  end
+
+  def_tag :string_field, :name do
+    text_field_tag(name, this, options)
+  end
+
+  def_tag :editor do
+    raise HoboError.new("Not allowed to edit") unless can_edit_this?
+
+    if this_type.respond_to?(:macro)
+      if this_type.macro == :belongs_to
+        belongs_to_editor(options)
+      else
+        has_many_editor(options)
+      end
+    else
+      tag = type_name(this_type).to_s + "_editor"
+      if respond_to?(tag)
+        send(tag, options)
+      else
+        raise HoboError.new("<editor> not implemented for #{this.class.name}\##{this_field} " +
+                            "(#{this.inspect}:#{this_type})")
+      end
+    end
+  end
+  
+  
+  def_tag :has_many_editor do
+    # TODO: Implement
+    object_link(options)
+  end
+  
+  
+  def in_place_editor(kind, tag, options)
+    opts = add_classes(options, kind, editor_class).merge(:hobo_model_id => this_field_dom_id)
+
+    update = opts.delete(:update)
+    blank_message = opts.delete(:blank_message) || "(click to edit)"
+    
+    display = show(:no_span => true)
+    opts[:hobo_blank_message] = blank_message
+    display = blank_message if display.blank?
+    opts[:hobo_update] = update if update 
+    content_tag(tag, display, opts)
+  end
+    
+  
+  def_tag :string_editor do
+    in_place_editor "in_place_textfield_bhv", :span, options
+  end
+  
+  def_tag :textarea_editor do
+    in_place_editor "in_place_textarea_bhv", :div, options
+  end
+    
+  def_tag :html_editor do
+    in_place_editor "in_place_html_textarea_bhv", :div, options
+  end
+  
+  def_tag :belongs_to_editor do
+    belongs_to_menu_editor(options)
+  end
+  
+  def_tag :datetime_editor do
+    string_editor(options)
+  end
+  
+  def_tag :date_editor do
+    string_editor(options)
+  end
+
+  def_tag :integer_editor do
+    in_place_editor "in_place_textfield_bhv", :span, options
+  end
+
+  def_tag :float_editor do
+    in_place_editor "in_place_textfield_bhv", :span, options
+  end
+
+  def_tag :password_string_editor do
+    raise HoboError, "passwords cannot be edited in place"
+  end
+  
+  def_tag :boolean_editor do
+    boolean_checkbox_editor(options)
+  end
+  
+
+  AJAX_ATTRS = [:before, :success, :failure, :complete, :type, :method,
+                :script, :form, :params, :confirm,
+                :reset_form, :refocus_form]
+
+
+  def_tag :update_button, :label, :message, :attrs, :update, :params do
+    raise HoboError.new("no update specified") unless update
+    message2 = message || label
+    func = ajax_updater(object_url(this), message2, update,
+                        :params => { this.class.name.underscore => attrs }.merge(params || {}),
+                        :method => :put)
+    tag :input, add_classes(options.merge(:type =>'button', :onclick => func, :value => label),
+                            "button_input update_button update_#{this.class.name.underscore}_button")
+  end
+
+
+  def_tag :delete_button, :label, :message, :update, :ajax, :else, :image, :confirm, :fade do
+    fade2 = fade.nil? ? true : fade
+    if can_delete?(this)
+      opts = options.merge(if image
+                             { :type => "image", :src => "#{urlb}/images/#{image}" }
+                           else
+                             { :type => "button" }
+                           end)
+      label2 = label || "Remove"
+      confirm2 = confirm || "Are you sure?"
+      
+      add_classes!(opts,
+                   image ? "image_button_input" : "button_input",
+                   "delete_button delete_#{this.class.name.underscore}_button")
+      url = object_url(this, "destroy")
+      if ajax == false
+        opts[:confirm] = confirm2
+        button_to(label2, url, opts)
+      else
+        opts[:value] = label2
+        opts[:onclick] = "Hobo.removeButton(this, '#{url}', #{js_updates(update)}, #{fade2 ? 'true' : 'false'})"
+        tag(:input, opts)
+      end
+    else
+      else_
+    end
+  end
+  
+  
+  def_tag :create_button, :model, :update, :attrs, :label, :message, :else do
+    raise HoboError.new("no update specified") unless update
+    params = attrs || {}
+    if model
+      new = (model.is_a?(String) ? model.constantize : model).new(params)
+    else
+      raise HoboError.new("invalid context for <create_button>") unless Hobo.simple_has_many_association?(this)
+      params[this.proxy_reflection.primary_key_name] = this.proxy_owner.id
+      new = this.new(params)
+    end
+    if can_create?(new)
+      label2 = label || "New #{new.class.name.titleize}"
+      message2 = message || label2
+      class_name = new.class.name.underscore
+      func = ajax_updater(object_url(new.class), message2, update,
+                          ({:params => { class_name => params }} unless params.empty?))
+      tag :input, add_classes(options.merge(:type =>'button', :onclick => func, :value => label2),
+                              "button_input create_button create_#{class_name}_button")
+    else
+      else_
+    end
+  end
+  
+  
+  def_tag :remote_method_button, :method, :update, :result_update, :params, :label, :message do
+    ajax_options, html_options = options.partition_hash(AJAX_ATTRS)
+
+    message2 = message || method.titleize
+    func = ajax_updater(object_url(this) + "/#{method}", message2, update,
+                        ajax_options.merge(:params => params, :result_update => result_update))
+    html_options.update(:type =>'button', :onclick => "var e = this; " + func, :value => label)
+    tag(:input, add_classes(html_options, "button_input remote_method_button #{method}_button"))
+  end
+  
+
+  def_tag :hobo_rapid_javascripts, :tiny_mce do
+    res = javascript_include_tag("hobo_rapid")
+    res += "<script>"
+    unless Hobo.all_controllers.empty?
+      res += "var controllerNames = {" +
+        Hobo.all_controllers.map {|c| "#{c.singularize}: '#{c}'"}.join(', ') +
+        "}; "
+    end
+    res += "urlBase = '#{urlb}'; hoboPartPage = '#{view_name}'</script>"
+    
+    if tiny_mce
+      res += javascript_include_tag("tiny_mce/tiny_mce_src") + %{
+               <script type="text/javascript">
+                 tinyMCE.init({ mode: "textareas", editor_selector: "tiny_mce",
+                       plugins: 'save',
+                       theme_advanced_buttons1 : "bold, italic, separator, " +
+                                                 "bullist, outdent, indent, separator, " +
+                                                 "undo, redo, separator, link, unlink",
+                       theme_advanced_buttons2 : "",
+                       theme_advanced_buttons3 : ""
+                 });
+               </script>}
+    end
+    res
+  end
+
+
+  def_tag :object_form, :message, :update, :hidden_fields, :url do
+    ajax_options, html_options = options.partition_hash(AJAX_ATTRS)
+
+    url2 = url || object_url(this)
+    if update
+      # add an onsubmit to convert to an ajax form if `update` is given
+      function = ajax_updater(:post_form, message, update, ajax_options)
+      html_options[:onsubmit] = [html_options[:onsubmit],
+                                 "#{function}; return false;"].compact.join("; ")
+    end
+
+    body, field_names = with_form_context{ tagbody.call }
+    body = body.to_s
+
+    hiddens = case hidden_fields
+              when nil
+                []
+              when '*'
+                this.class.column_names - ['type']
+              else
+                comma_split(hidden_fields)
+              end
+    pname = this.class.name.underscore
+    hidden_tags = hiddens.map do |h|
+      val = this.send(h)
+      name = "#{pname}[#{h}]"
+      hidden_field_tag(name, val.to_s) if val and name.not_in?(field_names)
+    end
+    hidden_tags << hidden_field_tag("_method", "PUT") unless this.respond_to?(:new_record?) and this.new_record?
+
+    html_options[:method] = "post"
+    body_with_hiddens = hidden_tags.compact.join("\n") + body
+    
+    form_class = this.new_record? ? "new_#{this.class.name.underscore}" : this.class.name.underscore
+    
+    content_tag("form", body_with_hiddens, add_classes(html_options, form_class).merge(:action => url2))
+  end
+
+  
+  def_tag :create_form, :model, :in, :update, :message, :hidden_fields do
+    hiddens = hidden_fields
+    if model
+      obj = (model.is_a?(String) ? model.constantize : model).new
+    else
+      raise HoboError.new("cannot create object in #{in_.inspect}") unless this.is_a? Array
+      obj = this.new
+      refl = this.proxy_reflection
+      if refl.macro == :has_many and !refl.through_reflection
+        hiddens ||= [refl.primary_key_name]
+      end
+    end
+    m = message || "New #{obj.class.name.titleize}"
+    options = add_classes(options, "create_#{obj.class.underscore.name}_form")
+    object_form(obj, options.merge(:message => m, :update => update, :hidden_fields => hiddens)) do
+      tagbody.call
+    end
+  end
+  
+  def_tag :remote_method_form, :method, :message, :update, :result_update do
+    ajax_options, html_options = options.partition_hash(AJAX_ATTRS)
+    
+    url = object_url(this, method)
+    if update || result_update || !ajax_options.empty?
+      # add an onsubmit to convert to an ajax form
+      
+      function = ajax_updater(:post_form, message, update, ajax_options.merge(:result_update => result_update))
+      html_options[:onsubmit] = [html_options[:onsubmit],
+                                 "var e = this; #{function}; return false;"].compact.join("; ")
+    end
+
+    add_classes!(html_options, "#{this.class.name.underscore}_#{method}_form")
+    html_options[:method] = "post"
+    content_tag("form", tagbody.call, html_options.merge(:action => url))
+  end
+  
+  def editor_class
+    "#{this_parent.class.name.underscore}_#{this_field}_editor"
+  end
+
+end