@@ -13,25 +13,4 @@ class HostsController < ApplicationController config.columns[:resources].association.reverse = :host end - #def show - # unless @host = Host.find(:first, :conditions => [ 'name LIKE ?', "#{params[:name]}.%" ]) - # @host = Host.find(params[:id]) - # end - #end - - # POST /hosts - # POST /hosts.xml - #def create - # attrs = {} - # params.each_pair do |k,v| - # k.chomp - # case k - # when "name" - # attrs.store(k,v) - # when "ip" - # attrs.store(k,v) - # end - # end - #end - end app/controllers/hosts_controller.rb @@ -7,7 +7,7 @@ class ResourcesController < ApplicationController layout "application", :except => "collect_exported" active_scaffold :resource do |config| - config.list.columns = [:name, :param_values, :resource_tags, :source_file, :line] + config.list.columns = [:name, :param_values, :resource_tags] config.columns[:param_values].label = "Parameters" config.columns[:param_values].includes = nil config.columns[:param_values].association.reverse = :resource app/controllers/resources_controller.rb @@ -1,2 +1,12 @@ module HostsHelper + + def resources_column(record) + display = record.resources.count + display ||= "0" + end + + def fact_values_column(record) + display = record.fact_values.count + display ||= "0" + end end app/helpers/hosts_helper.rb @@ -1,2 +1,3 @@ module ResourceTagsHelper + end app/helpers/resource_tags_helper.rb @@ -1,2 +1,11 @@ module ResourcesHelper + def resource_tags_column(record) + display = record.resource_tags.count + display ||= "0" + end + + def param_values_column(record) + display = record.param_values.count + display ||= "0" + end end app/helpers/resources_helper.rb @@ -2,7 +2,7 @@ class Host < Puppet::Rails::Host hobo_model - def viewable_by?(viewer, field) - !user.guest? - end +# def viewable_by?(viewer, field) +# !user.guest? +# end end app/models/host.rb @@ -2,7 +2,9 @@ <include src="rapid" plugin="hobo"/> -<set-theme name="clean"/> +<set-theme name="puppetshow"/> + +<def tag="app-name">Puppet Show</def> <def tag="page" extend-with="app"> <page-without-app merge> app/views/taglibs/application.dryml @@ -14,9 +14,10 @@ development: adapter: mysql database: puppet - username: root - password: + username: puppet + password: puppet host: localhost + socket: "/var/run/mysqld/mysqld.sock" # Warning: The database defined as 'test' will be erased and # re-generated from your development database when you run 'rake'. @@ -30,7 +31,8 @@ test: production: adapter: mysql - database: puppetstore_production - username: root - password: + database: puppet + username: puppet + password: puppet host: localhost + socket: "/var/run/mysqld/mysqld.sock" config/database.yml @@ -1,22 +1,31 @@ -# This file is autogenerated. Instead of editing this file, please use the -# migrations feature of ActiveRecord to incrementally modify your database, and +# This file is auto-generated from the current state of the database. Instead of editing this file, +# please use the migrations feature of ActiveRecord to incrementally modify your database, and # then regenerate this schema definition. +# +# Note that this schema.rb definition is the authoritative source for your database schema. If you need +# to create the application database on another system, you should be using db:schema:load, not running +# all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations +# you'll amass, the slower it'll run and the greater likelihood for issues). +# +# It's strongly recommended to check this file into your version control system. -ActiveRecord::Schema.define(:version => 9) do +ActiveRecord::Schema.define(:version => 3) do create_table "fact_names", :force => true do |t| - t.column "name", :string - t.column "updated_at", :datetime + t.string "name", :null => false + t.datetime "updated_at" + t.datetime "created_at" end add_index "fact_names", ["id"], :name => "index_fact_names_on_id" add_index "fact_names", ["name"], :name => "index_fact_names_on_name" create_table "fact_values", :force => true do |t| - t.column "value", :text, :null => false - t.column "fact_name_id", :integer, :null => false - t.column "host_id", :integer, :null => false - t.column "updated_at", :datetime + t.text "value", :null => false + t.integer "fact_name_id", :null => false + t.integer "host_id", :null => false + t.datetime "updated_at" + t.datetime "created_at" end add_index "fact_values", ["id"], :name => "index_fact_values_on_id" @@ -24,13 +33,14 @@ ActiveRecord::Schema.define(:version => 9) do add_index "fact_values", ["host_id"], :name => "index_fact_values_on_host_id" create_table "hosts", :force => true do |t| - t.column "name", :string, :null => false - t.column "ip", :string - t.column "last_compile", :datetime - t.column "last_freshcheck", :datetime - t.column "last_report", :datetime - t.column "updated_at", :datetime - t.column "source_file_id", :integer + t.string "name", :null => false + t.string "ip" + t.datetime "last_compile" + t.datetime "last_freshcheck" + t.datetime "last_report" + t.datetime "updated_at" + t.integer "source_file_id" + t.datetime "created_at" end add_index "hosts", ["id"], :name => "index_hosts_on_id" @@ -38,19 +48,21 @@ ActiveRecord::Schema.define(:version => 9) do add_index "hosts", ["name"], :name => "index_hosts_on_name" create_table "param_names", :force => true do |t| - t.column "name", :string - t.column "updated_at", :datetime + t.string "name", :null => false + t.datetime "updated_at" + t.datetime "created_at" end add_index "param_names", ["id"], :name => "index_param_names_on_id" add_index "param_names", ["name"], :name => "index_param_names_on_name" create_table "param_values", :force => true do |t| - t.column "value", :text, :null => false - t.column "param_name_id", :integer, :null => false - t.column "line", :integer - t.column "resource_id", :integer - t.column "updated_at", :datetime + t.text "value", :null => false + t.integer "param_name_id", :null => false + t.integer "line" + t.integer "resource_id" + t.datetime "updated_at" + t.datetime "created_at" end add_index "param_values", ["id"], :name => "index_param_values_on_id" @@ -58,16 +70,18 @@ ActiveRecord::Schema.define(:version => 9) do add_index "param_values", ["resource_id"], :name => "index_param_values_on_resource_id" create_table "puppet_tags", :force => true do |t| - t.column "name", :string - t.column "updated_at", :datetime + t.string "name" + t.datetime "updated_at" + t.datetime "created_at" end add_index "puppet_tags", ["id"], :name => "index_puppet_tags_on_id" create_table "resource_tags", :force => true do |t| - t.column "resource_id", :string - t.column "puppet_tag_id", :integer - t.column "updated_at", :datetime + t.integer "resource_id" + t.integer "puppet_tag_id" + t.datetime "updated_at" + t.datetime "created_at" end add_index "resource_tags", ["id"], :name => "index_resource_tags_on_id" @@ -75,13 +89,14 @@ ActiveRecord::Schema.define(:version => 9) do add_index "resource_tags", ["puppet_tag_id"], :name => "index_resource_tags_on_puppet_tag_id" create_table "resources", :force => true do |t| - t.column "title", :text, :null => false - t.column "restype", :string, :null => false - t.column "host_id", :integer - t.column "source_file_id", :integer - t.column "exported", :boolean - t.column "line", :integer - t.column "updated_at", :datetime + t.text "title", :null => false + t.string "restype", :null => false + t.integer "host_id" + t.integer "source_file_id" + t.boolean "exported" + t.integer "line" + t.datetime "updated_at" + t.datetime "created_at" end add_index "resources", ["id"], :name => "index_resources_on_id" @@ -89,13 +104,35 @@ ActiveRecord::Schema.define(:version => 9) do add_index "resources", ["source_file_id"], :name => "index_resources_on_source_file_id" add_index "resources", ["restype", "title"], :name => "typentitle" + create_table "sessions", :force => true do |t| + t.string "session_id", :null => false + t.text "data" + t.datetime "created_at" + t.datetime "updated_at" + end + + add_index "sessions", ["session_id"], :name => "index_sessions_on_session_id" + add_index "sessions", ["updated_at"], :name => "index_sessions_on_updated_at" + create_table "source_files", :force => true do |t| - t.column "filename", :string - t.column "path", :string - t.column "updated_at", :datetime + t.string "filename" + t.string "path" + t.datetime "updated_at" + t.datetime "created_at" end add_index "source_files", ["id"], :name => "index_source_files_on_id" add_index "source_files", ["filename"], :name => "index_source_files_on_filename" + create_table "users", :force => true do |t| + t.string "crypted_password", :limit => 40 + t.string "salt", :limit => 40 + t.string "remember_token" + t.datetime "remember_token_expires_at" + t.string "username" + t.boolean "administrator", :default => false + t.datetime "created_at" + t.datetime "updated_at" + end + end db/schema.rb @@ -17,11 +17,6 @@ table.new-record textarea, table.new-record input { display: inline; } -.edit-page .content-header {overflow: hidden; height: 100%;} -.edit-page .content-header h1 {float: left;} -.edit-page .content-header .delete-button {float: right;} -form .actions {margin: 30px 0;width: 100%; text-align: center;} - /**** Admin ****/ .admin-banner { @@ -39,25 +34,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;} float: right; } -/* rails error message */ -.error-messages { - font-family: "Lucida Grande", arial, sans-serif; - background: #9d0018; - border: 1px solid #7a0013; - padding: 15px 30px; - color: white; - margin-bottom: 20px; -} -.error-messages h2 { - text-transform: none; - letter-spacing: normal; - color: white; - margin-bottom: 10px; -} -.error-messages li { - margin-left: 20px; -} - /********* everything below here came from hobo_rapid.css, needs looking at ********/ /**** Default styling for Rapid ***/ @@ -66,30 +42,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;} float: right; margin: 20px; position: fixed; display: none; z-index: 10; } -/* -#ajax-progress { - color: grey; - float: right; - margin: 20px; - position: fixed; - background: white; - font-family: Tahoma "sans serif"; - display: none; - z-index: 10; -} - -#ajax-progress div { - border: 1px dashed grey; - margin: 10px; - padding: 3px; - padding-top: -15px; -} - -#ajax-progress img { - padding-left: 6px; - vertical-align: middle; -} -*/ /* Scriptaculous Autocompleter ---*/ @@ -126,7 +78,7 @@ div.completions-popup ul li { text-align: left; width: 1px; white-space: nowrap; vertical-align: top; padding-top: 10px; padding-bottom: 10px; } -.field-list textarea, .field-list input.string, .field-list input.password { width: 100%; margin: 0; } +.field-list textarea, .field-list input.string, .field-list input.password { width: 99%; margin: 0; } /*input[type=text].wide { width: 100%; }*/ textarea { height: 170px; } public/hobothemes/clean/stylesheets/rapid-ui.css @@ -37,7 +37,7 @@ var Hobo = { var opts = Object.merge(options || {}, { params: params}) Hobo.ajaxRequest(Hobo.putUrl(el), - el.getAttribute("hobo-ajax-message") || "Changing...", + el.getAttribute("hobo-ajax-message") || "Saving...", updates, opts) }, @@ -49,8 +49,7 @@ var Hobo = { updates.each(function(id_or_el) { var el = $(id_or_el) if (el) { // ignore update of parts that do not exist - var partDomId - partDomId = el.id + var partDomId = el.id if (!hoboParts[partDomId]) { throw "Update of dom-id that is not a part: " + partDomId } params.push("render["+i+"][part_context]=" + encodeURIComponent(hoboParts[partDomId])) params.push("render["+i+"][id]=" + partDomId) @@ -73,11 +72,12 @@ var Hobo = { return params.join('&') }, - ajaxRequest: function(url_or_form, message, updates, options) { + ajaxRequest: function(url_or_form, updates, options) { options = Object.merge({ asynchronous:true, evalScripts:true, resetForm: false, - refocusForm: false + refocusForm: false, + message: "Saving..." }, options) if (typeof url_or_form == "string") { var url = url_or_form @@ -104,7 +104,7 @@ var Hobo = { params.push(Form.serialize(form)) } - Hobo.showSpinner(message, options.spinnerNextTo) + Hobo.showSpinner(options.message, options.spinnerNextTo) var complete = function() { if (form && options.resetForm) form.reset(); Hobo.hideSpinner(); @@ -112,6 +112,7 @@ var Hobo = { if (options.onComplete) options.onComplete.apply(this, arguments) if (form && options.refocusForm) Form.focusFirstElement(form) + Event.addBehavior.reload() } if (options.method && options.method.toLowerCase() == "put") { delete options.method @@ -184,30 +185,30 @@ var Hobo = { var updateParams = Hobo.ajaxUpdateParams(updates, [{id: id, result: 'new_field_value', func: "Hobo.onFieldEditComplete"}]) - opts = {okButton: false, - cancelLink: false, - submitOnBlur: true, - evalScripts: true, - htmlResponse: false, - ajaxOptions: { method: "put" }, - onEnterHover: null, - onLeaveHover: null, - callback: function(form, val) { - old = val - return (Hobo.fieldSetParam(el, val) + "&" + updateParams) - }, - onFailure: function(resp) { - alert(resp.responseText); el.innerHTML = old - }, - onEnterEditMode: function() { - var blank_message = el.getAttribute("hobo-blank-message") - if (el.innerHTML.gsub("&nbsp;", " ") == blank_message) { - el.innerHTML = "" - } else { - Hobo.ipeOldValues[el.id] = el.innerHTML + var opts = {okButton: false, + cancelLink: false, + submitOnBlur: true, + evalScripts: true, + htmlResponse: false, + ajaxOptions: { method: "put" }, + onEnterHover: null, + onLeaveHover: null, + callback: function(form, val) { + old = val + return (Hobo.fieldSetParam(el, val) + "&" + updateParams) + }, + onFailure: function(resp) { + alert(resp.responseText); el.innerHTML = old + }, + onEnterEditMode: function() { + var blank_message = el.getAttribute("hobo-blank-message") + if (el.innerHTML.gsub("&nbsp;", " ") == blank_message) { + el.innerHTML = "" + } else { + Hobo.ipeOldValues[el.id] = el.innerHTML + } } - } - } + } Object.extend(opts, options) return new Ajax.InPlaceEditor(el, Hobo.putUrl(el), opts) }, @@ -219,14 +220,14 @@ var Hobo = { } select(".in-place-textfield-bhv").each(function (el) { - ipe = Hobo._makeInPlaceEditor(el) + var ipe = Hobo._makeInPlaceEditor(el) ipe.getText = function() { return this.element.innerHTML.gsub(/<br\s*\/?>/, "\n").unescapeHTML() } }) select(".in-place-textarea-bhv").each(function (el) { - ipe = Hobo._makeInPlaceEditor(el, {rows: 2}) + var ipe = Hobo._makeInPlaceEditor(el, {rows: 2}) ipe.getText = function() { return this.element.innerHTML.gsub(/<br\s*\/?>/, "\n").unescapeHTML() } @@ -258,12 +259,12 @@ var Hobo = { select("select.number-editor-bhv").each(function(el) { el.onchange = function() { - Hobo.ajaxSetFieldForElement(el, el.value) + Hobo.ajaxSetFieldForElement(el, $F(el)) } }) select(".autocomplete-bhv").each(function (el) { - options = {paramName: "query", minChars: 3, method: 'get' } + var options = {paramName: "query", minChars: 3, method: 'get' } if (el.hasClassName("autosubmit")) { options.afterUpdateElement = function(el, item) { el.form.onsubmit(); } } @@ -324,34 +325,50 @@ var Hobo = { return res }, + fadeObjectElement: function(el) { - new Effect.Fade(Hobo.objectElementFor(el), - { duration: 0.5, - afterFinish: function (ef) { ef.element.remove() } }); + var fadeEl = Hobo.objectElementFor(el) + new Effect.Fade(fadeEl, { duration: 0.5, afterFinish: function (ef) { + ef.element.remove() + } }); + Hobo.showEmptyMessageAfterLastRemove(fadeEl) }, + removeButton: function(el, url, updates, options) { if (options.fade == null) { options.fade = true; } if (options.confirm == null) { options.fade = "Are you sure?"; } if (options.confirm == false || confirm(options.confirm)) { - objEl = Hobo.objectElementFor(el) + var objEl = Hobo.objectElementFor(el) Hobo.showSpinner('Removing'); function complete() { if (options.fade) { Hobo.fadeObjectElement(el) } Hobo.hideSpinner() } if (updates && updates.length > 0) { - new Hobo.ajaxRequest(url, "Removing", updates, { method:'delete', - onComplete: complete}); + new Hobo.ajaxRequest(url, updates, { method:'delete', message: "Removing...", onComplete: complete}); } else { - new Ajax.Request(url, {asynchronous:true, evalScripts:true, method:'delete', - onComplete: complete}); + var ajaxOptions = {asynchronous:true, evalScripts:true, method:'delete', onComplete: complete} + if (typeof(formAuthToken) != "undefined") { + ajaxOptions.parameters = formAuthToken.name + "=" + formAuthToken.value + } + new Ajax.Request(url, ajaxOptions); } } }, + showEmptyMessageAfterLastRemove: function(el) { + var empty + var container = el.parentNode + if (container.getElementsByTagName(el.nodeName).length == 1 && + (empty = container.next('.empty-collection-message'))) { + new Effect.Appear(empty, {delay:0.3}) + } + }, + + parseFieldId: function(el) { id = el.getAttribute("hobo-model-id") if (!id) return @@ -359,6 +376,7 @@ var Hobo = { if (m) return { name: m[1], id: m[2], field: m[3] } }, + appendRow: function(el, rowSrc) { // IE friendly method to add a <tr> (from html source) to a table // el should be an element that contains *only* a table @@ -367,6 +385,7 @@ var Hobo = { Hobo.applyEvents(el) }, + objectElementFor: function(el) { var m while(el.getAttribute) { @@ -385,7 +404,7 @@ var Hobo = { if(t = $('ajax-progress-text')) Element.update(t, message); if(e = $('ajax-progress')) { if (nextTo) { - var pos = nextTo.cumulativeOffset() + var pos = $(nextTo).cumulativeOffset() e.style.top = pos.top + "px" e.style.left = (pos.left + nextTo.offsetWidth) + "px" } @@ -431,8 +450,14 @@ var Hobo = { return pluralisations[s] || s + "s" }, - addUrlParams: function(params) { + addUrlParams: function(params, options) { params = $H(window.location.search.toQueryParams()).merge(params) + + if (options.remove) { + var remove = (options.remove instanceof Array) ? options.remove : [options.remove] + remove.each(function(k) { params.unset(k) }) + } + return window.location.href.sub(/(\?.*|$)/, "?" + params.toQueryString()) } @@ -485,7 +510,7 @@ Element.Methods.$$ = function(e, css) { // --- has_many_through_input --- // -HasManyThroughInput = Behavior.create({ +SelectManyInput = Behavior.create({ initialize : function() { // onchange doesn't bubble in IE6 so... @@ -493,15 +518,16 @@ HasManyThroughInput = Behavior.create({ }, addOne : function() { - var select = this.element.down('select') + var select = this.element.down('select') var selected = select.options[select.selectedIndex] - if (selected.style.display != "none" & selected.value != "") { - var newItem = strToDom(this.element.down('.item-proto').innerHTML) + if (selected.style.display != "none" & selected.text != "") { + var newItem = $(DOM.Builder.fromHTML(this.element.down('.item-proto').innerHTML.strip())) this.element.down('.items').appendChild(newItem); newItem.down('span').innerHTML = selected.innerHTML - newItem.down('input[type=hidden]').value = selected.innerHTML + this.itemAdded(newItem, selected) selected.style.display = 'none' select.value = "" + Event.addBehavior.reload() } }, @@ -518,14 +544,37 @@ HasManyThroughInput = Behavior.create({ var label = el.down('span').innerHTML var option = $A(this.element.getElementsByTagName('option')).find(function(o) { return o.innerHTML == label }) option.style.display = 'block' + }, + + itemAdded: function(item, option) { + this.hiddenField(item).value = option.innerHTML + }, + + hiddenField: function(item) { + return item.down('input[type=hidden]') + //return item.getElementsByClassName("hidden-field")[0] } + }) Event.addBehavior({ - 'div.has-many-through.input' : HasManyThroughInput(), - '.dependent-collection-count:click' : function(e) { - new Effect.ScrollTo('dependent-collection', {duration: 1.0, offset: -10, transition: Effect.Transitions.sinoidal}); - Event.stop(e); - } + 'div.select-many.input' : SelectManyInput(), + + '.association-count:click' : function(e) { + new Effect.ScrollTo('primary-collection', {duration: 1.0, offset: -20, transition: Effect.Transitions.sinoidal}); + Event.stop(e); + }, + 'form.filter-menu select:change': function(event) { + var paramName = this.up('form').down('input[type=hidden]').value.gsub("-", "_") + var params = {} + var remove = [ 'page' ] + if ($F(this) == '') { + remove.push(paramName) + } else { + params[paramName] = $F(this) + } + location.href = Hobo.addUrlParams(params, {remove: remove}) + } + }); public/javascripts/hobo-rapid.js @@ -1,8 +1,8 @@ LowPro = {}; LowPro.Version = '0.5'; -LowPro.CompatibleWithPrototype = '1.6.0'; +LowPro.CompatibleWithPrototype = '1.6'; -if (Prototype.Version != LowPro.CompatibleWithPrototype && console && console.warn) +if (Prototype.Version.indexOf(LowPro.CompatibleWithPrototype) != 0 && window.console && window.console.warn) console.warn("This version of Low Pro is tested with Prototype " + LowPro.CompatibleWithPrototype + " it may not work as expected with this version (" + Prototype.Version + ")"); @@ -15,19 +15,19 @@ DOM = {}; // DOMBuilder for prototype DOM.Builder = { tagFunc : function(tag) { - return function() { - var attrs, children; - if (arguments.length>0) { - if (arguments[0].nodeName || - typeof arguments[0] == "string") - children = arguments; - else { - attrs = arguments[0]; - children = Array.prototype.slice.call(arguments, 1); - }; - } - return DOM.Builder.create(tag, attrs, children); - }; + return function() { + var attrs, children; + if (arguments.length>0) { + if (arguments[0].constructor == Object) { + attrs = arguments[0]; + children = Array.prototype.slice.call(arguments, 1); + } else { + children = arguments; + }; + children = $A(children).flatten() + } + return DOM.Builder.create(tag, attrs, children); + }; }, create : function(tag, attrs, children) { attrs = attrs || {}; children = children || []; tag = tag.toLowerCase(); @@ -71,7 +71,8 @@ DOM.Builder.fromHTML = function(html) { // Event.onReady(callbackFunction); Object.extend(Event, { onReady : function(f) { - document.observe('dom:loaded', f); + if (document.body) f(); + else document.observe('dom:loaded', f); } }); @@ -96,7 +97,7 @@ Event.addBehavior = function(rules) { Ajax.Responders.register({ onComplete : function() { if (Event.addBehavior.reassignAfterAjax) - setTimeout(function() { ab.unload(); ab.load(ab.rules) }, 10); + setTimeout(function() { ab.reload() }, 10); } }); ab.responderApplied = true; @@ -145,6 +146,12 @@ Object.extend(Event.addBehavior, { this.cache = []; }, + reload: function() { + var ab = Event.addBehavior; + ab.unload(); + ab.load(ab.rules); + }, + _wrapObserver: function(observer) { return function(event) { if (observer.call(this, event) === false) event.stop(); @@ -277,7 +284,7 @@ Remote.Form = Behavior.create(Remote.Base, { onclick : function(e) { var sourceElement = e.element(); - if (sourceElement.nodeName.toLowerCase() == 'input' && + if (['input', 'button'].include(sourceElement.nodeName.toLowerCase()) && sourceElement.type == 'submit') this._submitButton = sourceElement; }, public/javascripts/lowpro.js @@ -1,3 +1,909 @@ +== Hobo 0.7.5 === + + Restructuring the git repo -- all the different gems/plugins live + in the same repo now (github.com/tablatom/hobo) + + Change to themes - the stylesheet and tablib are now called + (e.g. for the 'clean' theme) clean.css and clean.dryml + + New rake task generate_tag_reference. Creates simple HTML reference + docs, including any inline documentation comments (found + immediately above the <def>) + + ModelController + + Made it possible to have a custom #permission_denined and + #not_found in ApplicationController + + Improved logic for figuring out redirect after destroy + + Fix to bug where we would turn pagination off when we shouldn't + + We now have a list of mime-types that we *don't* paginate for + (can be extended) + + hobo_index now silently skips pagination when the passed finder doesn't support it + + Fix to auto_actions :except => :collections + + Fix to rendering permission denied errors + + + Fixes for IE6 + + The rapid-pages now include the fabulous IE7.js when the client + is IE6. + + http://dean.edwards.name/IE7/ + + The clean theme now works much better in IE6. + + hobo-rapid.js -- fix displaying the empty-message after a removeButton + + + Hobo models + + No longer defines Model[...] (in Hobo use Model.named(foo) instead) + + Fix to MyHoboModel.defined_scopes sometimes returning nil + + Allowing belongs_to and has_one associations to be set by name + during mass-assignment + + e.g. person.attributes = { :department => 'Sales' } + + Automatic scopes -- give up silently if there's a problem with the DB + + Fix to :managed => true option on has_many. No longer requires + the through association to be declared first. + + Auto-completers are now working again. The tag to use is + <name-one>. Should be a how-to for this availabe soon. + + In-place-edits are working again + + New controller method call_dryml_tag (added by DRYML template + handler). Calls a tag and returns the result as a string. + + Fix to <after-submit stay-here> following a part update + + Bundles -- fixes to class renaming + + <remote-method-button> is working again + + Refactored the DRYML parser to make it easier to parse DRYML in other contexts + + Rapid: + + Improvements to wording on index-page + + Display the users name, not login in the account-nav + + Small tweaks to generic tags + + Fix: The <view> for various types was reverting to a plain String view + + + Switching to dependency on hobofields and will_paginate as gems rather than plugins + + Fix: DRYML parser works again with REXML versions back to 3.1.4 + + Fix: Hobo No longer depends on redcloth unless you're using markdown + + Routing + + Recover from ActiveRecord::StatementInvalid (routes may not be + declared). Without this you sometimes can't even run rake if + something is invalid + + Don't do routing (and hence load models) during + script/generate. This *finally* fixes the dreaded 'User is + reserved by Rails' error + + +== Hobo 0.7.4 === + +Switching to a new style for the changelog. Now that we're using git +the commit logs are a lot better, so this file is just going to +contain edited highlights of the commit log. + + Rapid: making <view> make more use of the to_html API from + HoboFields + + Reworked REXML extensions. Now compatible with REXML 3.7.1.1 + through 3.7.1.3 + + ModelController -- fix to chosing whether or not to paginate + + Various IE Javascript fixes + + Rapid, <select-many>: Additional params, and IE fix + + Moving the part-contexts javascripts from the very end of the + output, to the end of <body> + + The script tag must now be output by the <page>, instead of + being appended automatically by DRYML. This is done in + <simple-layout/> + + Rapid -- removing <view for='percentage'> + + DRYML -- improved error reporting + + Hobo::Model: fix -- we were breaking inheritence of validations + + Model generators -- adding some helpful comments + + Rapid: Fix to permission check for adding to primary collection on + <show-page> + + Rapid: removing empty message from <index-page> + + Rapid: Fix to enum-string editor + + Rapid: Fix to auto-label in <count> + + User model generator -- change create permission to allow admin to + create another admin + + New lowpro version + + New automatic css class 'with-owner' on default <card/> + + Hobo::ModelController -- fix to automatic inclusion of reorder + action for models that act as list + + Improvements to default <card> + + Rapid javascript: try to automatically bring back the + empty-message on removing the last item from a collection + + Scopes: fix to apply_scopes + + Fix to <name-for-collection> + + Rapid tags: Support for the empty-message on a collection + re-appearing automatically if all the items are removed by the + user + + DRYML: scoped variables -- assigning to a variable now modifies + it's value in a parent scope if it's present in one + + <delete-button> fix -- was incorrectly guessing 'in-place' during + ajax update + + New tag <name-for-collection> + + Fix to <view for='text'/> + + Improvements to <table-plus> + + Ability to sort by name of 'this' when 'this' is one of the + fields + + Keep table headings in when the table is empty + + Don't include page nav if the collection doesn't support it + + Improvements to rapid pages + + Allowing has_many associations in forms + + Allowing the primary collection on a show page to be provided by + an instance variable (so that filtering/searching/pagination are + supported) + + Tidy of <show-page> + + <index-page> -- improved wording + + Fixes to <index-page> + + <account-nav> make 'logged in as bob' a link to current_user + + Factored out default <collection> into <base-collection>, and + fixes to <collection-preview> + + <base-card> -- add 'edit' link + + <base-card> change 'title' param to 'heading' and make it easier + to provide your own + + <creation-details> use a div rather than a span + + Fix to <select-many> + + Fix to <select-menu> + + Fix to <input for='datetime'> + + Rapid forms: switching to <select-one> and <select-many> naming + + <form> -- don't include auth token on GET forms + + Rapid: <belongs-to-menu-editor> -- don't show 'View' link if the + thing is not linkable + + Rapid: adding sort attribute to <belongs-to-menu-editor> + + Rapid: default 'no-filter' option for filter-menu + + Rapid: Fix to extraneous whitespace in <you> + + Rapid: better guess of label on <count> + + Rapid: Use association name rather than class name in css classes + on <a> tags (when available) + + Rapid: Fix to use of <else> with <a> + + Removed 'all' method from ScopedProxy - delegates to the model + class instead + + Fix to origin_attribute on scoped associations + + Fix to with_abc automatic scopes + + New automatic scopes 'include' and 'search', and improvements to + order_by scope + + Scopes: fix to parameterised scopes on associations + + Scopes: new apply_scopes method for models and has_many + associations + + Pass a hash of scope-name => scope-arguments (single valur or + array), the result will be scoped accordingly, but only if the + first argument to the scope is not blank. It's designed to be + used from controllers: if a param (e.g. a search or filter) is + not included in the request, the scope is not applied + + Hobo::ModelController -- fix to permission denied response for + ajax actions + + Hobo::ModelController -- Fix to flash message after update + + Hobo::ModelController -- fix to redirection after submitting a + form + + Hobo::ModelController -- cleaning up sorting and filtering + + Hobo::ModelController -- make reorder one of the automatic + :write_only actions if the model has the position_column method + + <with-fields> better error reporting + + Hobo::ModelController -- adding automatic reorder action + + Works with acts_as_list and scriptaculous drag and drop + re-ordering + + Hobo::Model adding :managed => true option to has_many + + Only valid with the :through option. Records of the joining + model will be created and destroyed as required when this record + is saved, in order to honour the contents of the association at + save time. + + Hobo::Model -- adding .user_update + + Hobo::Model -- fix to user_find + + Hobo::HoboHelper -- #map_this (used by repeat) will set this_key + when iterating over a hash + + DRYML: made this_field_reflection do a better job of figuring out + the current reflection + + DRYML: adding this_key -- gives you the current key when + <repeat>ing on a hash + + DRYML: Error message for invalid attributes on parameter tags, + e.g. <foo: if-'...'> + + Hobo module - fix to permission checks on unexpected objects + + Hobo module -- always return false for can_create? on has_many + associations that are not 'simple' + + (i.e. they have conditions) + + DRYML: Fix for replacing an overridden tag parameter + + Rapid pages: new submit label on show page (add to collection) + + Rapid pages: Add param to <show-page> + + Rapid pages: by default, append app-name to every title, override + with full-title attribute (<base-page>) + + Rapid pages: <show-page> -- update primary collection count when + an item is deleted + + Rapid pages: fix on <show-page> + + Rapid pages: make edit link on show-page check if the edit action + is linkable + + Rapid forms: adding inputs (just textareas) for textile and + markdown + + front_controller generator -- use <collection-preview> in + index.dryml + + Rapid generics: adding support for <collection with='&MyModel'/> + + Rapid tags: switching to <main-nav> tag, called from simple-layout + + hobo_model_resource generator -- removing creating of (rails + style) resource route + + Improvements to rapid pages + + Allowing has_many associations in forms + + Allowing the primary collection on a show page to be provided by + an instance variable (so that filtering/searching/pagination are + supported) + + Rapid: Fix to use of <else> with <a> + + Removed 'all' method from ScopedProxy - delegates to the model + class instead + + Fix to origin_attribute on scoped associations + + Rapid tags: disabled <belongs-to-view>, new <view + for='ActiveRecord::Base'> is used now + + Hobo::Model -- fix to reverse_refelction + + Rapid tags: Adding <head:> and <foot:> params to <ul> + + Rapid tags: Adding params to <select-many> + + Rapid tags: adding support for <ul empty> (force the <ul> to + appear even if empty) + + Fix: automatic scopes not_ and "association name" were not being + created + + Rapid forms: Renaming <name-array-input> to <select-many> (and + improvements) + + Hobo::Model -- adding assigment by arrays of names to has_many + associations + + Hobo::Model -- adding Model.manage_join_records + + Routing: fix -- don't try to load assemble.rb if + ApplicationController not defined + + Rapid pages: Fix to body class on <new-page> + + Rapid pages: fix to show page + + Rapid pages -- fixing pluralisation of <index-page> title + + Adding support for 'this' psuedo-field to <with-fields> and + <with-fields-names> + + In particular, this makes it possible to include the object + itself in a table plus column + + Adding a general <view> for ActiveRecord objects (just <a/>) + + Allowing lookup of polymorphic tags to include ActiveRecord::Base + or Object as a catch-all + + Rapid generics: make collection preview hide the show-all link if + there are none + + <page-nav> now uses will_paginate's helper to provide much better + page navigation than before. + + +=== Release 0.7.3 === + +hobo command -- options are now: + + --user-model <model-name-or-false> + --svn # Use 'svn co' to checkout Hobo + --create-dbs # Run rake db:create:all + --hobo-src <path to hobo src> + -d | --database <database> # e.g. mysql, sqlite + + +Core extentions + + Extracted from Hobo into new project: HoboSupport + + Some notable changes: + + #every has gone: users.every(:name) is now users.*.name + + +hobo generator + + application.dryml now has a generated <app-name> tag + + +hobo_front_controller generator + + Generated "search" route is now called "site_search" + + Removed unused --no-user option + + +hobo_migration_generator + + Removed from Hobo - now part of the HoboFields spinn-off project + + +New generator hobo_model_resource creates a model + controller pair + + +Rapid Javascripts + + Default ajax message changed to "Saving..." + + Hobo.ajaxRequest now takes the message as an option (was the second argument) + + Fix to showing the ajax spinner in the right place in IE + + Hobo.addUrlParams now has an option to remove specified parameters + + Fixes to HasManyThroughInput behaviour + + New behaviour supporting filtering (e.g. on index pages) using <select> tags + + +Rich data types + + These are all part of the HoboFields project now + + Booleans are now represented by the type Hobo::Boolean which is still part of Hobo + + +Active record extensions + + Monkey-patch to make AR complain less about missing classes for + polymorphic associations + + +The block-based "composable query mechanism" is gone. Named scopes are much better. + + +Hobo's original implementation of what later became "Sexy Migrations" is gone. + + +Hobo module utility methods + + Hobo.field_types and Hobo.symbolic_type_name are gone - now part of + HoboFields + + Fixes to can_edit? + + +Site-search: + + Now automatically skips searching of non-linkable models. + + Can now be passed an array of models (including scoped finders) to search + + Now renders <search-card> instead of <card> + + +New feature: Hobo::DevController + + A controller that adds developer support features (not in production + mode). For now it just adds a method that can be used to change the current_user: + + /dev/set_current_user?name=Fred+Bloggs + + Very useful + + +Hobo Routing + + Hobo::ModelRouter.linkable? can now be used with all the routes + created by Hobo. + + +Hobo helpers + + object_url now always returns nil if the URL requested is not a + route known to Hobo routing + + + object_url never includes _method= in the query string + + dom_id is now moved to DRYML's TemplateEnvironment + + can_view? now utilises some simple cacheing + + signup_url now defaults to the + + linkable? no longer accepts an array as parameter + + +Rapid helpers + + ajax_updater(url_or_form, message, update, options) is now + ajax_updater(url_or_form, update, options) (message has become an + option) + + +DRYML + + DRYML integration changes -- this is a start to the work of + extracting DRYML from Hobo. + + The fallback from a template file to a tag, e.g. from index.dryml + to <index-page/> is now handled by DRYML, not by Hobo's model + controller. You can customise the chosed tag by calling + + dryml_fallback_tag("my-tag") from your controller action + + The default DRYML context is now the value returned by + #dryml_context (was previously the value of @this). #dryml_context + returns @this by default but can be overridden. + + <include src="mytags" bundle="foo"> + + includes a taglib from the plugin that the 'foo' bundle came from, + and puts into effect any class renames from that bundle (for + polymorphic tags). + + Fix - tags with capitalised names now work + + <my-param:></my-param:> can now be used to clear the contents of a + parameter. It's not the same as <my-param:/> (which does nothing) + + New psuedo parameters for insterting content in and around + parameters. e.g. for a param 'title': + + <before-title:> and <after-title:> for insterting content + immediately before and after the parameter. + + <append-content:> and <prepend-content:> for inserting content at + the begining and end of the default content. + + Note these are all just syntactic sugar for things you can do + already with <param-content/> and <title: replace> / + <title: restore/> + + When changing the context with the ':' shorthand, now use dashes, + not underscores (the idea being that underscores are soley for use + in Ruby code + + e.g. <with:my-field> + + Control attributes <my-tag if> is equivalent to <my-tag if="&this"/> + (remember these test for blank? / not blank?, not Ruby trueness) + + this_type now never returns AssociationReflections, + this_field_reflection does + + this_type now returns Hobo::Boolean for boolean types. + + this_field_dom_id is now just dom_id -- pass an object and an + attriubte, or nothing to default to this and this_field + + Can now do merge-params="param1, param2" to merge just the named + params + + Fix: <foo:foo> (i.e. field name same as tag name) + + Fix: using alias-of with a reserved word was broken + + +Hobo models + + New method Model.named to find things by name, + e.g. Category.named("Cars"), also aliased as Category["Cars"] + + Various new methods to support permission. This moves much of the + logic into the model (from Hobo::ModelController). These methods are + all passed, as the first argument, the user performing the action. A + Hobo::Model::PermissionDeniedError is raised if the permission check + fails. + + Class methods: + + user_find -- find with view-permission check + user_new -- new with create-permission check + user_create -- create with create-permission check + + user_can_create? -- test to see if a user is allowed to create the model. + + Instace methods: + + user_can_create? + user_save_changes + user_view + user_destroy + + Models now get a new_foo method for each has_one :foo + + The old id_name system is gone. Will be coming back in various + guises (e.g. see .named above) + + def_scope implementation factored out into separate modules + + New metod #get_creator returns the value of the creator attribute + (if there is one) + + Various features exrtacted and now part of HoboFields + + +Scopes + + Note: Hobo will probably switch to has_finder which provides + (nearly) all the functionality of Hobo's scopes and has a superior + implementation. We'll extend has_finder to add the bits that it is + missing. + + The implementation of scopes has been factored out into separate models. + + Large new set of automatically defined scopes. These are defined + automatically when you call them for the first time, much like the + magic finders in ActiveRecord (e.g. find_by_name_and_address): + + For every has_many relationship (e.g. tags) + + with_tag(t) -- find records that have tag c + with_tags(a, b, c) -- find records that have all these tags + without_tag(t) + without_tags(a, b, c) + + For every belongs_to and has_one (e.g. manager) + + manager_is(m) + manager_is_not(m) + + For every regular field (e.g. name) + + name_is(x) + name_is_not(x) + + For textual fields + + name_contains(x) + name_does_not_contain(x) + name_starts(x) + name_does_not_start(x) + name_ends(x) + name_does_not_end(x) + + For boolean fields (e.g. published) + + published + not_published + + For the various date/time columns (these must end _at, e.g. pulished_at) + + published_before(x) + published_after(x) + published_between(x, y) + + And finally + + order_by(field_name) -- add an ORDER BY clause + limit(n) -- add a LIMIT clause + recent(n) -- orders by created_at and limits to n records + + + +Hobo model controller + + Permission and not-found errors are now handled centrally using the + new rescue_from declaration in Rails. No need to worry about these + in individual actions. + + All the hobo actions (hobo_show, hobo_new etc) are greatly + simplified. Much of the logic has been moved elsewhere, so it's now + a lot easier to avoid using those actions at all and still get the + usual features such as permission checks, fallback on page tags etc. + + hobo_index now takes a "finder" (model class or scoped model + class) as the first argument. If you want to retrieve the + collection yourself, there's no reason to call hobo_index at all - + just write a regular Rails style action. + + The hobo_actions don't set any extra instance variables any more + beyond @this. e.g. hobo_show_collection doesn't set @owner, + because you can now use this.origin + + As part of the previous change, #not_allowed? is gone. + + Some work on autocomplete - might be working now :-) + + auto_actions -- can now say + + auto_actions :write_only # just gives you create, update and destroy + auto_actions :read_only # gives you all except the above three + + Support for scopes on declarative index actions: + + index_action :scope => :my_scope + + New method filter_by for easily adding filtering to index actions, e.g. + + # assuming category and price_range are scopes defined on the current model + def index + finder = filter_by(:category => params[:category], price_range => [params[:min_price], params[:max_price]) + hobo_index finder + end + + The old data_filters stuff is gone. This was based on the + "composable query" thing which is gone too (see above). + + Dependency on classic_pagination is gone. Now uses will_paginate + + + +User model + + Hobo::UserController.user_models is now Hobo::User.user_models + + New method Hobo::User.default_user_model returns the user model used + in various places if no model is specified. + + Now requires the current password to be provided when changing the + password (at the model level and in the related rapid-pages) + + User.login_attr renamed to User.login_attribute + + +User controller + + Now includes the rapid_user_pages taglib (these have been separated + from the main rapid-pages taglib) + + New helper: logout_current_user + + +Bundles + + Support for multiple bundles per plugin -- bundles can now be + selective about which models and controllers they include. + + Adding support for: belongs_to :foo, :polymorphic => :optional + + Magic option names are now available inside the model and controller *instances* + + Bundle options with defaults now work with nested option hashes + + belongs_to in a bundle model can now be given an :alias option - an + alias of the (parameterised) belongs_to is created so that the model + has a known API + + +Core DRYML tags + + <wrap> can be given a parameter="..." attribute to wrap the content + in a template using the given parameter name. + + <repeat> can now be used with <else> (i.e. the collection was empty) + + +Rapid tags: general + + New standardised API for getting metadata from collections + + #association_name returns th, er, name of the association. If + called on a named scope it returns the original association name, + not the scope name + + #member_class returns the (expected) class of items in the array + + #origin returns the object from which the collection was obtained + + #origin_attribute returns the name of the attribute from which the + collection was obtained + + So, unless something has changed: + + collection.origin.send(collection.origin_attribute) == collection + + This API is made available on all association proxies, regular + arrays and will_paginate collections. + + New taglib - rapid_generics - provides various tags used by the + default pages. These tags are designed to work generically with your + models, but can also be customised of course. + + <table> -- the "Edit" link now goes to action="edit" (was linking to + the show page) + + <count> is now better at guessing the label to use, also now + supports <count lowercase/> to downcase the label. + + <clearer> is gone - hooray for overflow: hidden + + Added do to <you> as in: <you do/> + + New tag <filter-menu/> creates a form with a <select>. Used for + adding menu-based filters to index pages. + + New tag <comma-list> + + +Rapid tags: editing + + <editor> now merges params and attributes (e.g. you can add your own css classes) + + Most ajax controls now just give "Saving..." as the default ajax + message. + + +Rapid tags: forms + + <form> (without an action attribute) now renders nothing if the + calculated action is not linkable + + If you provide action="..." to <form> (i.e. a manual form) the + automatic css classes are not added. + + <delete-button> now renders nothing if the destory action is not linkable + + <delete-button> now automatically switche to non-in-place delete if + the thing being deleted is the top-level context if the page. + + New tag <select-menu> + + <remote-method-button> now switches to in-place mode if you give any + ajax attribute (e.g. success="...") + + <after-submit> -- can now do + + <after-submit go-back> (requires session[:previous_uri]) + + and + + <after-submit stay-here> + + +Rapid tags: navigation + + Now assumes will_paginate style pagination instead of classic_pagination + + <account-nav> now proivides a link to the account page by default + + <account-nav> now provides a complete set of parameters for customisation + + +Rapid tags: pages + + login, signup and account-disabled pages have been moved out to + rapid-user-pages + + simple-layout -- the main-nav parameter is now on a wrapper around + <magic-nav> rather than actually on <magic-nav>, so this now works + as you'd expect: + + <main-nav:> --- your nav here --- </main-nav:> + + aside-layout -- the aside now appears in the output even if it's + empty + + <show-page> -- various improvements and new parameters + + <permission-denied-page> now sets a body class, and the message can + be changed with an attribute. + + <app-name> is gone -- this is now automatically generated in your + application.dryml (you may need to manually add this to existing + apps) + + +Rapid tags: plus + + New tag <change-password-form> + + + === Release 0.7.2 === Migration generator vendor/plugins/hobo/CHANGES.txt @@ -2,6 +2,8 @@ require 'rake' require 'rake/rdoctask' require 'rake/testtask' +load "tasks/generate_tag_reference.rb" + desc 'Default: run specs.' task :default => :spec vendor/plugins/hobo/Rakefile @@ -7,19 +7,21 @@ class HoboGenerator < Rails::Generator::Base route = " Hobo.add_routes(map)\n" route_src = File.read(routes_path) - return if route_src.include?(route) - - head = "ActionController::Routing::Routes.draw do |map|" - route_src.sub!(head, head + "\n\n" + route) - File.open(routes_path, 'w') {|f| f.write(route_src) } + + unless route_src.include?(route) + head = "ActionController::Routing::Routes.draw do |map|" + route_src.sub!(head, head + "\n\n" + route) + File.open(routes_path, 'w') {|f| f.write(route_src) } + end end record do |m| m.directory File.join("app/views/taglibs") m.directory File.join("app/views/taglibs/themes") m.directory File.join("public/hobothemes") - m.file "application.dryml", File.join("app/views/taglibs/application.dryml") + m.template "application.dryml", File.join("app/views/taglibs/application.dryml") m.file "guest.rb", File.join("app/models/guest.rb") + m.file "dryml-support.js", File.join("public/javascripts/dryml-support.js") end end vendor/plugins/hobo/generators/hobo/hobo_generator.rb @@ -1,2 +1,5 @@ <!-- Define your application-wide tags here --> +<def tag="app-name"><%= File.basename(Dir.chdir(RAILS_ROOT) { Dir.getwd }).strip.titleize %></def> + + vendor/plugins/hobo/generators/hobo/templates/application.dryml @@ -1,6 +1,6 @@ class HoboFrontControllerGenerator < Rails::Generator::NamedBase - default_options :no_user => false, :delete_index => false, :add_routes => false + default_options :delete_index => false, :add_routes => false def full_class_path class_path.blank? ? file_name : File.join(class_path, file_name) @@ -34,8 +34,7 @@ class HoboFrontControllerGenerator < Rails::Generator::NamedBase File.join('app/helpers', class_path, "#{file_name}_helper.rb")) - pages = options[:no_user] ? %w{index search} : %w{index search} - for page in pages + for page in %w{index search} m.template("#{page}.dryml", File.join('app/views', class_path, file_name, "#{page}.dryml")) end end @@ -49,7 +48,7 @@ class HoboFrontControllerGenerator < Rails::Generator::NamedBase routes_path = File.join(RAILS_ROOT, "config/routes.rb") name = full_class_path - route = (" map.search 'search', :controller => '#{name}', :action => 'search'\n" + + route = (" map.site_search 'search', :controller => '#{name}', :action => 'search'\n" + " map.homepage '', :controller => '#{name}', :action => 'index'") route_src = File.read(routes_path) @@ -68,7 +67,7 @@ class HoboFrontControllerGenerator < Rails::Generator::NamedBase protected def banner - "Usage: #{$0} #{spec.name} <controller-name> [--add-routes] [--no-user] [--delete-index]" + "Usage: #{$0} #{spec.name} <controller-name> [--add-routes] [--delete-index]" end def add_options!(opt) vendor/plugins/hobo/generators/hobo_front_controller/hobo_front_controller_generator.rb @@ -15,15 +15,8 @@ <content-body:> <ul with="&front_models"> <li:> - <header><h2><a/></h2></header> - <section> - <p if="&this.count == 0">There are no <type-name plural/></p> - <else> - <card repeat="&select_viewable(this.recent.all)"/> - <p><a>More</a> (<count/>)</p> - </else> - <p if="&can_create? && linkable?(:new)">Create a <a to="&this" action="new"/>.</p> - </section> + <collection-preview/> + <p if="&can_create? && linkable?(:new)">Create a <a to="&this" action="new"/>.</p> </li:> </ul> </content-body> vendor/plugins/hobo/generators/hobo_front_controller/templates/index.dryml @@ -1,6 +1,6 @@ class <%= class_name %> < ActiveRecord::Base - hobo_model + hobo_model # Don't put anything above this fields do <% for attribute in attributes -%> vendor/plugins/hobo/generators/hobo_model/templates/model.rb @@ -12,6 +12,7 @@ class HoboRapidGenerator < Hobo::Generator record do |m| m.file "hobo-rapid.js", "public/javascripts/hobo-rapid.js" m.file "lowpro.js", "public/javascripts/lowpro.js" + m.file "IE7.js", "public/javascripts/IE7.js" m.file "reset.css", "public/stylesheets/reset.css" m.file "hobo-rapid.css", "public/stylesheets/hobo-rapid.css" create_all(m, "themes/clean/public", "public/hobothemes/clean") vendor/plugins/hobo/generators/hobo_rapid/hobo_rapid_generator.rb @@ -37,7 +37,7 @@ var Hobo = { var opts = Object.merge(options || {}, { params: params}) Hobo.ajaxRequest(Hobo.putUrl(el), - el.getAttribute("hobo-ajax-message") || "Changing...", + el.getAttribute("hobo-ajax-message") || "Saving...", updates, opts) }, @@ -49,8 +49,7 @@ var Hobo = { updates.each(function(id_or_el) { var el = $(id_or_el) if (el) { // ignore update of parts that do not exist - var partDomId - partDomId = el.id + var partDomId = el.id if (!hoboParts[partDomId]) { throw "Update of dom-id that is not a part: " + partDomId } params.push("render["+i+"][part_context]=" + encodeURIComponent(hoboParts[partDomId])) params.push("render["+i+"][id]=" + partDomId) @@ -73,11 +72,12 @@ var Hobo = { return params.join('&') }, - ajaxRequest: function(url_or_form, message, updates, options) { + ajaxRequest: function(url_or_form, updates, options) { options = Object.merge({ asynchronous:true, evalScripts:true, resetForm: false, - refocusForm: false + refocusForm: false, + message: "Saving..." }, options) if (typeof url_or_form == "string") { var url = url_or_form @@ -104,7 +104,7 @@ var Hobo = { params.push(Form.serialize(form)) } - Hobo.showSpinner(message, options.spinnerNextTo) + Hobo.showSpinner(options.message, options.spinnerNextTo) var complete = function() { if (form && options.resetForm) form.reset(); Hobo.hideSpinner(); @@ -112,6 +112,7 @@ var Hobo = { if (options.onComplete) options.onComplete.apply(this, arguments) if (form && options.refocusForm) Form.focusFirstElement(form) + Event.addBehavior.reload() } if (options.method && options.method.toLowerCase() == "put") { delete options.method @@ -184,30 +185,30 @@ var Hobo = { var updateParams = Hobo.ajaxUpdateParams(updates, [{id: id, result: 'new_field_value', func: "Hobo.onFieldEditComplete"}]) - opts = {okButton: false, - cancelLink: false, - submitOnBlur: true, - evalScripts: true, - htmlResponse: false, - ajaxOptions: { method: "put" }, - onEnterHover: null, - onLeaveHover: null, - callback: function(form, val) { - old = val - return (Hobo.fieldSetParam(el, val) + "&" + updateParams) - }, - onFailure: function(resp) { - alert(resp.responseText); el.innerHTML = old - }, - onEnterEditMode: function() { - var blank_message = el.getAttribute("hobo-blank-message") - if (el.innerHTML.gsub("&nbsp;", " ") == blank_message) { - el.innerHTML = "" - } else { - Hobo.ipeOldValues[el.id] = el.innerHTML + var opts = {okButton: false, + cancelLink: false, + submitOnBlur: true, + evalScripts: true, + htmlResponse: false, + ajaxOptions: { method: "put" }, + onEnterHover: null, + onLeaveHover: null, + callback: function(form, val) { + old = val + return (Hobo.fieldSetParam(el, val) + "&" + updateParams) + }, + onFailure: function(resp) { + alert(resp.responseText); el.innerHTML = old + }, + onEnterEditMode: function() { + var blank_message = el.getAttribute("hobo-blank-message") + if (el.innerHTML.gsub("&nbsp;", " ") == blank_message) { + el.innerHTML = "" + } else { + Hobo.ipeOldValues[el.id] = el.innerHTML + } } - } - } + } Object.extend(opts, options) return new Ajax.InPlaceEditor(el, Hobo.putUrl(el), opts) }, @@ -219,14 +220,14 @@ var Hobo = { } select(".in-place-textfield-bhv").each(function (el) { - ipe = Hobo._makeInPlaceEditor(el) + var ipe = Hobo._makeInPlaceEditor(el) ipe.getText = function() { return this.element.innerHTML.gsub(/<br\s*\/?>/, "\n").unescapeHTML() } }) select(".in-place-textarea-bhv").each(function (el) { - ipe = Hobo._makeInPlaceEditor(el, {rows: 2}) + var ipe = Hobo._makeInPlaceEditor(el, {rows: 2}) ipe.getText = function() { return this.element.innerHTML.gsub(/<br\s*\/?>/, "\n").unescapeHTML() } @@ -258,19 +259,10 @@ var Hobo = { select("select.number-editor-bhv").each(function(el) { el.onchange = function() { - Hobo.ajaxSetFieldForElement(el, el.value) + Hobo.ajaxSetFieldForElement(el, $F(el)) } }) - select(".autocomplete-bhv").each(function (el) { - options = {paramName: "query", minChars: 3, method: 'get' } - if (el.hasClassName("autosubmit")) { - options.afterUpdateElement = function(el, item) { el.form.onsubmit(); } - } - new Ajax.Autocompleter(el, el.id + "-completions", el.getAttribute("autocomplete-url"), - options); - }); - select(".search-bhv").each(function(el) { new Form.Element.Observer(el, 1.0, function() { Hobo.doSearch(el) }) }); @@ -314,6 +306,14 @@ var Hobo = { return urlBase + "/" + Hobo.pluralise(spec.name) + "/" + spec.id + "?_method=PUT" }, + + urlForId: function(id) { + var spec = Hobo.parseId(id) + var url = urlBase + "/" + Hobo.pluralise(spec.name) + if (spec.id) { url += "/" + spec.id } + return url + }, + fieldSetParam: function(el, val) { spec = Hobo.parseFieldId(el) @@ -324,41 +324,62 @@ var Hobo = { return res }, + fadeObjectElement: function(el) { - new Effect.Fade(Hobo.objectElementFor(el), - { duration: 0.5, - afterFinish: function (ef) { ef.element.remove() } }); + var fadeEl = Hobo.objectElementFor(el) + new Effect.Fade(fadeEl, { duration: 0.5, afterFinish: function (ef) { + ef.element.remove() + } }); + Hobo.showEmptyMessageAfterLastRemove(fadeEl) }, + removeButton: function(el, url, updates, options) { if (options.fade == null) { options.fade = true; } if (options.confirm == null) { options.fade = "Are you sure?"; } if (options.confirm == false || confirm(options.confirm)) { - objEl = Hobo.objectElementFor(el) + var objEl = Hobo.objectElementFor(el) Hobo.showSpinner('Removing'); function complete() { if (options.fade) { Hobo.fadeObjectElement(el) } Hobo.hideSpinner() } if (updates && updates.length > 0) { - new Hobo.ajaxRequest(url, "Removing", updates, { method:'delete', - onComplete: complete}); + new Hobo.ajaxRequest(url, updates, { method:'delete', message: "Removing...", onComplete: complete}); } else { - new Ajax.Request(url, {asynchronous:true, evalScripts:true, method:'delete', - onComplete: complete}); + var ajaxOptions = {asynchronous:true, evalScripts:true, method:'delete', onComplete: complete} + if (typeof(formAuthToken) != "undefined") { + ajaxOptions.parameters = formAuthToken.name + "=" + formAuthToken.value + } + new Ajax.Request(url, ajaxOptions); } } }, + showEmptyMessageAfterLastRemove: function(el) { + var empty + var container = $(el.parentNode) + if (container.getElementsByTagName(el.nodeName).length == 1 && + (empty = container.next('.empty-collection-message'))) { + new Effect.Appear(empty, {delay:0.3}) + } + }, + + parseFieldId: function(el) { id = el.getAttribute("hobo-model-id") - if (!id) return - m = id.match(/^([a-z_]+)_([0-9]+)_([a-z_]+)$/) + return id && parseId(id) + }, + + + parseId: function(id) { + m = id.match(/^([a-z_]+)_([0-9]+)(?:_([a-z_]+))?$/) if (m) return { name: m[1], id: m[2], field: m[3] } }, + appendRow: function(el, rowSrc) { // IE friendly method to add a <tr> (from html source) to a table // el should be an element that contains *only* a table @@ -367,6 +388,7 @@ var Hobo = { Hobo.applyEvents(el) }, + objectElementFor: function(el) { var m while(el.getAttribute) { @@ -385,7 +407,7 @@ var Hobo = { if(t = $('ajax-progress-text')) Element.update(t, message); if(e = $('ajax-progress')) { if (nextTo) { - var pos = nextTo.cumulativeOffset() + var pos = $(nextTo).cumulativeOffset() e.style.top = pos.top + "px" e.style.left = (pos.left + nextTo.offsetWidth) + "px" } @@ -431,8 +453,14 @@ var Hobo = { return pluralisations[s] || s + "s" }, - addUrlParams: function(params) { + addUrlParams: function(params, options) { params = $H(window.location.search.toQueryParams()).merge(params) + + if (options.remove) { + var remove = (options.remove instanceof Array) ? options.remove : [options.remove] + remove.each(function(k) { params.unset(k) }) + } + return window.location.href.sub(/(\?.*|$)/, "?" + params.toQueryString()) } @@ -485,7 +513,7 @@ Element.Methods.$$ = function(e, css) { // --- has_many_through_input --- // -HasManyThroughInput = Behavior.create({ +SelectManyInput = Behavior.create({ initialize : function() { // onchange doesn't bubble in IE6 so... @@ -493,15 +521,16 @@ HasManyThroughInput = Behavior.create({ }, addOne : function() { - var select = this.element.down('select') + var select = this.element.down('select') var selected = select.options[select.selectedIndex] - if (selected.style.display != "none" & selected.value != "") { - var newItem = strToDom(this.element.down('.item-proto').innerHTML) + if (selected.style.display != "none" & selected.text != "") { + var newItem = $(DOM.Builder.fromHTML(this.element.down('.item-proto').innerHTML.strip())) this.element.down('.items').appendChild(newItem); newItem.down('span').innerHTML = selected.innerHTML - newItem.down('input[type=hidden]').value = selected.innerHTML + this.itemAdded(newItem, selected) selected.style.display = 'none' select.value = "" + Event.addBehavior.reload() } }, @@ -518,14 +547,50 @@ HasManyThroughInput = Behavior.create({ var label = el.down('span').innerHTML var option = $A(this.element.getElementsByTagName('option')).find(function(o) { return o.innerHTML == label }) option.style.display = 'block' + }, + + itemAdded: function(item, option) { + this.hiddenField(item).value = option.innerHTML + }, + + hiddenField: function(item) { + return item.down('input[type=hidden]') + //return item.getElementsByClassName("hidden-field")[0] } + }) Event.addBehavior({ - 'div.has-many-through.input' : HasManyThroughInput(), - '.dependent-collection-count:click' : function(e) { - new Effect.ScrollTo('dependent-collection', {duration: 1.0, offset: -10, transition: Effect.Transitions.sinoidal}); - Event.stop(e); - } + 'div.select-many.input' : SelectManyInput(), + + '.association-count:click' : function(e) { + new Effect.ScrollTo('primary-collection', {duration: 1.0, offset: -20, transition: Effect.Transitions.sinoidal}); + Event.stop(e); + }, + + 'form.filter-menu select:change': function(event) { + var paramName = this.up('form').down('input[type=hidden]').value.gsub("-", "_") + var params = {} + var remove = [ 'page' ] + if ($F(this) == '') { + remove.push(paramName) + } else { + params[paramName] = $F(this) + } + location.href = Hobo.addUrlParams(params, {remove: remove}) + }, + + '.autocompleter' : function(event) { + var target = this.className.match(/complete-on:([\S]+)/)[1].split(':') + var model = target[0] + var completer = target[1] + + var spec = Hobo.parseId(model) + var url = urlBase + "/" + Hobo.pluralise(spec.name) + "/complete_" + completer + var parameters = spec.id ? "id=" + spec.id : "" + new Ajax.Autocompleter(this, this.next('.completions-popup'), url, {paramName:'query', method:'get', parameters: parameters}); + } + + }); vendor/plugins/hobo/generators/hobo_rapid/templates/hobo-rapid.js @@ -1,8 +1,8 @@ LowPro = {}; LowPro.Version = '0.5'; -LowPro.CompatibleWithPrototype = '1.6.0'; +LowPro.CompatibleWithPrototype = '1.6'; -if (Prototype.Version != LowPro.CompatibleWithPrototype && console && console.warn) +if (Prototype.Version.indexOf(LowPro.CompatibleWithPrototype) != 0 && window.console && window.console.warn) console.warn("This version of Low Pro is tested with Prototype " + LowPro.CompatibleWithPrototype + " it may not work as expected with this version (" + Prototype.Version + ")"); @@ -15,19 +15,19 @@ DOM = {}; // DOMBuilder for prototype DOM.Builder = { tagFunc : function(tag) { - return function() { - var attrs, children; - if (arguments.length>0) { - if (arguments[0].nodeName || - typeof arguments[0] == "string") - children = arguments; - else { - attrs = arguments[0]; - children = Array.prototype.slice.call(arguments, 1); - }; - } - return DOM.Builder.create(tag, attrs, children); - }; + return function() { + var attrs, children; + if (arguments.length>0) { + if (arguments[0].constructor == Object) { + attrs = arguments[0]; + children = Array.prototype.slice.call(arguments, 1); + } else { + children = arguments; + }; + children = $A(children).flatten() + } + return DOM.Builder.create(tag, attrs, children); + }; }, create : function(tag, attrs, children) { attrs = attrs || {}; children = children || []; tag = tag.toLowerCase(); @@ -71,7 +71,8 @@ DOM.Builder.fromHTML = function(html) { // Event.onReady(callbackFunction); Object.extend(Event, { onReady : function(f) { - document.observe('dom:loaded', f); + if (document.body) f(); + else document.observe('dom:loaded', f); } }); @@ -96,7 +97,7 @@ Event.addBehavior = function(rules) { Ajax.Responders.register({ onComplete : function() { if (Event.addBehavior.reassignAfterAjax) - setTimeout(function() { ab.unload(); ab.load(ab.rules) }, 10); + setTimeout(function() { ab.reload() }, 10); } }); ab.responderApplied = true; @@ -145,6 +146,12 @@ Object.extend(Event.addBehavior, { this.cache = []; }, + reload: function() { + var ab = Event.addBehavior; + ab.unload(); + ab.load(ab.rules); + }, + _wrapObserver: function(observer) { return function(event) { if (observer.call(this, event) === false) event.stop(); @@ -277,7 +284,7 @@ Remote.Form = Behavior.create(Remote.Base, { onclick : function(e) { var sourceElement = e.element(); - if (sourceElement.nodeName.toLowerCase() == 'input' && + if (['input', 'button'].include(sourceElement.nodeName.toLowerCase()) && sourceElement.type == 'submit') this._submitButton = sourceElement; }, vendor/plugins/hobo/generators/hobo_rapid/templates/lowpro.js vendor/plugins/hobo/generators/hobo_rapid/templates/themes/clean/public/images/pencil.png @@ -17,11 +17,6 @@ table.new-record textarea, table.new-record input { display: inline; } -.edit-page .content-header {overflow: hidden; height: 100%;} -.edit-page .content-header h1 {float: left;} -.edit-page .content-header .delete-button {float: right;} -form .actions {margin: 30px 0;width: 100%; text-align: center;} - /**** Admin ****/ .admin-banner { @@ -39,25 +34,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;} float: right; } -/* rails error message */ -.error-messages { - font-family: "Lucida Grande", arial, sans-serif; - background: #9d0018; - border: 1px solid #7a0013; - padding: 15px 30px; - color: white; - margin-bottom: 20px; -} -.error-messages h2 { - text-transform: none; - letter-spacing: normal; - color: white; - margin-bottom: 10px; -} -.error-messages li { - margin-left: 20px; -} - /********* everything below here came from hobo_rapid.css, needs looking at ********/ /**** Default styling for Rapid ***/ @@ -66,30 +42,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;} float: right; margin: 20px; position: fixed; display: none; z-index: 10; } -/* -#ajax-progress { - color: grey; - float: right; - margin: 20px; - position: fixed; - background: white; - font-family: Tahoma "sans serif"; - display: none; - z-index: 10; -} - -#ajax-progress div { - border: 1px dashed grey; - margin: 10px; - padding: 3px; - padding-top: -15px; -} - -#ajax-progress img { - padding-left: 6px; - vertical-align: middle; -} -*/ /* Scriptaculous Autocompleter ---*/ @@ -126,7 +78,7 @@ div.completions-popup ul li { text-align: left; width: 1px; white-space: nowrap; vertical-align: top; padding-top: 10px; padding-bottom: 10px; } -.field-list textarea, .field-list input.string, .field-list input.password { width: 100%; margin: 0; } +.field-list textarea, .field-list input.string, .field-list input.password { width: 99%; margin: 0; } /*input[type=text].wide { width: 100%; }*/ textarea { height: 170px; } vendor/plugins/hobo/generators/hobo_rapid/templates/themes/clean/public/stylesheets/rapid-ui.css @@ -1,6 +1,6 @@ class <%= class_name %> < ActiveRecord::Base - hobo_user_model + hobo_user_model # Don't put anything above this fields do username :string, :login => true, :name => true @@ -17,7 +17,7 @@ class <%= class_name %> < ActiveRecord::Base # def super_user?; true; end def creatable_by?(creator) - true + creator.administrator? || !administrator end def updatable_by?(updater, new) vendor/plugins/hobo/generators/hobo_user_model/templates/model.rb @@ -1,16 +1,23 @@ +# gem dependencies +require 'hobosupport' +require 'hobofields' +begin + require 'will_paginate' +rescue MissingSourceFile + # OK, Hobo won't do pagination then +end + # Monkey patches, ooh ooh -require 'extensions' -require 'rexml' require 'active_record/has_many_association' require 'active_record/has_many_through_association' -require 'active_record/table_definition' +require 'active_record/association_proxy' +require 'active_record/association_reflection' require 'action_view_extensions/base' require 'hobo' require 'hobo/dryml' require 'hobo/model' -require 'hobo/field_declaration_dsl' require 'hobo/dryml/template' require 'hobo/dryml/taglib' @@ -19,15 +26,6 @@ require 'hobo/dryml/template_handler' require 'extensions/test_case' if RAILS_ENV == "test" -# Rich data types -require "hobo/html_string" -require "hobo/markdown_string" -require "hobo/textile_string" -require "hobo/password_string" -require "hobo/text" -require "hobo/email_address" -require "hobo/enum_string" -require "hobo/percentage" ActionView::Base.register_template_handler("dryml", Hobo::Dryml::TemplateHandler) @@ -54,6 +52,7 @@ end class ActiveRecord::Base def self.hobo_model include Hobo::Model + fields # force hobofields to load end def self.hobo_user_model include Hobo::Model @@ -64,3 +63,39 @@ end # Default settings Hobo.developer_features = RAILS_ENV.in?(["development", "test"]) if Hobo.developer_features?.nil? + + +module ::Hobo + # Empty class to represent the boolean type. + class Boolean; end +end + + +if defined? HoboFields + HoboFields.never_wrap(Hobo::Undefined) +end + + +# Add support for type metadata to arrays +class ::Array + + attr_accessor :member_class, :origin, :origin_attribute + + def to_url_path + base_path = origin_object.try.to_url_path + "#{base_path}/#{origin_attribute}" unless base_path.blank? + end + + def typed_id + origin_id = origin.try.typed_id + "#{origin_id}_#{origin_attribute}" if origin_id + end + +end + + +class NilClass + def typed_id + "nil" + end +end vendor/plugins/hobo/init.rb @@ -2,12 +2,13 @@ module ActionView class Base - alias_method :render_file_without_hobo, :render_file - def render_file(template_path, *args) + def render_file_with_dryml(template_path, *args) @hobo_template_path = template_path - render_file_without_hobo(template_path, *args) + render_file_without_dryml(template_path, *args) end + alias_method_chain :render_file, :dryml + end end vendor/plugins/hobo/lib/action_view_extensions/base.rb @@ -18,7 +18,7 @@ module ActiveRecord::Associations record = @reflection.klass.new(attributes) if hobo_has_many? set_belongs_to_association_for(record) - set_reverse_association(record) + set_reverse_association(record) unless proxy_reflection.options[:as] end record end @@ -29,16 +29,15 @@ module ActiveRecord::Associations end - def find_with_block(*args, &b) - if b - options = args.extract_options! - args << options.merge(:conditions => member_class.conditions(&b)) - find_without_block(*args) - else - find_without_block(*args) - end + def origin + proxy_owner end - alias_method_chain :find, :block + + + def origin_attribute + proxy_reflection.association_name + end + private vendor/plugins/hobo/lib/active_record/has_many_association.rb @@ -5,6 +5,14 @@ module ActiveRecord::Associations def member_class proxy_reflection.klass end + + def origin + proxy_owner + end + + def origin_attribute + proxy_reflection.association_name + end end vendor/plugins/hobo/lib/active_record/has_many_through_association.rb @@ -102,7 +102,7 @@ class Test::Unit::TestCase def replace_objects_in_params!(hash) hash.each do |k,v| if v.is_a? ActiveRecord::Base - hash[k] = "@" + Hobo.dom_id(v) + hash[k] = "@" + v.typed_id elsif v.is_a? Hash replace_objects_in_params!(v) end vendor/plugins/hobo/lib/extensions/test_case.rb @@ -1,24 +1,18 @@ class HoboError < RuntimeError; end module Hobo + + VERSION = "0.7.5" class RawJs < String; end @models = [] - @field_types = HashWithIndifferentAccess.new class << self - attr_accessor :current_theme, :field_types + attr_accessor :current_theme attr_writer :developer_features - def symbolic_type_name(type) - field_types.index(type) - end - - def type_id(type) - symbolic_type_name(type) || type.name.underscore.gsub("/", "__") - end def developer_features? @developer_features @@ -41,7 +35,7 @@ module Hobo def models=(models) - @models = models.every(:name) + @models = models.*.name end @@ -52,7 +46,7 @@ module Hobo end @models_loaded = true end - @models.every(:constantize) + @models.*.constantize end @@ -87,64 +81,38 @@ module Hobo end def dom_id(obj, attr=nil) - if obj.nil? - raise ArgumentError, "Tried to get dom id of nil.#{attr}" if attr - return 'nil' - end - - if obj.is_a?(Array) and obj.respond_to?(:proxy_owner) - attr = obj.proxy_reflection.name - obj = obj.proxy_owner - elsif obj.is_a?(Class) - return type_id(obj) - elsif !obj.respond_to?(:typed_id) - return (if attr - dom_id(get_field(obj, attr)) - elsif obj.respond_to?(:id) - "#{obj.class.name.underscore}_#{obj.id}" - else - raise ArgumentError, "Can't create dom id for #{obj.inspect}" - end) - end attr ? "#{obj.typed_id}_#{attr}" : obj.typed_id end - def find_by_search(query) - sql = Hobo.models.map do |model| - 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 - else - where = cols.map {|c| "(#{c} like ?)"}.join(' or ') - type = model.column_names.include?("type") ? "type" : "'#{model.name}'" - ActiveRecord::Base.send(:sanitize_sql, - ["select #{type} as type, id " + - "from #{model.table_name} " + - "where #{where}"] + - ["%#{query}%"] * cols.length) + def find_by_search(query, search_targets=nil) + search_targets ||= + begin + # FIXME: This should interrogate the model-router directly, there's no need to enumerate models + # By default, search all models, but filter out... + Hobo.models.select do |m| + ModelRouter.linkable?(m, :show) && # ...non-linkables + m.search_columns.any? # and models with no search-columns end end - end.compact.join(" union ") - - rows = ActiveRecord::Base.connection.select_all(sql) - records = Hash.new {|h,k| h[k] = []} - for row in rows - records[row['type']] << row['id'] - end - results = [] - for type, ids in records - results.concat(type.constantize.find(:all, :conditions => "id in (#{ids * ','})")) - end - results + query_words = ActiveRecord::Base.connection.quote_string(query).split + + search_targets.build_hash do |search_target| + conditions = query_words.map do |word| + "(" + search_target.search_columns.map { |column| %(#{column} like "%#{word}%") }.join(" or ") + ")" + end.join(" and ") + + results = search_target.find(:all, :conditions => conditions) + [search_target.name, results] unless results.empty? + end end def add_routes(m) Hobo::ModelRouter.add_routes(m) end + + # FIXME: This method won't be needed def all_models Hobo.models.map { |m| m.name.underscore } end @@ -159,6 +127,16 @@ module Hobo end + def can_create_in_association?(array_or_reflection) + refl = + (array_or_reflection.is_a?(ActiveRecord::Reflection::AssociationReflection) and array_or_reflection) or + array_or_reflection.try.proxy_reflection or + (origin = array_or_reflection.try.origin and origin.send(array_or_reflection.origin_attribute).try.proxy_reflection) + + refl && refl.macro == :has_many && (!refl.through_reflection) && (!refl.options[:conditions]) + end + + def get_field(object, field) return nil if object.nil? if field.to_s =~ /^\d+$/ @@ -195,9 +173,13 @@ module Hobo if object.is_a?(Class) and object < ActiveRecord::Base object = object.new object.set_creator(person) - elsif Hobo.simple_has_many_association?(object) - object = object.new - object.set_creator(person) + elsif (refl = object.try.proxy_reflection) && refl.macro == :has_many + if Hobo.simple_has_many_association?(object) + object = object.new + object.set_creator(person) + else + return false + end end check_permission(:create, person, object) end @@ -213,10 +195,12 @@ module Hobo return false if !can_view?(person, object, field) if field.nil? - if respond_to?(:editable_by?) + if object.has_hobo_method?(:editable_by?) object.editable_by?(person) - else + elsif object.has_hobo_method?(:updatable_by?) object.updatable_by?(person, nil) + else + false end else @@ -232,13 +216,13 @@ module Hobo object.send("#{field}_editable_by?", person) elsif object.has_hobo_method?(:editable_by?) check_permission(:edit, person, object) + elsif refl._?.macro == :has_many + # The below technique to figure out edit permission based on + # update permission doesn't work for has_many associations + false 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 @@ -257,7 +241,7 @@ module Hobo end) rescue Hobo::UndefinedAccessError raise HoboError, ("#{object.class.name}##{field} does not support undefined assignements, " + - "define editable_by?(user, field)") + "define #{field}_editable_by?(user)") end begin @@ -333,7 +317,7 @@ module Hobo else File.join(File.dirname(__FILE__), "hobo/static_tags") end - File.readlines(path).every(:chop) + File.readlines(path).*.chop end end @@ -355,7 +339,7 @@ module Hobo when :edit; :editable_by? when :view; :viewable_by? end - p = if object.has_hobo_method?(obj_method) + p = if (obj_method.respond_to?(:has_hobo_method) ? object.has_hobo_method?(obj_method) : object.respond_to?(obj_method)) begin object.send(obj_method, person, *args) rescue Hobo::UndefinedAccessError vendor/plugins/hobo/lib/hobo.rb @@ -38,7 +38,7 @@ module Hobo # skip_before_filter :login_required # def login_required(user_model=nil) - auth_model = user_model || UserController.user_models.first + auth_model = user_model || User.default_user_model if current_user.guest? username, passwd = get_auth_data self.current_user = auth_model.authenticate(username, passwd) || nil if username && passwd && auth_model vendor/plugins/hobo/lib/hobo/authentication_support.rb @@ -1,5 +1,3 @@ -require 'extensions' - module ::Hobo class Bundle @@ -8,48 +6,93 @@ module ::Hobo class << self - attr_accessor :bundles, :plugin + # Hobo::Bundle.bundles is a hash of all instantiated bundles by name + attr_accessor :bundles + + # Used by subclasses, e.g MyBundle.plugin is the name of the + # plugin the bundle came from + attr_reader :plugin + + attr_reader :model_declarations, :controller_declarations + + attr_accessor :dirname def inherited(base) filename = caller[0].match(/^(.*):\d+/)[1] - dirname = filename.match(%r(^.*/plugins/[^/]+))[0] - base.plugin = File.basename(dirname) + base.dirname = filename.match(%r(^.*/plugins/[^/]+))[0] + end + + + def load_models_and_controllers + return if models_and_controllers_loaded? - base.meta_eval do - attr_accessor :models, :controllers - end + @plugin = File.basename(dirname) - base.models = [] - base.controllers = [] + @model_declarations = [] + @controller_declarations = [] - eval_ruby_files(base, "#{dirname}/models") - eval_ruby_files(base, "#{dirname}/controllers") + class_eval do + eval_ruby_files("#{dirname}/models", @models) + eval_ruby_files("#{dirname}/controllers", @controllers) + end end + def [](bundle_name) + bundles[bundle_name] + end + + + private def bundle_model(name, &block) - models << [name, block] + @model_declarations << [name, block] end def bundle_model_controller(model_name, &block) - controllers << [model_name, block] + @controller_declarations << [model_name, block] + end + + + def models_and_controllers_loaded? + @model_declarations end - private - def eval_ruby_files(base, dir) - Dir["#{dir}/*.rb"].each do |f| - base.instance_eval(File.read(f), f, 1) - end + def eval_ruby_files(dir, filenames) + files = if filenames == [:none] + [] + elsif filenames.blank? || filenames == [:all] + Dir["#{dir}/*.rb"] + else + filenames.map { |f| "#{dir}/#{f}.rb" } + end + + files.each { |f| instance_eval(File.read(f), f, 1) } + end + + + # Declarations + + def models(*models) + @models = models + end + + def controllers(*controllers) + @controllers = controllers.map {|c| case c.to_s + when /controller$/, "all", "none" then c + else "#{c.to_s.pluralize}_controller" + end } end end def initialize(*args) + self.class.load_models_and_controllers + options = defaults.with_indifferent_access - options.update(args.extract_options!) + options.recursive_update(args.extract_options!) self.name = args.first || self.class.name.match(/[^:]+$/)[0].underscore Bundle.bundles[name] = self @@ -78,19 +121,53 @@ module ::Hobo def create_models - self.class.models.each do |name, block| - klass = make_class(new_name_for(name), ActiveRecord::Base) do - hobo_model + self.class.model_declarations.each do |name, block| + klass = make_class(new_name_for(name), ActiveRecord::Base) + + klass.meta_def :belongs_to_with_optional_polymorphism do |*args| + opts = args.extract_options! + + if opts[:polymorphic] == :optional + if bundle.options["polymorphic_#{name}"] + opts[:polymorphic] = true + opts.delete(:class_name) + else + opts.delete(:polymorphic) + end + end + belongs_to_without_optional_polymorphism(name, opts) end - klass.class_eval(&block) + klass.meta_eval { alias_method_chain :belongs_to, :optional_polymorphism } + + klass.class_eval { hobo_model } + + # FIXME this extension breaks passing a block to belongs_to + klass.meta_def :belongs_to_with_alias do |*args| + opts = args.extract_options! + name = args.first.to_sym + + alias_name = opts.delete(:alias) + + belongs_to_without_alias(name, opts) + + if alias_name && name != alias_name + klass.send(:alias_method, alias_name, name) + # make the aliased name available in the classes metadata + klass.reflections[alias_name] = klass.reflections[name] + end + + end + klass.meta_eval { alias_method_chain :belongs_to, :alias } + + 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 + self.class.controller_declarations.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) @@ -106,6 +183,14 @@ module ::Hobo def self.feature(name, &block) _feature(name, block) end + + def method_missing(name, *args) + if name.to_s =~ /^_.*_$/ + self.class.bundle.magic_option(name) + else + super + end + end end klass.meta_def(:bundle) do @@ -134,18 +219,34 @@ module ::Hobo 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 + name = name.to_s + underscore = name =~ /^[a-z]/ + name = name.camelize if underscore + + plural = !renames.has_key?(name) && (p = name.singularize) && renames.has_key?(p) + name = p if plural + + # Keep a track of names we've seen to avoid cycles + seen = [ name ] + + name = name.gsub(/_.*?_/) { |s| new_name_for(s[1..-2]) } + while (newname = renames[name]) + name = newname + name = name.gsub(/_.*?_/) { |s| new_name_for(s[1..-2]) } + + break if name.in?(seen) + seen << name end + + name = name.underscore if underscore + name = name.pluralize if plural + name = name.to_sym if underscore || plural name end @@ -155,8 +256,6 @@ module ::Hobo 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 @@ -169,7 +268,7 @@ module ::Hobo new_name_for(name).to_s.constantize.class_eval(&block) end - + def method_missing(name, *args) if name.to_s =~ /^_.*_$/ magic_option(name) @@ -213,7 +312,15 @@ module ::Hobo 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)) + + sub_bundle_options = external_options.merge(local_options).merge(renames) + sub_bundle = class_name.to_s.constantize.new(name, sub_bundle_options) + + conflicting_renames = (renames.keys & sub_bundle.renames.keys).select { |k| renames[k] != sub_bundle.renames[k] } + unless conflicting_renames.empty? + raise ArgumentError, "Conflicting renames in included bundle '#{name}' of '#{self.name}': #{conflicting_renames * ', '}" + end + renames.update(sub_bundle.renames) self.options["#{option_name}_bundle"] = name end vendor/plugins/hobo/lib/hobo/bundle.rb @@ -62,7 +62,7 @@ module Hobo def id objects = self.class.models.map {|m| instance_variable_get("@#{m.underscore}")} - objects.every(:id).join("_") + objects.*.id.join("_") end alias_method :to_param, :id vendor/plugins/hobo/lib/hobo/composite_model.rb @@ -87,12 +87,10 @@ module Hobo page << renderer.part_contexts_storage if renderer end end - - - def render_tag(tag, options={}, render_options={}) - add_variables_to_assigns - text = Hobo::Dryml.render_tag(@template, tag, options) - text && render({:text => text, :layout => false }.merge(render_options)) + + + def dryml_context + @this end @@ -111,11 +109,12 @@ module Hobo def site_search(query) - results = Hobo.find_by_search(query).select {|r| Hobo.can_view?(current_user, r, nil)} + results = Hobo.find_by_search(query).select{|r| Hobo.can_view?(current_user, r, nil)} if results.empty? render :text => "<p>Your search returned no matches.</p>" else - render_tags(results, :card, :for_type => true) + # TODO: call one tag that renders all the search results with headings for each model + render_tags(results.map {|r|r.last}.flatten, :search_card, :for_type => true) end end vendor/plugins/hobo/lib/hobo/controller.rb @@ -27,7 +27,11 @@ module Hobo APPLICATION_TAGLIB = { :src => "taglibs/application" } CORE_TAGLIB = { :src => "core", :plugin => "hobo" } - DEFAULT_IMPORTS = [Hobo::HoboHelper, ApplicationHelper] + DEFAULT_IMPORTS = (if defined?(ApplicationHelper) + [Hobo::HoboHelper, ApplicationHelper] + else + [Hobo::HoboHelper] + end) @renderer_classes = {} @tag_page_renderer_classes = {} vendor/plugins/hobo/lib/hobo/dryml.rb @@ -2,13 +2,17 @@ module Hobo::Dryml class DRYMLBuilder - def initialize(template_path) - @template_path = template_path + def initialize(template) + @template = template @build_instructions = Array.new @part_names = [] end - attr_reader :template_path + attr_reader :template + + def template_path + template.template_path + end def set_environment(environment) @@ -34,7 +38,7 @@ module Hobo::Dryml def add_part(name, src, line_num) raise DrymlException.new("duplicate part: #{name}", template_path, line_num) if name.in?(@part_names) - add_build_instruction(:part, :src => src, :line_num => line_num) + add_build_instruction(:def, :src => src, :line_num => line_num) @part_names << name end @@ -50,7 +54,7 @@ module Hobo::Dryml ("def render_page(__page_this__, __local_assigns__); " + "#{locals} new_object_context(__page_this__) do " + src + - "; _erbout; end + part_contexts_storage_tag; end") + "; _erbout; end; end") end @@ -73,9 +77,6 @@ module Hobo::Dryml src = erb_process(instruction[:src]) @environment.class_eval(src, template_path, instruction[:line_num]) - when :part - @environment.class_eval(erb_process(instruction[:src]), template_path, instruction[:line_num]) - when :render_page method_src = render_page_source(erb_process(instruction[:src]), local_names) @environment.compiled_local_names = local_names @@ -107,7 +108,12 @@ module Hobo::Dryml import_module(options[:module].constantize, options[:as]) else template_dir = File.dirname(template_path) - taglib = Taglib.get(options.merge(:template_dir => template_dir)) + options = options.merge(:template_dir => template_dir) + + # Pass on the current bundle, if there is one, to the sub-taglib + options[:bundle] = template.bundle.name unless template.bundle.nil? || options[:bundle] || options[:plugin] + + taglib = Taglib.get(options) taglib.import_into(@environment, options[:as]) end end @@ -122,7 +128,7 @@ module Hobo::Dryml def set_theme(name) if Hobo.current_theme.nil? or Hobo.current_theme == name Hobo.current_theme = name - import_taglib(:src => "taglibs/themes/#{name}/application") + import_taglib(:src => "taglibs/themes/#{name}/#{name}") end end end vendor/plugins/hobo/lib/hobo/dryml/dryml_builder.rb @@ -7,14 +7,12 @@ module Hobo::Dryml end def [](key) - @scopes.reverse_each do |s| - return s[key] if s.has_key?(key) - end - nil + s = scope_with_key(key) and s[key] end def []=(key, val) - @scopes.last[key] = val + s = scope_with_key(key) || @scopes.last + s[key] = val end def new_scope @@ -24,6 +22,13 @@ module Hobo::Dryml res end + def scope_with_key(key) + @scopes.reverse_each do |s| + return s if s.has_key?(key) + end + nil + end + def method_missing(name, *args) if name.to_s =~ /=$/ self[name.to_s[0..-2].to_sym] = args.first vendor/plugins/hobo/lib/hobo/dryml/scoped_variables.rb @@ -14,10 +14,9 @@ module Hobo taglib.reload else src_file = taglib_filename(options) - renames = (bundle = options[:bundle] and - Bundle.bundles[bundle]._?.renames) + bundle = options[:bundle] && Bundle.bundles[options[:bundle]] - taglib = Taglib.new(src_file, renames) + taglib = Taglib.new(src_file, bundle) @cache[options] = taglib end taglib @@ -38,7 +37,7 @@ module Hobo elsif options[:src] =~ /\// "app/views" else - options[:template_dir] + options[:template_dir].gsub(/^\//, "") # remove leading / if there is one end filename = "#{RAILS_ROOT}/#{base}/#{options[:src]}.dryml" @@ -48,9 +47,9 @@ module Hobo end - def initialize(src_file, renames) + def initialize(src_file, bundle) @src_file = src_file - @renames = renames + @bundle = bundle load end @@ -84,7 +83,7 @@ module Hobo end end - template = Template.new(File.read(@src_file), @module, @src_file, @renames) + template = Template.new(File.read(@src_file), @module, @src_file, @bundle) template.compile([], []) @last_load_time = File.mtime(@src_file) end vendor/plugins/hobo/lib/hobo/dryml/taglib.rb @@ -12,11 +12,15 @@ module Hobo::Dryml CODE_ATTRIBUTE_CHAR = "&" + NO_METADATA_TAGS = %w(doctype if else unless repeat do with name type-name) + SPECIAL_ATTRIBUTES = %w(param merge merge-params merge-attrs for-type if unless repeat part part-locals restore) + + VALID_PARAMETER_TAG_ATTRIBUTES = %w(param replace) @build_cache = {} @@ -28,19 +32,19 @@ module Hobo::Dryml end end - def initialize(src, environment, template_path, renames={}) + def initialize(src, environment, template_path, bundle=nil) @src = src @environment = environment # a class or a module @template_path = template_path.sub(/^#{Regexp.escape(RAILS_ROOT)}/, "") - @class_renames = renames + @bundle = bundle - @builder = Template.build_cache[@template_path] || DRYMLBuilder.new(@template_path) + @builder = Template.build_cache[@template_path] || DRYMLBuilder.new(self) @builder.set_environment(environment) @last_element = nil end - attr_reader :tags, :template_path, :class_renames + attr_reader :tags, :template_path, :bundle def compile(local_names=[], auto_taglibs=[]) now = Time.now @@ -74,6 +78,7 @@ module Hobo::Dryml def create_render_page_method erb_src = process_src + @builder.add_build_instruction(:render_page, :src => erb_src, :line_num => 1) end @@ -84,30 +89,14 @@ module Hobo::Dryml def process_src - # Replace <%...%> scriptlets with xml-safe references into a hash of scriptlets - @scriptlets = {} - src = @src.gsub(/<%(.*?)%>/m) do - _, scriptlet = *Regexp.last_match - id = @scriptlets.size + 1 - @scriptlets[id] = scriptlet - newlines = "\n" * scriptlet.count("\n") - "[![HOBO-ERB#{id}#{newlines}]!]" - end - - @xmlsrc = "<dryml_page>" + src + "</dryml_page>" - begin - @doc = REXML::Document.new(RexSource.new(@xmlsrc), :dryml_mode => true) - rescue REXML::ParseException => e - raise DrymlSyntaxError, "File: #{@template_path}\n#{e}" - end - @doc.default_attribute_value = "&true" - - restore_erb_scriptlets(children_to_erb(@doc.root)) + @doc = Hobo::Dryml::Parser::Document.new(@src, @template_path) + result = children_to_erb(@doc.root) + restore_erb_scriptlets(result) end def restore_erb_scriptlets(src) - src.gsub(/\[!\[HOBO-ERB(\d+)\s*\]!\]/m) {|s| "<%#{@scriptlets[$1.to_i]}%>" } + @doc.restore_erb_scriptlets(src) end @@ -127,7 +116,7 @@ module Hobo::Dryml REXML::Comment::START + node.to_s + REXML::Comment::STOP when REXML::Text - node.to_s + strip_suppressed_whiteaspace(node.to_s) when REXML::Element element_to_erb(node) @@ -135,6 +124,11 @@ module Hobo::Dryml end + def strip_suppressed_whiteaspace(s) + s # s.gsub(/ -(\s*\n\s*)/, '<% \1 %>') + end + + def element_to_erb(el) dryml_exception("old-style parameter tag (<#{el.name}>)", el) if el.name.starts_with?(":") @@ -194,7 +188,7 @@ module Hobo::Dryml def set_element(el) assigns = el.attributes.map do |name, value| - dryml_exception(el, "invalid name in set") unless name =~ /^#{DRYML_NAME}(\.#{DRYML_NAME})*$/ + dryml_exception("invalid name in <set>", el) unless name =~ /^#{DRYML_NAME}(\.#{DRYML_NAME})*$/ "#{ruby_name name} = #{attribute_to_ruby(value)}; " end.join code = apply_control_attributes("begin; #{assigns}; end", el) @@ -204,7 +198,7 @@ module Hobo::Dryml def set_scoped_element(el) assigns = el.attributes.map do |name, value| - dryml_exception(el, "invalid name in set-scoped") unless name =~ DRYML_NAME_RX + dryml_exception("invalid name in <set-scoped>", el) unless name =~ DRYML_NAME_RX "scope[:#{ruby_name name}] = #{attribute_to_ruby(value)}; " end.join "<% scope.new_scope { #{assigns}#{tag_newlines(el)} %>#{children_to_erb(el)}<% } %>" @@ -214,7 +208,7 @@ module Hobo::Dryml def declared_attributes(def_element) attrspec = def_element.attributes["attrs"] attr_names = attrspec ? attrspec.split(/\s*,\s*/).map{ |n| n.underscore.to_sym } : [] - invalids = attr_names & ([:with, :field, :this] + SPECIAL_ATTRIBUTES.every(:to_sym)) + invalids = attr_names & ([:with, :field, :this] + SPECIAL_ATTRIBUTES.*.to_sym) dryml_exception("invalid attrs in def: #{invalids * ', '}", def_element) unless invalids.empty? attr_names end @@ -243,11 +237,12 @@ module Hobo::Dryml unsafe_name = el.attributes["tag"] name = Hobo::Dryml.unreserve(unsafe_name) if (for_type = el.attributes['for']) - type_name = case for_type - when /^[a-z]/ + type_name = if defined?(HoboFields) && for_type =~ /^[a-z]/ # It's a symbolic type name - look up the Ruby type name - Hobo.field_types[for_type].name - when /^_.*_$/ + klass = HoboFields.to_class(for_type) + dryml_exception("No such type in polymorphic tag definition: '#{for_type}'", el) unless klass + klass.name + elsif for_type =~ /^_.*_$/ rename_class(for_type) else for_type @@ -257,13 +252,8 @@ module Hobo::Dryml unsafe_name += suffix end - # While processing this def, @def_name contains - # the names of all nested defs join with '_'. It's used to - # disambiguate local variables as a workaround for the broken - # scope semantics of Ruby 1.8. - old_def_name = @def_name - @def_name = @def_name ? "#{@def_name}_#{unsafe_name}" : unsafe_name - + @def_element = el + alias_of = el.attributes['alias-of'] extend_with = el.attributes['extend-with'] @@ -272,7 +262,8 @@ module Hobo::Dryml @builder.add_build_instruction(:alias_method, - :new => ruby_name(name).to_sym, :old => ruby_name(alias_of).to_sym) if alias_of + :new => ruby_name(name).to_sym, + :old => ruby_name(Hobo::Dryml.unreserve(alias_of)).to_sym) if alias_of res = if alias_of "<% #{tag_newlines(el)} %>" @@ -293,7 +284,7 @@ module Hobo::Dryml # keep line numbers matching up "<% #{"\n" * src.count("\n")} %>" end - @def_name = old_def_name + @def_element = nil res end @@ -332,13 +323,52 @@ module Hobo::Dryml "#{start} " + # reproduce any line breaks in the start-tag so that line numbers are preserved tag_newlines(el) + "%>" + - children_to_erb(el) + + wrap_tag_method_body_with_metadata(children_to_erb(el)) + "<% _erbout; end" end + + def wrap_source_with_metadata(content, kind, name, *args) + if (!include_source_metadata) || name.in?(NO_METADATA_TAGS) + content + else + metadata = [kind, name] + args + [@template_path] + "<!--[DRYML|#{metadata * '|'}[-->" + content + "<!--]DRYML]-->" + end + end + + + def wrap_tag_method_body_with_metadata(content) + name = @def_element.attributes['tag'] + extend = @def_element.attributes['extend-with'] + for_ = @def_element.attributes['for'] + name = extend ? "#{name}-with-#{extend}" : name + name += " for #{for_}" if for_ + wrap_source_with_metadata(content, "def", name, element_line_num(@def_element)) + end + + + def wrap_tag_call_with_metadata(el, content) + name = el.expanded_name + param = el.attributes['param'] + + if param == "&true" + name += " param" + elsif param + name += " param='#{param}'" + end + + wrap_source_with_metadata(content, "call", name, element_line_num(el)) + end + - def param_content_element(el) - name = el.attributes['for'] || @containing_tag_name + def param_content_element(name_or_el) + name = if name_or_el.is_a?(String) + name_or_el + else + el = name_or_el + el.attributes['for'] || @containing_tag_name + end local_name = param_content_local_name(name) "<%= #{local_name} && #{local_name}.call %>" end @@ -346,10 +376,19 @@ module Hobo::Dryml def part_element(el, content) require_attribute(el, "part", DRYML_NAME_RX) + + if contains_param?(el) + delegated_part_element(el, content) + else + simple_part_element(el, content) + end + end + + + def simple_part_element(el, content) part_name = el.attributes['part'] dom_id = el.attributes['id'] || part_name part_name = ruby_name(part_name) - part_locals = el.attributes["part-locals"] part_src = "<% def #{part_name}_part(#{part_locals._?.gsub('@', '')}) #{tag_newlines(el)}; new_context do %>" + @@ -363,6 +402,22 @@ module Hobo::Dryml end + def delegated_part_element(el, content) + # TODO + end + + + def contains_param?(el) + # TODO + false + end + + + def part_delegate_tag_name(el) + "#{@def_name}_#{el.attributes['part']}__part_delegate" + end + + def get_param_name(el) param_name = el.attributes["param"] @@ -391,8 +446,8 @@ module Hobo::Dryml 'this_type' elsif t =~ /^[A-Z]/ t - elsif t =~ /^[a-z]/ - "Hobo.field_types[:#{t}]" + elsif t =~ /^[a-z]/ && defined? HoboFields.to_class + "Hobo.to_class(:#{t})" elsif is_code_attribute?(t) t[1..-1] else @@ -431,14 +486,21 @@ module Hobo::Dryml elsif (call_type = polymorphic_call_type(el)) "send(find_polymorphic_tag(:#{ruby_name name}, #{call_type}), #{attributes}, #{parameters})" elsif attributes == "{}" && parameters == "{}" - "#{ruby_name name}.to_s" + if name =~ /^[A-Z]/ + # it's a tag with a cap name - not a local + "#{ruby_name name}()" + else + # could be a tag or a local variable + "#{ruby_name name}.to_s" + end else "#{ruby_name name}(#{attributes}, #{parameters})" end end call = apply_control_attributes(call, el) - maybe_make_part_call(el, "<% _output(#{call}) %>") + call = maybe_make_part_call(el, "<% _output(#{call}) %>") + wrap_tag_call_with_metadata(el, call) end @@ -449,29 +511,20 @@ module Hobo::Dryml end - def parameter_tags_hash(el) + def parameter_tags_hash(el, containing_tag_name=nil) call_type = nil + metadata_name = containing_tag_name || el.expanded_name + param_items = el.map do |node| case node when REXML::Text text = node.to_s - if text.blank? - # include whitespace in hash literal to keep line numbers - # matching - text - else - case call_type - when nil - call_type = :default_param_only - text - when :default_param_only - text - when :named_params - dryml_exception("mixed content and parameter tags", el) - end + unless text.blank? + dryml_exception("mixed content and parameter tags", el) if call_type == :named_params + call_type = :default_param_only end - node.to_s + text when REXML::Element e = node is_parameter_tag = e.parameter_tag? @@ -487,19 +540,14 @@ module Hobo::Dryml end if is_parameter_tag - param_name = get_param_name(e) - if param_name - ":#{ruby_name e.name} => merge_tag_parameter(#{param_proc(e)}, all_parameters[:#{param_name}]), " - else - ":#{ruby_name e.name} => #{param_proc(e)}, " - end + parameter_tag_hash_item(e, metadata_name) + ", " end end end.join - if call_type == :default_param_only + if call_type == :default_param_only || (el.children.empty? && el.has_end_tag?) with_containing_tag_name(el) do - param_items = " :default => #{default_param_proc(el)}, " + param_items = " :default => #{default_param_proc(el, containing_tag_name)}, " end end @@ -510,17 +558,73 @@ module Hobo::Dryml elsif is_code_attribute?(merge_params) merge_params[1..-1] else - dryml_exception("invalid merge_params", el) + merge_param_names = merge_params.split(/\s*,\s*/).*.gsub("-", "_") + "all_parameters & #{merge_param_names.inspect}" end "{#{param_items}}.merge((#{extra_params}) || {})" else "{#{param_items}}" end end + + + def parameter_tag_hash_item(el, metadata_name) + name = el.name.dup + if name.sub!(/^before-/, "") + before_parameter_tag_hash_item(name, el, metadata_name) + elsif name.sub!(/^after-/, "") + after_parameter_tag_hash_item(name, el, metadata_name) + elsif name.sub!(/^prepend-/, "") + prepend_parameter_tag_hash_item(name, el, metadata_name) + elsif name.sub!(/^append-/, "") + append_parameter_tag_hash_item(name, el, metadata_name) + else + hash_key = ruby_name name + hash_key += "_replacement" if el.attribute("replace") + if (param_name = get_param_name(el)) + ":#{hash_key} => merge_tag_parameter(#{param_proc(el, metadata_name)}, all_parameters[:#{param_name}])" + else + ":#{hash_key} => #{param_proc(el, metadata_name)}" + end + end + end + + + def before_parameter_tag_hash_item(name, el, metadata_name) + param_name = get_param_name(el) + dryml_exception("param declaration not allowed on 'before' parameters", el) if param_name + content = children_to_erb(el) + "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>" + ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}" + end - def default_param_proc(el) - "proc { |#{param_content_local_name(el.dryml_name)}| new_context { %>#{children_to_erb(el)}<% } #{tag_newlines(el)}}" + def after_parameter_tag_hash_item(name, el, metadata_name) + param_name = get_param_name(el) + dryml_exception("param declaration not allowed on 'after' parameters", el) if param_name + content = "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>" + children_to_erb(el) + ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}" + end + + + def append_parameter_tag_hash_item(name, el, metadata_name) + ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + + param_content_element(name) + children_to_erb(el) + + "<% } } } ] }" + end + + + def prepend_parameter_tag_hash_item(name, el, metadata_name) + ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + + children_to_erb(el) + param_content_element(name) + + "<% } } } ] }" + end + + + def default_param_proc(el, containing_param_name=nil) + content = children_to_erb(el) + content = wrap_source_with_metadata(content, "param", containing_param_name, + element_line_num(el)) if containing_param_name + "proc { |#{param_content_local_name(el.dryml_name)}| new_context { %>#{content}<% } #{tag_newlines(el)}}" end @@ -529,26 +633,45 @@ module Hobo::Dryml end - def param_proc(el) - param_name = el.dryml_name + def wrap_replace_parameter(el, name) + wrap_source_with_metadata(children_to_erb(el), "replace", name, element_line_num(el)) + end + + + def param_proc(el, metadata_name_prefix) + metadata_name = "#{metadata_name_prefix}><#{el.name}" + nl = tag_newlines(el) if (repl = el.attribute("replace")) dryml_exception("replace attribute must not have a value", el) if repl.has_rhs? dryml_exception("replace parameters must not have attributes", el) if el.attributes.length > 1 - "proc { |#{param_restore_local_name(param_name)}| new_context { %>#{children_to_erb(el)}<% } #{nl}}" + replace_parameter_proc(el, metadata_name) else - attributes = el.attributes.map do - |name, value| ":#{ruby_name name} => #{attribute_to_ruby(value, el)}" unless name.in?(SPECIAL_ATTRIBUTES) + attributes = el.attributes.map do |name, value| + if name.in?(VALID_PARAMETER_TAG_ATTRIBUTES) + # just ignore + elsif name.in?(SPECIAL_ATTRIBUTES) + dryml_exception("attribute '#{name}' is not allowed on parameter tags (<#{el.name}:>)", el) + else + ":#{ruby_name name} => #{attribute_to_ruby(value, el)}" + end end.compact - nested_parameters_hash = parameter_tags_hash(el) + nested_parameters_hash = parameter_tags_hash(el, metadata_name) "proc { [{#{attributes * ', '}}, #{nested_parameters_hash}] #{nl}}" end end + def replace_parameter_proc(el, metadata_name, content=nil) + content ||= wrap_replace_parameter(el, metadata_name) + param_name = el.dryml_name.sub(/^(before|after|append|prepend)-/, "") + "proc { |#{param_restore_local_name(param_name)}| new_context { %>#{content}<% } #{tag_newlines(el)}}" + end + + def param_content_local_name(name) "_#{ruby_name name}__default_content" end @@ -565,6 +688,11 @@ module Hobo::Dryml end + def field_shorthand_element?(el) + el.expanded_name =~ /:./ + end + + def tag_attributes(el) attributes = el.attributes items = attributes.map do |n,v| @@ -576,7 +704,7 @@ module Hobo::Dryml end.compact # if there's a ':' el.name is just the part after the ':' - items << ":field => \"#{el.name}\"" if el.name != el.dryml_name + items << ":field => \"#{ruby_name el.name}\"" if field_shorthand_element?(el) items = items.join(", ") @@ -637,7 +765,7 @@ module Hobo::Dryml def static_element_to_erb(el) - if %w(part merge-attrs if unless repeat).any? {|x| el.attributes[x]} + if promote_static_tag_to_method_call?(el) static_tag_to_method_call(el) else start_tag_src = el.start_tag_source.gsub(REXML::CData::START, "").gsub(REXML::CData::STOP, "") @@ -656,18 +784,23 @@ module Hobo::Dryml end + def promote_static_tag_to_method_call?(el) + %w(part merge-attrs if unless repeat).any? {|x| el.attributes[x]} + end + + def apply_control_attributes(expression, el) - if_, unless_, repeat = controls = %w(if unless repeat).map {|x| el.attributes[x]} - controls.compact! + controls = %w(if unless repeat).map_hash { |x| el.attributes[x] }.compact dryml_exception("You can't have multiple control attributes on the same element", el) if controls.length > 1 - val = controls.first + attr = controls.keys.first + val = controls.values.first if val.nil? expression else - control = if repeat && val == "&true" + control = if !el.attribute(attr).has_rhs? "this" elsif is_code_attribute?(val) "#{val[1..-1]}" @@ -676,13 +809,14 @@ module Hobo::Dryml end x = gensym - if if_ + case attr + when "if" "(if !(#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " + "else (Hobo::Dryml.last_if = false; ''); end)" - elsif unless_ + when "unless" "(if (#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " + "else (Hobo::Dryml.last_if = false; ''); end)" - elsif repeat + when "repeat" "repeat_attribute(#{control}) { #{expression} }" end end @@ -690,7 +824,7 @@ module Hobo::Dryml def attribute_to_ruby(*args) - options = extract_options_from_args!(args) + options = args.extract_options! attr, el = args dryml_exception('erb scriptlet not allowed in this attribute (use #{ ... } instead)', el) if @@ -746,8 +880,7 @@ module Hobo::Dryml end def element_line_num(el) - offset = el.source_offset - line_no = @xmlsrc[0..offset].count("\n") + 1 + @doc.element_line_num(el) end def tag_newlines(el) @@ -770,9 +903,14 @@ module Hobo::Dryml end def rename_class(name) - name = name[1..-2] - name = class_renames[name] while class_renames.has_key?(name) - name + @bundle && name.starts_with?("_") ? @bundle.send(name) : name + end + + def include_source_metadata + # disabled for now -- we're still getting broken rendering with this feature on + return false + @include_source_metadata = RAILS_ENV == "development" && !ENV['DRYML_EDITOR'].blank? if @include_source_metadata.nil? + @include_source_metadata end end vendor/plugins/hobo/lib/hobo/dryml/template.rb @@ -49,14 +49,51 @@ module Hobo::Dryml end end - attr_accessor for attr in [:erb_binding, :part_contexts, :view_name, - :this, :this_parent, :this_field, :this_type, + :this, :this_parent, :this_field, :this_key, :form_field_path, :form_this, :form_field_names] class_eval "def #{attr}; @_#{attr}; end" end + def this_key=(key) + @_this_key = key + end + + + # The type of this, or when this is nil, the type that would be expected in the current field + def this_type + @_this_type ||= if this == false || this == true + Hobo::Boolean + elsif this + this.class + elsif this_parent && this_field && (parent_class = this_parent.class).respond_to?(:attr_type) + type = parent_class.attr_type(this_field) + if type.is_a?(ActiveRecord::Reflection::AssociationReflection) + reflection = type + if reflection.macro == :has_many + Array + elsif reflection.options[:polymorphic] + # All we know is that it will be some active-record type + ActiveRecord::Base + else + reflection.klass + end + else + type + end + else + # Nothing to go on at all + Object + end + end + + + def this_field_reflection + this.try.proxy_reflection || + (this_parent && this_field && this_parent.class.respond_to?(:reflections) && this_parent.class.reflections[this_field.to_sym]) + end + def attrs_for(name) self.class.tag_attrs[name.to_sym] @@ -95,51 +132,50 @@ module Hobo::Dryml end - def this_field_dom_id - if this_parent && this_field - Hobo.dom_id(this_parent, this_field) - else - Hobo.dom_id(this) + def dom_id(object=nil, attribute=nil) + if object.nil? + # nothing passed -- use context + if this_parent && this_field + object, attribute = this_parent, this_field + else + object = this + end end - end - - - 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) - this.typed_id - elsif this.is_a?(Array) and !this.respond_to?(:proxy_reflection) - "nil" + + id = object.try.typed_id + if id + attribute ? "#{id}_#{attribute}" : id else - Hobo.dom_id(this) + "nil" end end - - def call_part(dom_id, part_name, part_this=nil, *locals) + + def call_part(part_node_id, part_name, part_this=nil, *locals) res = '' if part_this new_object_context(part_this) do - @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals) + @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals) res = send("#{part_name}_part", *locals) end else new_context do - @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals) + @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals) res = send("#{part_name}_part", *locals) end end res end + def call_polymorphic_tag(name, *args) + name = name.to_s.gsub('-', '_') type = args.first.is_a?(Class) ? args.shift : nil attributes, parameters = args tag = find_polymorphic_tag(name, type) if tag != name - send(tag, attributes, parameters || {}) + send(tag, attributes || {}, parameters || {}) else nil end @@ -147,26 +183,17 @@ module Hobo::Dryml def find_polymorphic_tag(name, call_type=nil) - call_type ||= case this_type - when ActiveRecord::Reflection::AssociationReflection - # Don't blow up with non-existent polymorphic types - return name if this_type.options[:polymorphic] && !Object.const_defined?(this_type.class_name) - this_type.klass - when Array - this.member_class - else - this_type - end - - call_type = TrueClass if call_type == FalseClass + call_type ||= (this.is_a?(Array) && this.respond_to?(:member_class) && this.member_class) || this_type while true - if call_type == ActiveRecord::Base || call_type == Object - return name - elsif respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}") + if respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}") return poly_name else - call_type = call_type.superclass + if call_type == ActiveRecord::Base || call_type == Object + return name + else + call_type = call_type.superclass + end end end end @@ -192,8 +219,9 @@ module Hobo::Dryml def new_context ctx = [ @_erb_output, @_this, @_this_parent, @_this_field, @_this_type, - @_form_field_path] + @_form_field_path ] @_erb_output = "" + @_this_type = nil res = yield @_erb_output, @_this, @_this_parent, @_this_field, @_this_type, @_form_field_path = ctx res.to_s @@ -202,14 +230,7 @@ module Hobo::Dryml def new_object_context(new_this) new_context do - @_this_parent,@_this_field,@_this_type = if new_this.respond_to?(:proxy_reflection) - refl = new_this.proxy_reflection - [new_this.proxy_owner, refl.name, refl] - else - # In dryml, TrueClass is the 'boolean' class - t = new_this.class == FalseClass ? TrueClass : new_this.class - [nil, nil, t] - end + @_this_parent, @_this_field = [new_this.origin, new_this.origin_attribute] if new_this.respond_to?(:origin) @_this = new_this yield end @@ -226,17 +247,7 @@ module Hobo::Dryml [field_path] end parent, field, obj = Hobo.get_field_path(tag_this || this, path) - - type = if parent.class.respond_to?(:field_type) && field_type = parent.class.field_type(field) - field_type - elsif obj == false - # In dryml, TrueClass is the 'boolean' class - TrueClass - else - obj.class - end - - @_this, @_this_parent, @_this_field, @_this_type = obj, parent, field, type + @_this, @_this_parent, @_this_field = obj, parent, field @_form_field_path += path if @_form_field_path yield end @@ -310,13 +321,14 @@ module Hobo::Dryml def call_tag_parameter(the_tag, attributes, parameters, caller_parameters, param_name) overriding_proc = caller_parameters[param_name] + replacing_proc = caller_parameters[:"#{param_name}_replacement"] if param_name == :default && overriding_proc # :default content is handled specially call_tag_parameter_with_default_content(the_tag, attributes, parameters[:default], overriding_proc) - - elsif overriding_proc && overriding_proc.arity == 1 + + elsif replacing_proc # The caller is replacing this parameter. Don't call the tag # at all, just the overriding proc, but pass the restorable # tag as a parameter to the overriding proc @@ -325,9 +337,17 @@ module Hobo::Dryml # Call the replaced tag with the attributes and parameters # as given in the original tag definition, and with the # specialisation given on the 'restore' call + + if overriding_proc + overriding_attributes, overriding_parameters = overriding_proc.call + restore_attrs = overriding_attributes.merge(restore_attrs) + restore_params = overriding_parameters.merge(restore_params) + end + override_and_call_tag(the_tag, attributes, parameters, restore_attrs, restore_params) end - overriding_proc.call(tag_restore) + replacing_proc.call(tag_restore) + else overriding_attributes, overriding_parameters = overriding_proc._?.call @@ -418,7 +438,7 @@ module Hobo::Dryml end - def part_contexts_storage_tag + def part_contexts_javascripts storage = part_contexts_storage storage.blank? ? "" : "<script>\n#{storage}</script>\n" end @@ -432,7 +452,14 @@ module Hobo::Dryml def render_tag(tag_name, attributes) method_name = tag_name.gsub('-', '_') if respond_to?(method_name) - (send(method_name, attributes) + part_contexts_storage_tag).strip + res = (send(method_name, attributes) + part_contexts_javascripts).strip + + # TODO: Temporary hack to get the dryml metadata comments in the right place + if false && RAILS_ENV == "development" + res.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1") + else + res + end else false end vendor/plugins/hobo/lib/hobo/dryml/template_environment.rb @@ -8,12 +8,70 @@ module Hobo::Dryml def render(src, local_assigns) renderer = Hobo::Dryml.page_renderer(@view, local_assigns.keys) - s = renderer.render_page(@view.assigns["this"] || local_assigns[:this], local_assigns) - # Important to strip whitespace, or the browser hangs around for ages (FF2) + this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || local_assigns[:this]) + s = renderer.render_page(this, local_assigns) - s.strip + # Important to strip whitespace, or the browser hangs around for ages (FF2) + s = s.strip + + # TODO: Temporary hack to get the dryml metadata comments in the right place + if RAILS_ENV == "development" + s.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1") + else + s + end end end end + +module ActionController + + + class Base + + def dryml_context + @this + end + + def dryml_fallback_tag(tag_name) + @dryml_fallback_tag = tag_name + end + + + def call_dryml_tag(tag, options={}) + add_variables_to_assigns + + # TODO: Figure out what this bit is all about :-) + if options[:with] + @this = options[:with] unless options[:field] + else + options[:with] = dryml_context + end + + Hobo::Dryml.render_tag(@template, tag, options) + end + + + # TODO: This is namespace polution, should be called render_dryml_tag + def render_tag(tag, options={}, render_options={}) + text = call_dryml_tag(tag, options) + text && render({:text => text, :layout => false }.merge(render_options)) + end + + def render_for_file_with_dryml(template_path, *args) + if template_path !~ /^\// && # not an absolute path (e.g. an exception ERB template) + !template_exists?(template_path) && # no template available in app/views + tag_name = @dryml_fallback_tag || "#{File.basename(template_path).dasherize}-page" + + # The template was missing, try to use a DRYML <page> tag instead + render_tag(tag_name) or raise ActionController::MissingTemplate, "Missing template #{template_path}.html.erb in view path #{RAILS_ROOT}/app/views" + else + render_for_file_without_dryml(template_path, *args) + end + end + alias_method_chain :render_for_file, :dryml + + end +end vendor/plugins/hobo/lib/hobo/dryml/template_handler.rb @@ -8,6 +8,13 @@ module Hobo end protected + + + def uid + @hobo_uid ||= 0 + @hobo_uid += 1 + end + def current_user # simple one-hit-per-request cache @@ -40,66 +47,51 @@ module Hobo def subsite params[:controller].match(/([^\/]+)\//)._?[1] end + + + IMPLICIT_ACTIONS = [:index, :show, :create, :update, :destroy] - - def object_url(*args) + def object_url(obj, *args) params = args.extract_options! - obj, action = args - action &&= action.to_s - - controller_name = controller_for(obj) - - subsite = params[:subsite] || self.subsite - - # TODO - what if you want if_available as a query param? - if_available = params.delete(:if_available) - return nil if if_available && - ((action.nil? && obj.respond_to?(:typed_id) && !linkable?(obj.class, :show, :subsite => subsite)) || - (action.nil? && obj.is_a?(Class) && !linkable?(obj, :index, :subsite => subsite))) - - base = subsite.blank? ? base_url : "/#{subsite}#{base_url}" + action = args.first._?.to_sym + options, params = params.partition_hash([:subsite, :method, :format]) + options[:subsite] ||= self.subsite - parts = if obj.is_a? Class - [base, controller_name] - - elsif obj.is_a? Hobo::CompositeModel - [base, controller_name, obj.to_param] - - elsif obj.is_a? ActiveRecord::Base - if obj.new_record? - [base, 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.to_param - end - - [base, 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 - url = parts.join("/") + if obj.respond_to?(:origin) + # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new + if action == :new + action_path = "#{obj.origin_attribute}/new" + action = "new_#{obj.origin_attribute.to_s.singularize}" + elsif action.nil? + action = obj.origin_attribute + end + obj = obj.origin + + else + action ||= case options[:method].to_s + when 'put'; :update + when 'post'; :create + when 'delete'; :destroy + else; obj.is_a?(Class) ? :index : :show + end - case action - when nil # do nothing - when "destroy" then params["_method"] = "DELETE" - when "update" then params["_method"] = "PUT" - else url += "/#{action}" + if action == :create && obj.try.new_record? + # Asking for url to post new record to + obj = obj.class + end end + + klass = obj.is_a?(Class) ? obj : obj.class + if Hobo::ModelRouter.linkable?(klass, action, options) + + path = obj.to_url_path or HoboError.new("cannot create url for #{obj.inspect} (#{obj.class})") + url = "#{base_url}#{'/' + subsite unless subsite.blank?}/#{path}" - params = make_params(params - [:subsite]) - params.blank? ? url : "#{url}?#{params}" + url += "/#{action_path || action}" unless action.in?(IMPLICIT_ACTIONS) + + params = make_params(params) + params.blank? ? url : "#{url}?#{params}" + end end @@ -127,31 +119,16 @@ module Hobo 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 - rescue ArgumentError - "" - end - def type_id(type=nil) - type ||= this.is_a?(Class) ? this : this_type - type == NilClass ? "" : Hobo.type_id(type || this.class) + type ||= (this.is_a?(Class) && this) || this_type || this.class + HoboFields.to_name(type) || type.name.underscore.gsub("/", "__") end - + def type_and_field(*args) - if args.empty? - this_parent && this_field && "#{Hobo.type_id(this_parent.class)}_#{this_field}" - else - type, field = args - "#{Hobo.type_id(type)}_#{field}" - end + type, field = args.empty? ? [this_parent.class, this_field] : args + "#{type.typed_id}_#{field}" if type.respond_to?(:typed_id) end @@ -160,6 +137,8 @@ module Hobo empty = true if this.respond_to?(:each_index) this.each_index {|i| empty = false; new_field_context(i) { res << yield } } + elsif this.is_a?(Hash) + this.map {|key, value| empty = false; self.this_key = key; new_object_context(value) { res << yield } } else this.map {|e| empty = false; new_object_context(e) { res << yield } } end @@ -203,8 +182,8 @@ module Hobo 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) + if !field && object.respond_to?(:origin) + Hobo.can_edit?(current_user, object.origin, object.origin_attribute) else Hobo.can_edit?(current_user, object, field) end @@ -225,12 +204,14 @@ module Hobo 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 + + @can_view_cache ||= {} + @can_view_cache[ [object, field] ] ||= + if !field && object.respond_to?(:origin) + Hobo.can_view?(current_user, object.origin, object.origin_attribute) + else + Hobo.can_view?(current_user, object, field) + end end @@ -272,8 +253,8 @@ module Hobo 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]) + name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to + param_name_for(form_this, form_field_path[0..-2] + [refl.primary_key_name]) else param_name_for(form_this, form_field_path) end @@ -282,21 +263,10 @@ module Hobo 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 + max_length = matrix.*.length.max matrix = matrix.map do |a| a + [nil] * (max_length - a.length) end @@ -306,9 +276,7 @@ module Hobo def new_for_current_user(model_or_assoc=nil) model_or_assoc ||= this - record = model_or_assoc.new - record.set_creator(current_user) - record + model_or_assoc.user_new(current_user) end @@ -338,8 +306,12 @@ module Hobo # Sign-up url for a given user record or user class - def signup_url(user_or_class) - c = user_or_class.is_a?(Class) ? user_or_class : user_or_class.class + def signup_url(user_or_class=nil) + c = case user_or_class + when Class; user_or_class + when nil; Hobo::User.default_user_model + else user_or_class + end send("#{c.name.underscore}_signup_url") rescue nil end @@ -366,23 +338,28 @@ module Hobo target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift action = args.first - if target.is_a?(Class) + if (origin = target.try.origin) + klass = origin.class + action = if action == :new + "new_#{target.origin_attribute.to_s.singularize}" + elsif action.nil? + target.origin_attribute + end + elsif target.is_a?(Class) klass = target action ||= :index - elsif target.respond_to?(:member_class) - klass = target.member_class - action ||= :show else klass = target.class action ||= :show end - Hobo::ModelRouter.linkable?(subsite, klass, action.to_sym) + Hobo::ModelRouter.linkable?(klass, action, options.reverse_merge(:subsite => subsite)) end - + # Convenience helper for the default app + # FIXME: this should interrogate the routes to find index methods, not the models def front_models Hobo.models.select {|m| linkable?(m) && !(m < Hobo::User)} end @@ -398,7 +375,7 @@ module Hobo 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("DRYML THIS = #{this.typed_id rescue this.inspect}") logger.debug("###################\n") args.first unless args.empty? end vendor/plugins/hobo/lib/hobo/hobo_helper.rb @@ -2,160 +2,176 @@ module Hobo module Model + class PermissionDeniedError < RuntimeError; end + class NoNameError < RuntimeError; end + NAME_FIELD_GUESS = %w(name title) PRIMARY_CONTENT_GUESS = %w(description body content profile) SEARCH_COLUMNS_GUESS = %w(name title body content profile) - PLAIN_TYPES = { :boolean => TrueClass, - :date => Date, - :datetime => Time, - :integer => Fixnum, - :big_integer => BigDecimal, - :float => Float, - :string => String - } - - Hobo.field_types.update(PLAIN_TYPES) def self.included(base) - Hobo.register_model(base) base.extend(ClassMethods) + + included_in_class_callbacks(base) + + Hobo.register_model(base) + + patch_will_paginate + base.class_eval do + inheriting_cattr_reader :default_order alias_method_chain :attributes=, :hobo_type_conversion - default_scopes end + class << base - alias_method_chain :has_many, :defined_scopes - alias_method_chain :belongs_to, :foreign_key_declaration - alias_method_chain :belongs_to, :hobo_metadata - alias_method_chain :acts_as_list, :fields if defined?(ActiveRecord::Acts::List) + alias_method_chain :has_many, :defined_scopes + alias_method_chain :has_many, :join_record_management + alias_method_chain :belongs_to, :creator_metadata + + alias_method_chain :has_one, :new_method + def inherited(klass) + super fields do Hobo.register_model(klass) field(klass.inheritance_column, :string) end end end + + end + + def self.patch_will_paginate + if defined?(WillPaginate) && !WillPaginate::Collection.respond_to?(:member_class) + + WillPaginate::Collection.class_eval do + attr_accessor :member_class, :origin, :origin_attribute + end + + WillPaginate::Finder::ClassMethods.class_eval do + def paginate_with_hobo_metadata(*args, &block) + returning paginate_without_hobo_metadata(*args, &block) do |collection| + collection.member_class = self + collection.origin = try.proxy_owner + collection.origin_attribute = try.proxy_reflection._?.name + end + end + alias_method_chain :paginate, :hobo_metadata + + end + + end end + module ClassMethods # include methods also shared by CompositeModel - include ModelSupport::ClassMethods + #include ModelSupport::ClassMethods attr_accessor :creator_attribute attr_writer :name_attribute, :primary_content_attribute - def default_scopes - def_scope :recent do |*args| - count = args.first || 3 - { :limit => count, :order => "#{table_name}.created_at DESC" } - end + def named(*args) + raise NoNameError, "Model #{name} has no name attribute" unless name_attribute + send("find_by_#{name_attribute}", *args) end - def name_attribute - @name_attribute ||= begin - cols = columns.every :name - NAME_FIELD_GUESS.detect {|f| f.in? columns.every(:name) } - end - end - - def primary_content_attribute - @description_attribute ||= begin - cols = columns.every :name - PRIMARY_CONTENT_GUESS.detect {|f| f.in? columns.every(:name) } - end + def field_added(name, type, args, options) + self.name_attribute = name.to_sym if options.delete(:name) + self.primary_content_attribute = name.to_sym if options.delete(:primary_content) + self.creator_attribute = name.to_sym if options.delete(:creator) + validate = options.delete(:validate) {true} + + #FIXME - this should be in Hobo::User + send(:login_attribute=, name.to_sym, validate) if options.delete(:login) && respond_to?(:login_attribute=) end - def dependent_collections - reflections.values.select do |refl| - refl.macro == :has_many && refl.options[:dependent] - end.every(:name) + + def user_find(user, *args) + record = find(*args) + raise PermissionDeniedError unless Hobo.can_view?(user, record) + record end - def dependent_on - reflections.values.select do |refl| - refl.macro == :belongs_to && (rev = reverse_reflection(refl.name) and rev.options[:dependent]) - end.every(:name) + def user_new(user, attributes={}) + record = new(attributes) + record.user_changes(user) and record end - private - def return_type(type) - @next_method_type = type + def user_new!(user, attributes={}) + user_new(user, attributes) or raise PermissionDeniedError end - def method_added(name) - if @next_method_type - set_field_type(name => @next_method_type) - @next_method_type = nil - end + + def user_create(user, attributes={}) + record = new(attributes) + record.user_save_changes(user) + record end - def fields(&b) - dsl = FieldDeclarationsDsl.new(self) - if b.arity == 1 - yield dsl - else - dsl.instance_eval(&b) - end + def user_can_create?(user, attributes={}) + record = new(attributes) + record.user_changes(user) end - def belongs_to_with_foreign_key_declaration(name, *args, &block) - options = args.extract_options! - res = belongs_to_without_foreign_key_declaration(name, *args + [options], &block) - refl = reflections[name] - fkey = refl.primary_key_name - column_options = {} - column_options[:null] = options[:null] if options.has_key?(:null) - field_specs[fkey] ||= FieldSpec.new(self, fkey, :integer, column_options) - if refl.options[:polymorphic] - type_col = "#{name}_type" - field_specs[type_col] ||= FieldSpec.new(self, type_col, :string, column_options) - end - res + def user_update(user, id, attributes={}) + find(id).user_save_changes(user, attributes) end - def belongs_to_with_hobo_metadata(name, *args, &block) - options = args.extract_options! - self.creator_attribute = name.to_sym if options.delete(:creator) - belongs_to_without_hobo_metadata(name, *args + [options], &block) + def name_attribute + @name_attribute ||= begin + cols = columns.*.name + NAME_FIELD_GUESS.detect {|f| f.in? columns.*.name } + end end + - - def acts_as_list_with_fields(options = {}) - fields { |f| f.send(options._?[:column] || "position", :integer) } - acts_as_list_without_fields(options) + def primary_content_attribute + @primary_content_attribute ||= begin + cols = columns.*.name + PRIMARY_CONTENT_GUESS.detect {|f| f.in? columns.*.name } + end end - - - def field_specs - @field_specs ||= HashWithIndifferentAccess.new + + def dependent_collections + reflections.values.select do |refl| + refl.macro == :has_many && refl.options[:dependent] + end.*.name end - public :field_specs - def set_field_type(types) - types.each_pair do |field, type| - type_class = Hobo.field_types[type] || type - field_types[field] = type_class - - if type_class && "validate".in?(type_class.instance_methods) - self.validate do |record| - v = record.send(field)._?.validate - record.errors.add(field, v) if v.is_a?(String) - end - end - end + + def dependent_on + reflections.values.select do |refl| + refl.macro == :belongs_to && (rev = reverse_reflection(refl.name) and rev.options[:dependent]) + end.*.name end - def field_types - @hobo_field_types ||= superclass.respond_to?(:field_types) ? superclass.field_types : {} + def default_dependent_on + dependent_on.first + end + + + private + + + def belongs_to_with_creator_metadata(name, options={}, &block) + self.creator_attribute = name.to_sym if options.delete(:creator) + belongs_to_without_creator_metadata(name, options, &block) + end + + + def has_one_with_new_method(name, options={}, &block) + has_one_without_new_method(name, options) + class_eval "def new_#{name}(attributes={}); build_#{name}(attributes, false); end" end @@ -163,181 +179,65 @@ module Hobo @default_order = order end - inheriting_attr_accessor :default_order, :id_name_options - def never_show(*fields) @hobo_never_show ||= [] - @hobo_never_show.concat(fields.every(:to_sym)) - end - - def never_show?(field) - (@hobo_never_show && field.to_sym.in?(@hobo_never_show)) || (superclass < Hobo::Model && superclass.never_show?(field)) + @hobo_never_show.concat(fields.*.to_sym) end - public :never_show? + def set_search_columns(*columns) class_eval %{ def self.search_columns - %w{#{columns.every(:to_s) * ' '}} + %w{#{columns.*.to_s * ' '}} end } end - - def id_name(*args) - @id_name_options = [] + args - - underscore = args.delete(:underscore) - insenstive = args.delete(:case_insensitive) - id_name_field = args.first || :name - @id_name_column = id_name_field.to_s - - if underscore - class_eval %{ - def id_name(underscore=false) - underscore ? #{id_name_field}.gsub(' ', '_') : #{id_name_field} - end - } - else - class_eval %{ - def id_name(underscore=false) - #{id_name_field} - end - } - end - - key = "id_name#{if underscore; ".gsub('_', ' ')"; end}" - finder = if insenstive - "find(:first, options.merge(:conditions => ['lower(#{id_name_field}) = ?', #{key}.downcase]))" - else - "find_by_#{id_name_field}(#{key}, options)" - end - - class_eval %{ - def self.find_by_id_name(id_name, options={}) - #{finder} - end - } - - model = self - validate do - erros.add id_name_field, "is taken" if model.find_by_id_name(name) - end - validates_format_of id_name_field, :with => /^[^_]+$/, :message => "cannot contain underscores" if - underscore - end - - public - def id_name? - respond_to?(:find_by_id_name) - end - - attr_reader :id_name_column + public - def field_type(name) - name = name.to_sym - field_types[name] or - reflections[name] or begin - col = column(name) - return nil if col.nil? - case col.type - when :boolean - TrueClass - when :text - Hobo::Text - else - col.klass - end - end - end - - - def column(name) - columns.find {|c| c.name == name.to_s} rescue nil - end - - - def conditions(*args, &b) - if args.empty? - ModelQueries.new(self).instance_eval(&b)._?.to_sql - else - ModelQueries.new(self).instance_exec(*args, &b)._?.to_sql - end + def never_show?(field) + (@hobo_never_show && field.to_sym.in?(@hobo_never_show)) || (superclass < Hobo::Model && superclass.never_show?(field)) end def find(*args, &b) options = args.extract_options! - if args.first.in?([:all, :first]) && options[:order] == :default + if options[:order] == :default options = if default_order.blank? - options - [:order] + options.except :order else options.merge(:order => "#{table_name}.#{default_order}") end end - - res = if b && !(block_conditions = conditions(&b)).blank? - c = if !options[:conditions].blank? - "(#{sanitize_sql options[:conditions]}) AND (#{sanitize_sql block_conditions})" - else - block_conditions - end - super(args.first, options.merge(:conditions => c)) - else - super(*args + [options]) - end - if args.first == :all - def res.member_class - @member_class - end - res.instance_variable_set("@member_class", self) - end - res + result = super(*args + [options]) + result.member_class = self if result.is_a?(Array) + result end - + def all(options={}) find(:all, options.reverse_merge(:order => :default)) end - def count(*args, &b) - if b - sql = ModelQueries.new(self).instance_eval(&b).to_sql - options = extract_options_from_args!(args) - super(*args + [options.merge(:conditions => sql)]) - else - super(*args) - end - end - - - def subclass_associations(association, *subclass_associations) - refl = reflections[association] - for assoc in subclass_associations - class_name = assoc.to_s.classify - options = { :class_name => class_name, :conditions => "type = '#{class_name}'" } - options[:source] = refl.source_reflection.name if refl.source_reflection - has_many(assoc, refl.options.merge(options)) - end - end - def creator_type reflections[creator_attribute]._?.klass end + def search_columns - cols = columns.every(:name) + cols = columns.*.name SEARCH_COLUMNS_GUESS.select{|c| c.in?(cols) } end - # This should really be a method on AssociationReflection + + # FIXME: This should really be a method on AssociationReflection def reverse_reflection(association_name) refl = reflections[association_name] - return nil if refl.options[:conditions] + return nil if refl.options[:conditions] || refl.options[:polymorphic] reverse_macro = if refl.macro == :has_many :belongs_to @@ -353,153 +253,124 @@ module Hobo end - class ScopedProxy - - def initialize(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) - if name.to_sym.in?(@klass.defined_scopes.keys) - proxy = @klass.send(name, *args) - proxy.instance_variable_set("@parent_scope", self) - proxy - else - _apply_scope { @klass.send(name, *args, &block) } - end - end - - def all - self.find(:all) - end - - def first - self.find(:first) - end - - def member_class - @klass - end - - private - def _apply_scope - if @parent_scope - @parent_scope.send(:_apply_scope) do - @scope ? @klass.send(:with_scope, @scope) { yield } : yield - end - else - @scope ? @klass.send(:with_scope, @scope) { yield } : yield - end + def has_inheritance_column? + columns_hash.include?(inheritance_column) + end + + + def method_missing(name, *args, &block) + name = name.to_s + if name =~ /\./ + # FIXME: Do we need this now? + call_method_chain(name, args, &block) + elsif create_automatic_scope(name) + send(name, *args, &block) + else + super(name.to_sym, *args, &block) 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 send instance_variable_set instance_variable_get puts}) || m.starts_with?('_') + + + def call_method_chain(chain, args, &block) + parts = chain.split(".") + s = parts[0..-2].inject(self) { |m, scope| m.send(scope) } + s.send(parts.last, *args) end - attr_accessor :defined_scopes - - def def_scope(name, scope=nil, &block) - @defined_scopes ||= {} - @defined_scopes[name.to_sym] = block || scope - - meta_def(name) do |*args| - ScopedProxy.new(self, block ? block.call(*args) : scope) - end + def to_url_path + "#{name.underscore.pluralize}" end - module DefinedScopeProxyExtender - - attr_accessor :reflections + def typed_id + HoboFields.to_name(self) || name.underscore.gsub("/", "__") + end + + + def manage_join_records(association) - def method_missing(name, *args, &block) - 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 - scope_name = "@#{name.to_s.gsub('?','')}_scope" - - # Calling instance_variable_get directly causes self to - # get loaded, hence this trick - assoc = Kernel.instance_method(:instance_variable_get).bind(self).call(scope_name) - - unless assoc - options = proxy_reflection.options - has_many_conditions = options[:conditions] - has_many_conditions = nil if has_many_conditions.blank? - source = proxy_reflection.source_reflection - scope_conditions = find_scope[:conditions] - scope_conditions = nil if scope_conditions.blank? - conditions = if has_many_conditions && scope_conditions - "(#{sanitize_sql scope_conditions}) AND (#{sanitize_sql has_many_conditions})" - else - scope_conditions || has_many_conditions - end - - options = options.merge(find_scope).update(:class_name => proxy_reflection.klass.name, - :foreign_key => proxy_reflection.primary_key_name) - options[:conditions] = conditions unless conditions.blank? - options[:source] = source.name if source - - r = ActiveRecord::Reflection::AssociationReflection.new(:has_many, - name, - options, - proxy_owner.class) - - @reflections ||= {} - @reflections[name] = r + method = "manage_join_records_for_#{association}" + after_save method + class_eval %{ + def #{method} + assigned = #{association}.dup + current = #{association}.reload - assoc = if source - ActiveRecord::Associations::HasManyThroughAssociation - else - ActiveRecord::Associations::HasManyAssociation - end.new(self.proxy_owner, r) - - # Calling directly causes self to get loaded - Kernel.instance_method(:instance_variable_set).bind(self).call(scope_name, assoc) - end - assoc - else - super + through = #{association}.proxy_reflection.through_reflection + source = #{association}.proxy_reflection.source_reflection + + to_delete = current - assigned + to_add = assigned - current + through.klass.delete_all(["\#{through.primary_key_name} = ? and \#{source.primary_key_name} in (?)", + self.id, to_delete.*.id]) if to_delete.any? + to_add.each { |record| #{association} << record } end - end - + } end - - def has_many_with_defined_scopes(name, *args, &block) - options = args.extract_options! - if options.has_key?(:extend) || block - # Normal has_many - has_many_without_defined_scopes(name, *args + [options], &block) - else - options[:extend] = DefinedScopeProxyExtender - has_many_without_defined_scopes(name, *args + [options], &block) + def has_many_with_join_record_management(name, options={}, &b) + manage = options.delete(:managed) + returning (has_many_without_join_record_management(name, options, &b)) do + manage_join_records(name) if manage end end + + end # --- of ClassMethods --- # + + + include Scopes + + + def to_url_path + "#{self.class.to_url_path}/#{to_param}" unless new_record? + end + + + def user_changes(user, changes={}) + if new_record? + self.attributes = changes + set_creator(user) + Hobo.can_create?(user, self) + else + original = duplicate + # 'duplicate' can cause these to be set, but they can conflict + # with the changes so we clear them + clear_aggregation_cache + clear_association_cache + + self.attributes = changes + + Hobo.can_update?(user, original, self) + end + end + + + def user_changes!(user, changes={}) + user_changes(user, changes) or raise PermissionDeniedError + end + + + def user_can_create?(user, attributes={}) + raise ArgumentError, "Called #user_can_create? on existing record" unless new_record? + user_changes(user, attributes) + end + + + def user_save_changes(user, changes={}) + user_changes!(user, changes) + save + end + + + def user_view(user, field=nil) + raise PermissionDeniedError, self.inspect unless Hobo.can_view?(user, self, field) + end + + + def user_destroy(user) + raise PermissionDeniedError unless Hobo.can_delete?(user, self) + destroy end @@ -509,13 +380,18 @@ module Hobo def attributes_with_hobo_type_conversion=(attributes, guard_protected_attributes=true) - converted = attributes.map_hash { |k, v| convert_type_for_mass_assignment(self.class.field_type(k), v) } + converted = attributes.map_hash { |k, v| convert_type_for_mass_assignment(self.class.attr_type(k), v) } send(:attributes_without_hobo_type_conversion=, converted, guard_protected_attributes) end def set_creator(user) + set_creator!(user) unless get_creator + end + + + def set_creator!(user) attr = self.class.creator_attribute return unless attr @@ -528,22 +404,30 @@ module Hobo self.send("#{attr}=", user.to_s) unless user.guest? end end + + + # We deliberately give this method an unconventional name to avoid + # polluting the application namespace too badly + def get_creator + self.class.creator_attribute && send(self.class.creator_attribute) + end def duplicate - res = self.class.new - res.instance_variable_set("@attributes", @attributes.dup) - res.instance_variable_set("@new_record", nil) unless new_record? + copy = self.class.new + copy.copy_instance_variables_from(self, ["@attributes_cache"]) + copy.instance_variable_set("@attributes", @attributes.dup) + copy.instance_variable_set("@new_record", nil) unless new_record? # Shallow copy of belongs_to associations for refl in self.class.reflections.values if refl.macro == :belongs_to and (target = self.send(refl.name)) - bta = ActiveRecord::Associations::BelongsToAssociation.new(res, refl) + bta = ActiveRecord::Associations::BelongsToAssociation.new(copy, refl) bta.replace(target) - res.instance_variable_set("@#{refl.name}", bta) + copy.instance_variable_set("@#{refl.name}", bta) end end - res + copy end @@ -554,29 +438,25 @@ module Hobo fields.all?{|f| self.send(f) == other.send(f)} end + def only_changed_fields?(other, *changed_fields) return true if other.nil? - changed_fields = changed_fields.flatten.every(:to_s) - all_cols = self.class.columns.every(:name) - [] + changed_fields = changed_fields.flatten.*.to_s + all_cols = self.class.columns.*.name - [] all_cols.all?{|c| c.in?(changed_fields) || self.send(c) == other.send(c) } end + def compose_with(object, use=nil) 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 + "#{self.class.name.underscore}_#{self.id}" if id end + def to_s if self.class.name_attribute @@ -586,21 +466,22 @@ module Hobo end end + private + def parse_datetime(s) defined?(Chronic) ? Chronic.parse(s) : Time.parse(s) end + def convert_type_for_mass_assignment(field_type, value) - if field_type.is_a?(ActiveRecord::Reflection::AssociationReflection) and field_type.macro.in?([:belongs_to, :has_one]) - if value.is_a?(String) && value.starts_with?('@') - Hobo.object_from_dom_id(value[1..-1]) - else - value - end + if field_type.is_a?(ActiveRecord::Reflection::AssociationReflection) + convert_associated_records_for_mass_assignment(field_type, value) + elsif !field_type.is_a?(Class) value + elsif field_type <= Date if value.is_a? Hash Date.new(*(%w{year month day}.map{|s| value[s].to_i})) @@ -610,6 +491,7 @@ module Hobo else value end + elsif field_type <= Time if value.is_a? Hash Time.local(*(%w{year month day hour minute}.map{|s| value[s].to_i})) @@ -618,62 +500,52 @@ module Hobo else value end - elsif field_type <= TrueClass + + elsif field_type <= Hobo::Boolean (value.is_a?(String) && value.strip.downcase.in?(['0', 'false']) || value.blank?) ? false : true + else # primitive field value 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.not_in?(Hobo::Model::PLAIN_TYPES.values) - "val = begin; #{access_code}; end; " + - "if val.nil? || (val.respond_to?(:hobo_undefined?) && val.hobo_undefined?); val; " + - "else; self.class.field_type(:#{attr_name}).new(val); end" + def convert_associated_records_for_mass_assignment(reflection, value) + if reflection.macro.in?([:belongs_to, :has_one]) + if value.is_a?(String) + if value.starts_with?('@') + # TODO: This @foo_1 feature is rarely (never?) used - get rid of it + Hobo.object_from_dom_id(value[1..-1]) else - access_code + reflection.klass.named(value) end - - evaluate_attribute_method(attr_name, - "def #{symbol}; @attributes_cache['#{attr_name}'] ||= begin; #{src}; end; end") + else + value + end + elsif reflection.macro == :has_many + if reflection.klass.try.name_attribute + value.map do |x| + if x.is_a?(String) + reflection.klass.named(x) unless x.blank? + else + x + end + end.compact + else + value + end + + else + # unknown kind of accociation - no conversion + value + end + end + end - def define_write_method(attr_name) - src = if connected? && respond_to?(:field_type) && (type_wrapper = field_type(attr_name)) && - type_wrapper.is_a?(Class) && type_wrapper.not_in?(Hobo::Model::PLAIN_TYPES.values) - "if val.nil? || (val.respond_to?(:hobo_undefined?) && val.hobo_undefined?); val; " + - "else; self.class.field_type(:#{attr_name}).new(val); end" - else - "val" - end - evaluate_attribute_method(attr_name, "def #{attr_name}=(val); " + - "write_attribute('#{attr_name}', #{src});end", "#{attr_name}=") - - end - end + class ActiveRecord::Base alias_method :has_hobo_method?, :respond_to_without_attributes? end vendor/plugins/hobo/lib/hobo/model.rb @@ -6,66 +6,50 @@ module Hobo VIEWLIB_DIR = "taglibs" - PAGINATE_FORMATS = [ Mime::HTML, Mime::ALL ] + DONT_PAGINATE_FORMATS = [ Mime::CSV, Mime::YAML, Mime::JSON, Mime::XML, Mime::ATOM, Mime::RSS ] + + READ_ONLY_ACTIONS = [:index, :show] + WRITE_ONLY_ACTIONS = [:create, :update, :destroy] + FORM_ACTIONS = [:new, :edit] class << self def included(base) base.class_eval do @auto_actions ||= {} + + inheriting_cattr_reader :web_methods => [], :show_actions => [], :index_actions => [] extend ClassMethods + helper_method :model, :current_user before_filter :set_no_cache_headers + + rescue_from ActiveRecord::RecordNotFound, :with => :not_found + + rescue_from Hobo::Model::PermissionDeniedError, :with => :permission_denied + + alias_method_chain :render, :hobo_model + end - base.template_path_cache = {} Hobo::Controller.included_in_class(base) end end + module ClassMethods attr_writer :model - attr_accessor :template_path_cache - - def add_collection_actions(name) - defined_methods = instance_methods - - show_collection_method = "show_#{name}".to_sym - if show_collection_method.not_in?(defined_methods) && include_action?(show_collection_method, true) - define_method show_collection_method do - hobo_show_collection(name) - end - end - - if Hobo.simple_has_many_association?(model.reflections[name]) - new_method = "new_#{name.to_s.singularize}" - if new_method.not_in?(defined_methods) && include_action?(new_method, true) - define_method new_method do - hobo_new_in_collection(name) - end - end - end - end - - def web_methods - @web_methods ||= superclass.respond_to?(:web_methods) ? superclass.web_methods : [] - end - - def show_actions - @show_actions ||= superclass.respond_to?(:show_actions) ? superclass.show_actions : [] - end - - def index_actions - @index_actions ||= superclass.respond_to?(:index_actions) ? superclass.index_actions : [] - end - def collections - # By default, all has_many associations are published + # FIXME The behaviour here is weird if the superclass does + # define collections *and* this class adds some more. The + # added ones won't be published + + # by default By default, all has_many associations are published @collections ||= if superclass.respond_to?(:collections) superclass.collections else @@ -73,72 +57,110 @@ module Hobo end end + def model @model ||= name.sub(/Controller$/, "").singularize.constantize end - - - def autocomplete_for(attr, options={}, &b) - options = options.reverse_merge(:limit => 15) - options[:data_filters_block] = b - @completers ||= HashWithIndifferentAccess.new - @completers[attr.to_sym] = options + + + def autocomplete(name, options={}, &block) + options = options.dup + field = options.delete(:field) || name + if block + index_action "complete_#{name}", &block + else + index_action "complete_#{name}" do + hobo_completetions name, model, options + end + end end - def autocompleter(name) - (@completers && @completers[name]) || - (superclass.respond_to?(:autocompleter) && superclass.autocompleter(name)) - end - - def web_method(web_name, options={}, &block) web_methods << web_name.to_sym - method = options[:method] || web_name + method = options.delete(:method) || web_name got_block = block_given? define_method web_name do # Make sure we have a copy of the options - it is being mutated somewhere opts = {}.merge(options) @this = find_instance(opts) unless opts[:no_find] - set_status(Hobo.can_call?(current_user, @this, method) ? :valid : :not_allowed) - # TODO - block should get to handle permission denied? - if not_allowed? - permission_denied - elsif got_block + raise Hobo::Model::PermissionDeniedError unless Hobo.can_call?(current_user, @this, method) + if got_block instance_eval(&block) else @this.send(method) end - hobo_ajax_response unless performed? + hobo_ajax_response || render(:nothing => true) unless performed? end end def auto_actions(*args) - # auto_actions is either an array - the actions to provide, or a hash: { :except => [...] } + options = args.extract_options! + @auto_actions = case args.first - when :all then args.extract_options! - when :none then [] + when :all then available_auto_actions + when :write_only then available_auto_write_actions + args.rest + when :read_only then available_auto_read_actions + args.rest else args end + except = Array(options[:except]) + except_actions = except.map do |arg| + if arg == :collections + available_auto_collection_actions + else + arg + end + end + + @auto_actions -= except_actions.flatten + + def_auto_actions + end + + + def def_auto_actions self.class_eval do def index; hobo_index end if include_action?(:index) def show; hobo_show end if include_action?(:show) def new; hobo_new end if include_action?(:new) def create; hobo_create end if include_action?(:create) - def edit; hobo_edit end if include_action?(:edit) + def edit; hobo_show end if include_action?(:edit) def update; hobo_update end if include_action?(:update) def destroy; hobo_destroy end if include_action?(:destroy) def completions; hobo_completions end if include_action?(:completions) - collections.each { |c| add_collection_actions(c.to_sym) } + def reorder; hobo_reorder end if include_action?(:reorder) end + + collections.each { |c| def_collection_actions(c.to_sym) } end + def def_collection_actions(name) + defined_methods = instance_methods + + show_collection_method = name + if show_collection_method.not_in?(defined_methods) && include_action?(show_collection_method) + define_method show_collection_method do + hobo_show_collection(name) + end + end + + if Hobo.simple_has_many_association?(model.reflections[name]) + new_method = "new_#{name.to_s.singularize}" + if new_method.not_in?(defined_methods) && include_action?(new_method) + define_method new_method do + hobo_new_in_collection(name) + end + end + end + end + + def show_action(*names, &block) options = names.extract_options! show_actions.concat(names) @@ -158,504 +180,349 @@ module Hobo if block define_method(name, &block) else - define_method(name) { hobo_index options } + if scope = options.delete(:scope) + define_method(name) { hobo_index scope, options } + else + define_method(name) { hobo_index options } + end end end end def publish_collection(*names) collections.concat(names) - names.each {|n| add_collection_actions(n)} + names.each {|n| def_collection_actions(n)} end - def find_instance(id, options={}) - if model.id_name? and id !~ /^\d+$/ - model.find_by_id_name(id, options) - else - model.find(id, options) - end + def include_action?(name) + name.to_sym.in?(@auto_actions) end - - def include_action?(name, collection_action=false) - name = name.to_sym - if @auto_actions.is_a?(Array) - # White list - name.in?(@auto_actions) || (collection_action && :collections.in?(@auto_actions)) + + + def available_auto_actions + (available_auto_read_actions + + available_auto_write_actions + + FORM_ACTIONS + + available_auto_collection_actions).uniq + end + + + def available_auto_read_actions + READ_ONLY_ACTIONS + collections + end + + + def available_auto_write_actions + if "position_column".in?(model.instance_methods) + WRITE_ONLY_ACTIONS + [:reorder] else - # Black list - except = Array(@auto_actions[:except]) - return !(name.in?(except) || (collection_action && :collections.in?(except))) + WRITE_ONLY_ACTIONS end end + + + def available_auto_collection_actions + collections + collections.map {|c| "new_#{c.to_s.singularize}".to_sym} + end end protected - def data_filter(name, &b) - @data_filters ||= HashWithIndifferentAccess.new - @data_filters[name] = b - end - def search(*args) - if args.first.is_a?(Class) - model, search_string, *columns = args - else - model = self.model - search_string, *columns = args - end - return nil if search_string.blank? - - model.conditions do - words = search_string.split - terms = words.map do |word| - cols = columns.map do |c| - if c.is_a?(Symbol) - send("#{c}_contains", word) - elsif c.is_a?(Hash) - c.map do |k, v| - related = send(k) - v = [v] unless v.is_a?(Array) - v.map { |related_col| related.send("#{related_col}_contains", word) } - end - end - end.flatten - any?(*cols) + def parse_sort_param(*sort_fields) + _, desc, field = *params[:sort]._?.match(/^(-)?([a-z_]+(?:\.[a-z_]+)?)$/) + + if field + if field.in?(sort_fields.*.to_s) + @sort_field = field + @sort_direction = desc ? "desc" : "asc" + + [@sort_field, @sort_direction] end - all?(*terms) end end - attr_accessor :data_filters - # --- Action implementation helpers --- # - def find_instance(*args) - options = args.extract_options! - res = self.class.find_instance(args.first || params[:id], options) - instance_variable_set("@#{model.name.underscore}", res) - res - end - - - def set_named_this! - instance_variable_set("@#{@this.class.name.underscore}", @this) - end - - def response_block(&b) - if b - if b.arity == 1 - respond_to {|wants| yield(wants) } - else - yield - end - performed? - end + def find_instance(options={}) + model.user_find(current_user, params[:id], options) end - - def paginated_find(*args, &b) - options = args.extract_options! - filter_conditions = data_filter_conditions - conditions_proc = if b && filter_conditions - proc { block(b) & block(filter_conditions) } - else - b || filter_conditions - end - - @association = options.delete(:association) || - if args.length == 1 - scopes = args.first - @association = scopes.to_s.split(".").inject(model) { |m, name| m.send(name) } - elsif args.length == 2 - owner, collection_name = args - @association = collection_name.to_s.split(".").inject(owner) { |m, name| m.send(name) } - end - @reflection = @association.proxy_reflection if @association._?.respond_to?(:proxy_reflection) - - model_or_assoc, @member_class = if @association - [@association, @association.member_class] - else - [model, model] - end - - page_size = options.delete(:page_size) || 20 - page = options.delete(:page) || params[:page] - - paginate = options.fetch(:paginate, request.format.in?(PAGINATE_FORMATS)) - options.delete(:paginate) - if paginate - total_number = options.delete(:total_number) || - begin - # If there is a conditions block, it may depend on the includes - count_options = conditions_proc ? { :include => options[:include] } : {} - model_or_assoc.count(count_options, &conditions_proc) - end - - @pages = ::ActionController::Pagination::Paginator.new(self, total_number, page_size, page) - - options = options.reverse_merge(:limit => @pages.items_per_page, - :offset => @pages.current.offset) - end - - unless options.has_key?(:order) - _, desc, field = *params[:sort]._?.match(/^(-)?([a-z_]+(?:\.[a-z_]+)?)$/) - if field - @sort_field = field - @sort_direction = desc ? "desc" : "asc" - - table, column = if field =~ /^(.*)\.(.*)$/ - [$1.camelize.constantize.table_name, $2] - else - [@member_class.table_name, field] - end - options[:order] = "#{table}.#{column} #{@sort_direction}" - elsif !@association - options[:order] = :default - end - end - - model_or_assoc.find(:all, options, &conditions_proc) - end - - def find_instance_or_not_found(this=nil) - begin - this || find_instance - rescue ActiveRecord::RecordNotFound - not_found - false - end - end + def invalid?; !valid?; end - def save_and_set_status!(record, original=nil) - can = if record.new_record? - Hobo.can_create?(current_user, record) - else - Hobo.can_update?(current_user, original, record) - end - status = if can - record.save ? :valid : :invalid - else - :not_allowed - end - set_status(status) - end - - def set_status(status) - @status = status - end - - def invalid?; @status == :invalid; end - def valid?; @status == :valid; end + def valid?; this.errors.empty?; end - def not_allowed?; @status == :not_allowed; end - def re_render_form(default_action) if params[:page_path] controller, view = Controller.controller_and_view_for(params[:page_path]) view = default_action if view == Dryml::EMPTY_PAGE - hobo_render(view, model_for(controller)) + render :action => view, :controller => controller else - hobo_render(default_action) + render :action => default_action end end - def model_for(controller_name) - "#{controller_name.camelize}Controller".constantize.model - end - - - def destination_after_create(record) + def destination_after_submit(record=nil, destroyed=false) + record ||= this + + after_submit = params[:after_submit] + # The after_submit post parameter takes priority - params[:after_submit] || + (after_submit == "stay-here" ? :back : after_submit) || + - # Then try the records show page - object_url(@this, :if_available => true) || + # Then try the record's show page + (!destroyed && object_url(@this)) || # Then the show page of the 'owning' object if there is one - (@this.dependent_on.first && object_url(@this.dependent_on.first, :if_available => true)) || + (!destroyed && (@this.class.default_dependent_on && object_url(@this.send(@this.class.default_dependent_on)))) || # Last try - the index page for this model - object_url(@this.class, :if_available => true) || + object_url(@this.class) || # Give up home_page end + def response_block(&b) + if b + if b.arity == 1 + respond_to {|wants| yield(wants) } + else + yield + end + performed? + end + end + + + def request_requires_pagination? + request.format.not_in?(DONT_PAGINATE_FORMATS) + end + + + def find_or_paginate(finder, options) + options = options.reverse_merge(:paginate => request_requires_pagination?) + do_pagination = options.delete(:paginate) && finder.respond_to?(:paginate) + + if do_pagination + finder.paginate(options.reverse_merge(:page => params[:page] || 1)) + else + finder.all(options) + end + end + + # --- Action implementations --- # def hobo_index(*args, &b) options = args.extract_options! - options = LazyHash.new(options) - @model = model - collection = args.first - @this = if collection.blank? - paginated_find(options) - elsif collection.is_a?(String, Symbol) - paginated_find(collection, options) # a scope name - else - collection - end - instance_variable_set("@#{@model.name.pluralize.underscore}", @this) - response_block(&b) or hobo_render + finder = args.first || model + self.this = find_or_paginate(finder, options) + response_block(&b) end def hobo_show(*args, &b) options = args.extract_options! - options = LazyHash.new(options) - - @this = find_instance_or_not_found(args.first) and - begin - set_status(:not_allowed) unless Hobo.can_view?(current_user, @this) - set_named_this! - response_block(&b) or - if not_allowed? - permission_denied - else - hobo_render - end - end + self.this = find_instance(options) + response_block(&b) end - - - def hobo_new(*args, &b) - options = args.extract_options! - options = LazyHash.new(options) - @this = args.first || model.new - @this.set_creator(current_user) if options.fetch(:set_creator, true) - - set_status(:not_allowed) unless Hobo.can_create?(current_user, @this) - set_named_this! - response_block(&b) or - if not_allowed? - permission_denied - else - hobo_render - end + + + def hobo_new(new_record=nil, &b) + self.this = new_record || model.new + this.user_changes!(current_user) # set_creator and permission check + response_block(&b) end - + def hobo_create(*args, &b) options = args.extract_options! - options = LazyHash.new(options) - - @this = args.first || - begin - create_model = if 'type'.in?(model.column_names) && - (type_attr = params['type']) && - type_attr.in?(model.send(:subclasses).every(:name)) - type_attr.constantize - else - model - end - create_model.new(params[model.name.underscore]) - end - @this.set_creator(current_user) if options.fetch(:set_creator, true) - save_and_set_status!(@this) - set_named_this! - - flash[:notice] = "The #{model.name.titleize.downcase} was created successfully" if !request.xhr? && valid? + self.this = args.first || new_for_create + this.user_save_changes(current_user, options[:attributes] || attribute_parameters) + create_response(&b) + end + + + def attribute_parameters + params[this.class.name.underscore] + end + + + def new_for_create + if model.has_inheritance_column? && (type_attr = params['type']) && type_attr.in?(model.send(:subclasses).*.name) + type_attr.constantize + else + model + end.new + end + + + def create_response(&b) + flash[:notice] = "The #{@this.class.name.titleize.downcase} was created successfully" if !request.xhr? && valid? response_block(&b) or if valid? respond_to do |wants| - wants.html { redirect_to(destination_after_create(@this)) } - wants.js { hobo_ajax_response || render(:text => "") } + wants.html { redirect_to destination_after_submit } + wants.js { hobo_ajax_response || render(:nothing => true) } end - elsif invalid? + else respond_to do |wants| wants.html { re_render_form(:new) } wants.js { render(:status => 500, - :text => ("There was a problem creating that #{create_model.name}.\n" + - @this.errors.full_messages.join("\n"))) } + :text => ("Couldn't create the #{this.class.name.titleize.downcase}.\n" + + this.errors.full_messages.join("\n"))) } end - elsif not_allowed? - permission_denied end end - def hobo_edit(*args, &b) - hobo_show(*args, &b) - end - - def hobo_update(*args, &b) options = args.extract_options! - options = LazyHash.new(options) - - @this = find_instance_or_not_found(args.first) or return - original = @this.duplicate - # 'duplicate' can cause these to be set, but they can conflict - # with the changes so we clear them - @this.send(:clear_aggregation_cache) - @this.send(:clear_association_cache) - changes = params[@this.class.name.underscore] - @this.attributes = changes - save_and_set_status!(@this, original) + self.this = args.first || find_instance + changes = options[:attributes] || attribute_parameters + this.user_save_changes(current_user, changes) # Ensure current_user isn't out of date @current_user = @this if @this == current_user + in_place_edit_field = changes.keys.first if changes.size == 1 && params[:render] + update_response(in_place_edit_field, &b) + end + + + def update_response(in_place_edit_field=nil, &b) flash[:notice] = "Changes to the #{@this.class.name.titleize.downcase} were saved" if !request.xhr? && valid? - set_named_this! response_block(&b) or if valid? respond_to do |wants| wants.html do - redirect_to(params[:after_submit] || object_url(@this)) + redirect_to destination_after_submit end wants.js do - if changes.size == 1 && params[:render] + if in_place_edit_field # Decreasingly hacky support for the scriptaculous in-place-editor - new_val = Hobo::Dryml.render_tag(@template, "view", - :with => @this, :field => changes.keys.first, - :no_wrapper => true) - hobo_ajax_response(@this, :new_field_value => new_val) + new_val = call_dryml_tag("view", :field => in_place_edit_field, :no_wrapper => true) + hobo_ajax_response(this, :new_field_value => new_val) else - hobo_ajax_response(@this) + hobo_ajax_response(this) end # Maybe no ajax requests were made render :nothing => true unless performed? end end - elsif invalid? + else respond_to do |wants| wants.html { re_render_form(:edit) } wants.js { render(:status => 500, :text => ("There was a problem with that change.\n" + @this.errors.full_messages.join("\n"))) } end - elsif not_allowed? - permission_denied end end def hobo_destroy(*args, &b) options = args.extract_options! - options = LazyHash.new(options) - @this = find_instance_or_not_found(args.first) or return - - set_named_this! - - set_status(Hobo.can_delete?(current_user, @this) ? :valid : :not_allowed) - unless not_allowed? - @this.destroy - flash[:notice] = "The #{model.name.titleize.downcase} was deleted" unless request.xhr? - end - + self.this = args.first || find_instance + this.user_destroy(current_user) + flash[:notice] = "The #{model.name.titleize.downcase} was deleted" unless request.xhr? + destroy_response(&b) + end + + + def destroy_response(&b) response_block(&b) or - if not_allowed? - permission_denied - else - respond_to do |wants| - wants.html { redirect_to(:action => "index") } - wants.js { hobo_ajax_response || render(:text => "") } - end + respond_to do |wants| + wants.html { redirect_to destination_after_submit(this, true) } + wants.js { hobo_ajax_response || render(:nothing => true) } end end - + - def hobo_show_collection(collection, options={}, &b) - options = LazyHash.new(options) - - @owner = find_instance_or_not_found(options[:owner]) or return - - if collection.is_a?(Array) - @this = collection - @reflection = collection.proxy_reflection if collection.respond_to?(:proxy_reflection) - else - toplevel_collection = collection.to_s.split(".").first - set_status(:not_allowed) unless Hobo.can_view?(current_user, @owner, toplevel_collection) - @this = paginated_find(@owner, collection, options) unless not_allowed? + def hobo_show_collection(association, *args, &b) + options = args.extract_options! + association = find_instance.send(association) if association.is_a?(String, Symbol) + if association.respond_to?(:origin) + association.origin.user_view(current_user, association.origin_attribute) # permission check end - - response_block(&b) or - if not_allowed? - permission_denied - else - hobo_render(params[:action]) or (@reflection and hobo_render(:show_collection, @reflection.klass)) - end + self.this = find_or_paginate(association, options) + dryml_fallback_tag("show_collection_page") + response_block(&b) end - def hobo_new_in_collection(collection, *args, &b) + # TODO: This action needs some more tidying up + def hobo_new_in_collection(association, *args, &b) options = args.extract_options! - this = args.first - options = LazyHash.new(options) - - @owner = find_instance_or_not_found(options[:owner]) or return - @association = collection.is_a?(Array) ? collection : @owner.send(collection) - @this = this || @association.new - set_named_this! - @this.set_creator(current_user) if options.fetch(:set_creator, true) - - set_status(:not_allowed) unless Hobo.can_create?(current_user, @this) - - response_block(&b) or - if not_allowed? - permission_denied - else - hobo_render("new_#{collection.to_s.singularize}") or hobo_render("new_in_collection", @this.class) - end + @association = association.is_a?(String, Symbol) ? find_instance.send(association) : association + self.this = args.first || @association.new + this.user_changes(current_user) # set_creator and permission check + dryml_fallback_tag("new_in_collection_page") + response_block(&b) end - def hobo_completions - opts = self.class.autocompleter(params[:for]) - if opts - # Eval any defined filters - instance_eval(&opts[:data_filters_block]) if opts[:data_filters_block] - conditions = data_filter_conditions - q = params[:query] - items = model.find(:all) { all?(send("#{attr}_contains", q), conditions && block(conditions)) } - - render :text => "<ul>\n" + items.map {|i| "<li>#{i.send(attr)}</li>\n"}.join + "</ul>" - else - render :text => "No completer for #{attr}", :status => 404 + def hobo_completions(attribute, finder, options={}) + options = options.reverse_merge(:limit => 10, :param => :query) + finder = finder.limit(options[:limit]) unless finder.scope(:find, :limit) + finder = finder.send("#{attribute}_contains", params[options[:param]]) + items = finder.find(:all) + render :text => "<ul>\n" + items.map {|i| "<li>#{i.send(attribute)}</li>\n"}.join + "</ul>" + end + + + def hobo_reorder + params["#{model.name.underscore}_ordering"].each_with_index do |id, position| + model.user_update(current_user, id, :position => position+1) end + hobo_ajax_response || render(:nothing => true) end - #def hobo_create_in_collection(collection, options={}, &b) - # hobo_create do - # hobo_new_in_collection(collection, :this => @this, &b) - # end - #end # --- Response helpers --- # - - def permission_denied(options={}) - if respond_to? :permission_denied_response - permission_denied_response - elsif render_tag("permission-denied-page", { :with => @this }, :status => 403) - # cool + def permission_denied(error) + self.this = nil # Otherwise this gets sent user_view + if :permission_denied.in?(superclass.instance_methods) + super else - message = options[:message] || "Permission Denied" - render :text => message, :status => 403 + respond_to do |wants| + wants.html do + if render_tag("permission-denied-page", { }, :status => 403) + # job done + else + render :text => "Permission Denied", :status => 403 + end + end + wants.js do + render :text => "Permission Denied", :status => 403 + end + end end end - def not_found - if respond_to? :not_found_response - not_found_response - elsif render_tag("not-found-page", { :with => @this }, :status => 404) + def not_found(error) + if :not_found_response.in?(superclass.instance_methods) + super + elsif render_tag("not-found-page", {}, :status => 404) # cool else render(:text => "The page you requested cannot be found.", :status => 404) @@ -663,46 +530,34 @@ module Hobo end - def hobo_template_exists?(dir, name) - self.class.template_path_cache.clear if RAILS_ENV == "development" - self.class.template_path_cache.fetch([dir, name], - begin - full_dir = "#{RAILS_ROOT}/app/views/#{dir}" - !Dir["#{full_dir}/#{name}.*"].empty? - end) + def this + @this ||= (instance_variable_get("@#{model.name.underscore}") || + instance_variable_get("@#{model.name.underscore.pluralize}")) end - - def find_model_template(klass, name) - while klass and klass != ActiveRecord::Base - dir = klass.name.underscore.pluralize - dir = File.join(subsite, dir) if subsite - if hobo_template_exists?(dir, name) - return "#{dir}/#{name}" - end - klass = klass.superclass - end - nil + + def this=(object) + ivar = if object.is_a?(Array) + (object.try.member_class || model).name.underscore.pluralize + else + model.name.underscore + end + @this = instance_variable_set("@#{ivar}", object) end - - def hobo_render(page_kind = nil, page_model=nil) - page_kind ||= params[:action].to_sym - page_model ||= model - - if hobo_template_exists?(controller_path, page_kind) - render :action => page_kind - true - elsif (template = find_model_template(page_model, page_kind)) - render :template => template - true - else - # This returns false if no such tag exists - render_tag("#{page_kind.to_s.dasherize}-page", :with => @this) - end + + def dryml_context + this end + def render_with_hobo_model(*args, &block) + options = args.extract_options! + self.this = options[:object] if options[:object] + this.user_view(current_user) if this && this.respond_to?(:user_view) + render_without_hobo_model(*args + [options], &block) + end + # --- filters --- # def set_no_cache_headers @@ -715,21 +570,12 @@ module Hobo # --- end filters --- # + public def model self.class.model end - - def data_filter_conditions - active_filters = data_filters && (params.keys & data_filters.keys) - filters = data_filters - params = self.params - proc do - all?(*active_filters.map {|f| instance_exec(params[f], &filters[f])}) - end unless active_filters.blank? - end - end end vendor/plugins/hobo/lib/hobo/model_controller.rb @@ -2,9 +2,21 @@ class ActionController::Routing::RouteSet # Monkey patch this method so routes are reloaded on *every* # request. Without this Rails checks the mtime of config/routes.rb # which doesn't take into account Hobo's auto routing - def reload - load! + #def reload + # # TODO: This can get slow - quicker to stat routes.rb and the + # # controllers and only do a load if there's been a change + # load! + #end + + # temporay hack -- reload assemble.rb whenever routes need reloading + def reload_with_hobo_assemble + if defined? ::ApplicationController + load "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb" + reload_without_hobo_assemble + end end + alias_method_chain :reload, :hobo_assemble + end module Hobo @@ -16,19 +28,30 @@ module Hobo class << self def reset_linkables - @linkable = Hash.new {|h, k| h[k] = Hash.new {|h, k| h[k] = {} } } + @linkable =Set.new end - def linkable(subsite, klass, action) - @linkable[subsite][klass.name][action] = true + def linkable_key(klass, action, options) + opts = options.map { |k, v| "#{k}=#{v}" unless v.blank? }.compact.join(',') + "#{klass.name}/#{action}/#{opts}" end - def linkable?(subsite, klass, action) - @linkable[subsite][klass.name][action] + def linkable!(klass, action, options={}) + options[:method] ||= :get + @linkable << linkable_key(klass, action, options) + end + + def linkable?(klass, action, options={}) + options[:method] ||= :get + @linkable.member? linkable_key(klass, action, options) end def add_routes(map) + # Don't create routes if it's a generator that's running + return if caller[-1] =~ /script[\/\\]generate:\d+$/ + reset_linkables + begin ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active? rescue @@ -45,11 +68,17 @@ module Hobo # Any directory inside app/controllers defines a subsite subsites = Dir["#{APP_ROOT}/controllers/*"].map { |f| File.basename(f) if File.directory?(f) }.compact subsites.each { |subsite| add_routes_for(map, subsite) } + + add_developer_routes(map) if Hobo.developer_features? + rescue ActiveRecord::StatementInvalid + # Database problem? Just continue without routes end def add_routes_for(map, subsite) module_name = subsite._?.camelize + + # FIXME: This should go directly to the controllers, not load the models first. Hobo.models.each do |model| controller_name = "#{model.name.pluralize}Controller" is_defined = if subsite @@ -59,12 +88,18 @@ module Hobo end controller_filename = File.join(*["#{APP_ROOT}/controllers", subsite, "#{controller_name.underscore}.rb"].compact) if is_defined || File.exists?(controller_filename) - owner_module = subsite ? module_name.constantize : Object - controller = owner_module.const_get(controller_name) + controller = (subsite ? "#{module_name}::#{controller_name}" : controller_name).constantize ModelRouter.new(map, model, controller, subsite) end end end + + + def add_developer_routes(map) + map.dryml_support "dryml/:action", :controller => "hobo/dryml/dryml_support" + map.dev_support "dev/:action", :controller => "hobo/dev" + end + end @@ -103,7 +138,10 @@ module Hobo collection_routes web_method_routes show_action_routes - user_routes if controller < Hobo::UserController + reorder_route + + lifecycle_routes if defined? model::Lifecycle + user_routes if controller < Hobo::UserController end end @@ -111,6 +149,9 @@ module Hobo def resource_routes # We re-implement resource routing - routes are not created for # actions that the controller does not provide + + # FIX ME -- what about routes with formats (e.g. .xml)? + linkable_route(plural, plural, :index, :conditions => { :method => :get }) linkable_route("new_#{singular}", "#{plural}/new", :new, :conditions => { :method => :get }) @@ -126,49 +167,52 @@ module Hobo def collection_routes controller.collections.each do |collection| - new_method = Hobo.simple_has_many_association?(model.reflections[collection]) - named_route("#{singular}_#{collection}", - "#{plural}/:id/#{collection}", - :action => "show_#{collection}", - :conditions => { :method => :get }) + linkable_route("#{singular}_#{collection}", + "#{plural}/:id/#{collection}", + collection.to_s, + :conditions => { :method => :get }) - named_route("new_#{singular}_#{collection.to_s.singularize}", - "#{plural}/:id/#{collection}/new", - :action => "new_#{collection.to_s.singularize}", - :conditions => { :method => :get }) if new_method + if Hobo.simple_has_many_association?(model.reflections[collection]) + linkable_route("new_#{singular}_#{collection.to_s.singularize}", + "#{plural}/:id/#{collection}/new", + "new_#{collection.to_s.singularize}", + :conditions => { :method => :get }) + end end end def web_method_routes controller.web_methods.each do |method| - named_route("#{plural.singularize}_#{method}", "#{plural}/:id/#{method}", - :action => method.to_s, :conditions => { :method => :post }) + linkable_route("#{plural.singularize}_#{method}", "#{plural}/:id/#{method}", method.to_s, :conditions => { :method => :post }) end end def index_action_routes controller.index_actions.each do |view| - named_route("#{view}_#{plural}", "#{plural}/#{view}", - :action => view.to_s, :conditions => { :method => :get }) + linkable_route("#{view}_#{plural}", "#{plural}/#{view}", view.to_s, :conditions => { :method => :get }) end end def show_action_routes controller.show_actions.each do |view| - named_route("#{plural.singularize}_#{view}", "#{plural}/:id/#{view}", - :action => view.to_s, :conditions => { :method => :get }) + linkable_route("#{plural.singularize}_#{view}", "#{plural}/:id/#{view}", view.to_s, :conditions => { :method => :get }) end end + + def reorder_route + linkable_route("reorder_#{plural}", "#{plural}/reorder", 'reorder', :conditions => { :method => :post }) + end + def user_routes prefix = plural == "users" ? "" : "#{singular}_" - named_route("#{singular}_login", "#{prefix}login", :action => 'login') - named_route("#{singular}_logout", "#{prefix}logout", :action => 'logout') - named_route("#{singular}_signup", "#{prefix}signup", :action => 'signup') + linkable_route("#{singular}_login", "#{prefix}login", 'login') + linkable_route("#{singular}_logout", "#{prefix}logout", 'logout') + linkable_route("#{singular}_signup", "#{prefix}signup", 'signup') end @@ -187,8 +231,12 @@ module Hobo end - def linkable_route(name, route, action, options) - named_route(name, route, options.merge(:action => action.to_s)) and self.class.linkable(subsite, model, action) + def linkable_route(name, route, action, options={}) + named_route(name, route, options.merge(:action => action.to_s)) and + begin + linkable_options = { :method => options[:conditions]._?[:method], :subsite => subsite } + self.class.linkable!(model, action, linkable_options) + end end vendor/plugins/hobo/lib/hobo/model_router.rb @@ -1,8 +1,20 @@ module Hobo::RapidHelper - def options_for_hobo_ajax(options) - js_options = build_callbacks(options) + def rapid_build_callbacks(options) + callbacks = {} + options.each do |callback, code| + if AJAX_CALLBACKS.include?(callback.to_sym) + name = 'on' + callback.to_s.capitalize + callbacks[name] = "function(request){#{code}}" + end + end + callbacks + end + + def options_for_hobo_ajax(options) + js_options = rapid_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 @@ -11,7 +23,8 @@ module Hobo::RapidHelper js_options['resultUpdate'] = js_result_updates(options[:result_update]) if options[:result_update] 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['spinnerNextTo'] = options[:spinner_next_to] if options.has_key?(:spinner_next_to) + js_options['spinnerNextTo'] = js_str(options[:spinner_next_to]) if options.has_key?(:spinner_next_to) + js_options['message'] = js_str(options[:message]) if options[:message] js_options.empty? ? nil : options_for_javascript(js_options) end @@ -39,7 +52,7 @@ module Hobo::RapidHelper end - def ajax_updater(url_or_form, message, update, options={}) + def ajax_updater(url_or_form, update, options={}) options ||= {} options.symbolize_keys! @@ -49,7 +62,7 @@ module Hobo::RapidHelper js_str(url_or_form) end js_options = options_for_hobo_ajax(options) - args = [target, js_str(message || "..."), js_updates(update), js_options].compact + args = [target, js_updates(update), js_options].compact confirm = options.delete(:confirm) @@ -83,7 +96,7 @@ module Hobo::RapidHelper blank_message = attributes.delete(:blank_message) || "(click to edit)" attributes = add_classes(attributes, behaviour_class) - attributes.update(:hobo_model_id => this_field_dom_id, + attributes.update(:hobo_model_id => dom_id, :hobo_blank_message => blank_message, :if_blank => blank_message, :no_wrapper => false) @@ -96,12 +109,39 @@ module Hobo::RapidHelper - AJAX_ATTRS = [:before, :success, :failure, :complete, :type, :method, - :script, :form, :params, :confirm, - :reset_form, :refocus_form, :result_update, :spinner_next_to] + AJAX_CALLBACKS = [ :before, :success, :failure, :complete ] + + AJAX_ATTRS = AJAX_CALLBACKS + [ :type, :method, + :script, :form, :params, :confirm, :message, + :reset_form, :refocus_form, :result_update, :spinner_next_to ] def editor_class end + + def through_collection_names(object=this) + object.class.reflections.values.select do |refl| + refl.macro == :has_many && refl.options[:through] + end.map {|x| x.options[:through]} + end + + + def primary_collection_name(object=this) + dependent_collection_names = object.class.reflections.values.select do |refl| + refl.macro == :has_many && refl.options[:dependent] + end.*.name + + (dependent_collection_names - through_collection_names(object)).first + end + + + def non_through_collections(object=this) + names = object.class.reflections.values.select do |refl| + refl.macro == :has_many + end.*.name + + names - through_collection_names + end + end vendor/plugins/hobo/lib/hobo/rapid_helper.rb @@ -40,3 +40,5 @@ module Hobo end end + + vendor/plugins/hobo/lib/hobo/undefined.rb @@ -4,6 +4,12 @@ module Hobo module User + @user_models = [] + + def self.default_user_model + @user_models.first._?.constantize + end + AUTHENTICATION_FIELDS = [:salt, :crypted_password, :remember_token, :remember_token_expires_at] # Extend the base class with AuthenticatedUser functionality @@ -12,9 +18,12 @@ module Hobo # - plaintext password validation # - login token for rembering a login during multiple browser sessions def self.included(base) + @user_models << base.name + base.extend(ClassMethods) base.class_eval do + fields do crypted_password :string, :limit => 40 salt :string, :limit => 40 @@ -22,21 +31,20 @@ module Hobo remember_token_expires_at :datetime end - # Virtual attribute for the unencrypted password - attr_accessor :password + validates_confirmation_of :password, :if => :password_required? - validates_presence_of :password, :if => :password_required? - validates_presence_of :password_confirmation, :if => :password_required? - validates_confirmation_of :password, :if => :password_required? - + # Virtual attributes for setting and changing the password + attr_accessor :current_password, :password, :password_confirmation, :type => :password + + + validate :validate_current_password_when_changing_password + before_save :encrypt_password never_show *AUTHENTICATION_FIELDS attr_protected *AUTHENTICATION_FIELDS - set_field_type :password => :password, :password_confirmation => :password - password_validations end end @@ -50,23 +58,22 @@ module Hobo end def login_attribute=(attr, validate=true) - @login_attr = attr = attr.to_sym + @login_attribute = attr = attr.to_sym unless attr == :login alias_attribute(:login, attr) - set_field_type :login => field_type(attr) + declare_attr_type(:login, attr_type(attr)) if table_exists? # this breaks if the table doesn't exist end if validate - validates_presence_of attr validates_length_of attr, :within => 3..100 validates_uniqueness_of attr, :case_sensitive => false end end - attr_reader :login_attr + attr_reader :login_attribute # Authenticates a user by their login name and unencrypted password. Returns the user or nil. def authenticate(login, password) - u = find(:first, :conditions => ["#{@login_attr} = ?", login]) # need to get the salt + u = find(:first, :conditions => ["#{@login_attribute} = ?", login]) # need to get the salt if u && u.authenticated?(password) if u.respond_to?(:last_login_at) || u.respond_to?(:login_count) @@ -125,6 +132,10 @@ module Hobo false end + def changing_password? + crypted_password? && (password || password_confirmation) + end + protected # Before filter that encrypts the password before having it stored in the database. def encrypt_password @@ -133,9 +144,15 @@ module Hobo self.crypted_password = encrypt(password) end + # Is a password required for login? (or do we have an empty password?) def password_required? - (crypted_password.blank? && password != nil) || !password.blank? + (crypted_password.blank? && password != nil) || !password.blank? || changing_password? + end + + + def validate_current_password_when_changing_password + changing_password? && !authenticated?(current_password) and errors.add :current_password, "is not correct" end end vendor/plugins/hobo/lib/hobo/user.rb @@ -2,15 +2,18 @@ module Hobo module UserController - @user_models = [] - class << self - attr_reader :user_models - def included(base) - base.filter_parameter_logging "password" - base.skip_before_filter :login_required, :only => [:login] - user_models << base.model + base.class_eval do + filter_parameter_logging "password" + skip_before_filter :login_required, :only => [:login, :signup] + + include_taglib "rapid_user_pages", :plugin => "hobo" + + show_action :account + + alias_method_chain :hobo_update, :account_flash + end end end @@ -20,9 +23,10 @@ module Hobo def logout; hobo_logout; end + private + def hobo_login(options={}) - options = LazyHash.new(options) - login_attr = model.login_attr.to_s.titleize.downcase + login_attr = model.login_attribute.to_s.titleize.downcase options.reverse_merge!(:success_notice => "You have logged in.", :failure_notice => "You did not provide a valid #{login_attr} and password.") @@ -36,10 +40,12 @@ module Hobo # If supplied, a block can be used to test if this user is # allowed to log in (e.g. the account may be disabled) - if block_given? && !yield + account_available = block_given? ? yield : true + + if !account_available # block returned false - cancel this login self.current_user = old_user - hobo_render(:account_disabled) + render :action => :account_disabled unless performed? else if params[:remember_me] == "1" current_user.remember_me @@ -50,30 +56,21 @@ module Hobo end end end - - hobo_render unless performed? end def hobo_signup(&b) if request.post? - @user = model.new(params[model.name.underscore]) - @this = @user - save_and_set_status!(@user) - self.current_user = @user if valid? + self.this = model.user_create(current_user, params[model.name.underscore]) + self.current_user = this if valid? response_block(&b) or if valid? flash[:notice] ||= "Thanks for signing up!" redirect_back_or_default(home_page) - elsif invalid? - hobo_render - elsif not_allowed? - permission_denied end else - @this = @user = model.new + self.this = model.new yield if block_given? - hobo_render unless performed? end end @@ -81,15 +78,32 @@ module Hobo def hobo_logout(options={}) options = options.reverse_merge(:notice => "You have logged out.", :redirect_to => base_url) - - current_user.forget_me if logged_in? - cookies.delete :auth_token - reset_session + + logout_current_user yield if block_given? flash[:notice] ||= options[:notice] redirect_back_or_default(options[:redirect_to]) unless performed? end + + def hobo_update_with_account_flash(*args) + hobo_update_without_account_flash(*args) do + flash[:notice] = "Changes to your account were saved" if valid? && @this == current_user + yield if block_given? + end + end + + private + + def logout_current_user + if logged_in? + current_user.forget_me + cookies.delete :auth_token + reset_session + self.current_user = nil + end + end + end end vendor/plugins/hobo/lib/hobo/user_controller.rb @@ -3,9 +3,9 @@ </def> -<def tag="wrap" attrs="tag, when"> - <% body = parameters.default %> - <%= when_ ? call_tag(tag, attributes, &proc { body }) : body %> +<def tag="wrap" attrs="tag, when, parameter"> + <% parameter ||= :default %> + <%= when_ ? send(tag, attributes, { parameter.to_sym => parameters[:default] }) : parameter.default %> </def> @@ -15,8 +15,8 @@ %></def> -<def tag="repeat" attrs="even-odd, join"><%= - if !this.blank? +<def tag="repeat" attrs="even-odd, join"> + <if><%= if even_odd map_this do klass = [attributes[:class], cycle("even", "odd")].compact.join(' ') @@ -31,15 +31,13 @@ res end.join(join) end - end - else - "" - end -%></def> + end %> + </if> +</def> <def tag="do"><%= parameters.default %></def> -<def tag="with"><%= parameters.default %></def> +<def tag="with" alias-of="do"/> <def tag="if" attrs="test"><%= vendor/plugins/hobo/taglibs/core.dryml @@ -7,6 +7,8 @@ <include src="rapid_forms"/> <include src="rapid_navigation"/> <include src="rapid_plus"/> +<include src="rapid_generics"/> + <def tag="field-list" attrs="tag"> <% tag ||= scope.in_form ? "input" : "view" %> @@ -29,18 +31,20 @@ <def tag="nil-view"><%= scope.nil_view || "(Not Available)" %></def> -<def tag="ul"> +<def tag="ul" attrs="empty"> <% if all_parameters.li? # don't use dryml if, because it will mess up <ul/><else> %> - <unless test="&this.empty?"> + <if test="&empty || all_parameters[:head] || all_parameters[:foot] || !this.empty?"> <% element "ul", attributes do %> + <do param="head"/> <repeat> <li param if="&can_view?" class="#{scope.even_odd} #{this_type.name.underscore.dasherize}" merge-attrs="&{'hobo-model-id' => dom_id(this)} if this.respond_to?(:typed_id)"> <do param="default"><a/></do> </li> </repeat> + <do param="foot"/> <% end %> - </unless> + </if> <% else %> <%= element("ul", attributes, all_parameters.default) %> <% end %> @@ -73,7 +77,7 @@ <td param="#{this_field.to_s.sub('?', '').gsub('.', '-')}-view"><call-tag tag="&field_tag"/></td> </with-fields> <td class="controls" param="controls" if="&all_parameters[:controls]"> - <a param="edit-link">Edit</a> + <a param="edit-link" action="edit">Edit</a> <delete-button param/> </td> </if> @@ -97,39 +101,9 @@ </def> -<def tag="theme-image" attrs="src"> - <img src="#{theme_asset('images/' + src)}" merge-attrs/> -</def> - - -<def tag="card"> - <if test="&can_view?"> - <%= poly = call_polymorphic_tag('card', attributes, parameters) %> - <div class="card #{linkable? ? 'linkable' : 'content'} #{type_name :dasherize => true}" unless="&poly"> - <a if="&linkable?"/> - <div class="content" param="content"> - <primary-content if="&!linkable?"/> - </div> - <creation-details/> - <span class="dependents"><count-dependents /></span> - </div> - </if> -</def> - - -<def tag="collection"> - <%= poly = call_polymorphic_tag('collection', attributes, parameters) %> - <ul class="collection" merge-attrs unless="&poly"> - <li:><card param/></li:> - </ul> - <p class="empty-collection-message" if="&this.empty?" param="empty-message"> - There are no <type-name plural/> - </p> -</def> - - <def tag="hobo-rapid-javascripts" attrs="tiny-mce"><%= res = '<script type="text/javascript">var hoboParts = {};' + # FIXME: This should interrogate the model-router - not the models unless Hobo.all_models.empty? # Tell JS code how to pluralize names, unless they follow the simple rule names = Hobo.all_models.map do |m| @@ -147,7 +121,7 @@ if tiny_mce res += javascript_include_tag("tiny_mce/tiny_mce_src") + %{ <script type="text/javascript"> - tinyMCE.init({ mode: "textareas", editor_selector: "tiny_mce", + tinyMCE.init({ mode: "textareas", editor_selector: "tiny-mce", plugins: 'save', theme_advanced_buttons1 : "bold, italic, separator, " + "bullist, outdent, indent, separator, " + @@ -183,18 +157,23 @@ %></def> <def tag="type-name" attrs="type, plural, lowercase, dasherize"><%= - type ||= if this.is_a?(Class) - this - elsif this.respond_to? :proxy_reflection - this.proxy_reflection.klass - else - this.class - end + type ||= (this if this.is_a?(Class)) || this.try.member_class || this.class + name = dasherize ? type.name.underscore.dasherize : type.name.titleize name = name.pluralize if plural name = name.downcase if lowercase name %></def> + + +<def tag="name-for-collection" attrs="singular, lowercase"><%= + name = (attr = this.try.origin_attribute and attr.to_s) || type_name(:plural => true) + name = name.titleize + name = name.singularize if singular + name = name.downcase if lowercase + name +%></def> + <def tag="a" attrs="action, to, params, query-params, href, format, subsite"><%= @@ -216,17 +195,18 @@ # Link to a new object form new_record = target.new new_record.set_creator(current_user) - if can_create?(new_record) - + href = object_url(target, "new", params._?.merge(:subsite => subsite)) + + if href && can_create?(new_record) new_class_name = if target.respond_to?(:proxy_reflection) target.proxy_reflection.klass.name else target.name end - href = object_url(target, "new", params._?.merge(:subsite => subsite)) add_classes!(attributes, "new-#{new_class_name.underscore}-link") content = "New #{new_class_name.titleize}" if content.blank? + Hobo::Dryml.last_if = true element(:a, attributes.update(:href => href), content) else Hobo::Dryml.last_if = false @@ -235,22 +215,15 @@ else # Link to an existing object - if target.is_a?(Array) && !target.respond_to?(:proxy_reflection) && target.respond_to?(:member_class) - # Not much to go on here - last guess is that this is an index page - target = target.member_class - end - content = name if content.blank? - # Do we want automatic disabling of links to thinks that are not - # linkable? - only_if_linkable = format.blank? - href = object_url(target, action, (params || {}).merge(:subsite => subsite, :if_available => only_if_linkable)) + href = object_url(target, action, (params || {}).merge(:subsite => subsite)) if href.nil? # This target is registered with ModelRouter as not linkable content else - add_classes!(attributes, "#{target.class.name.underscore}-link") + css_class = target.try.origin_attribute || target.class.name.underscore + add_classes!(attributes, "#{css_class}-link") href.sub!(/\?|$/, ".#{format}\\0") unless format.blank? @@ -268,21 +241,23 @@ res = if this.nil? && if_blank.nil? this_type.is_a?(Class) && this_type <= String ? "" : nil_view - elsif this_type.respond_to?(:macro) - if this_type.macro == :belongs_to - belongs_to_view(attributes) - elsif this_type.macro == :has_many - has_many_view(attributes) - end + elsif (refl = this_field_reflection) && refl.macro == :has_many + has_many_view(attributes) else - 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") if view_tag == "view" # i.e. it didn't find a type specific tag - raise HoboError, "Cannot view: #{this.inspect} (field is #{this_field}, type is #{this.class})" + if this.respond_to?(:to_html) + this.to_html + else + raise HoboError, "Cannot view: #{this.inspect} (field is #{this_field}, type is #{this.class})" + end else + attrs = add_classes(attributes, "view", type_and_field) + id = dom_id + attrs['hobo-model-id'] = id unless id == "nil" + view_attrs = attrs_for(view_tag) the_view = send(view_tag, attrs & view_attrs) @@ -321,36 +296,27 @@ <def tag="view" for="Numeric" attrs="format"><%= format ? format % this : this.to_s %></def> -<def tag="view" for="Hobo::Text"><%= h(this).gsub("\n", "<br/>") %></def> +<def tag="view" for="string"><%= this.try.to_html || h(this).gsub("\n", "<br/>") %></def> -<def tag="view" for="html"><%= this %></def> +<def tag="view" for="boolean"><%= this ? 'Yes' : 'No' %></def> -<def tag="view" for="Hobo::MarkdownString"><%= this.to_html %></def> +<def tag="view" for="ActiveRecord::Base"><a/></def> -<def tag="view" for="Hobo::TextileString"><%= this.to_html %></def> -<def tag="view" for="Hobo::PasswordString">[password withheld]</def> - -<def tag="view" for="String"><%= h(this).gsub("\n", "<br/>") %></def> - -<def tag="view" for="TrueClass"><%= this ? 'Yes' : 'No' %></def> - -<def tag="count" attrs="label, prefix, if-any"><%= +<def tag="count" attrs="label, prefix, if-any, lowercase"><%= raise Exception.new("asked for count of a string") if this.is_a?(String) - if this.is_a?(Class) and this < ActiveRecord::Base - c = this.count - label ||= this.name.titleize - else - label ||= this.respond_to?(:proxy_reflection) && this.proxy_reflection.name.to_s.singularize.titleize - c = if this.is_a?(Fixnum) - this - elsif this.respond_to?(:count) - this.count - else - this.length - end - end + c = this.try.to_int || this.try.total_entries || this.try.count || this.try.length + + label ||= if this.is_a?(Class) + this.name + elsif (attr = this.try.origin_attribute) + attr.to_s.singularize + else + this.member_class.name + end.titleize + + label = label.downcase if lowercase Hobo::Dryml.last_if = c > 0 if if_any if if_any && c == 0 @@ -360,7 +326,7 @@ if prefix.in? %w(are is) p = c == 1 ? "is" : "are" - p + ' ' + main + p + ' ' + main.to_s else main end @@ -369,15 +335,12 @@ <def tag="theme-stylesheet" attrs="name"> - <% name ||= 'application' -%> - <link href="<%= base_url %>/hobothemes/<%= Hobo.current_theme %>/stylesheets/<%= name %>.css" + <% name ||= Hobo.current_theme -%> + <link href="#{base_url}/hobothemes/#{Hobo.current_theme}/stylesheets/#{name}.css" media="screen" rel="Stylesheet" type="text/css" /> </def> -<def tag="clearer"><div class='clearer'>&nbsp;</div></def> - - <!-- The Tags defined below here are a bit rough and will be improved in the future - use at your own risk. --> @@ -386,12 +349,12 @@ in the future - use at your own risk. --> <do param="default"/> - <if test="&delete_buttons != false and can_delete?(this)"> + <if test="&delete_buttons != false && can_delete?(this)"> <td><delete-button/></td> </if> </table-for> <else> - <p>There are no <%= this_type.klass.name.titleize.pluralize.downcase %></p> + <p>There are no <%= this.member_class.name.titleize.pluralize.downcase %></p> </else> <div> <create-button update="&id || part_id"/> @@ -423,16 +386,9 @@ in the future - use at your own risk. --> </def> -<def tag="you" attrs="have, are"> - <if test="&this == current_user">you <%= if have then 'have' elsif are then 'are' end %></if> - <else><do param="default"><name/> <%= if have then 'has' elsif are then 'is' end %></do></else> -</def> - +<def tag="you" attrs="have, are, do, titleize"><if test="&this == current_user"><%= "#{titleize ? 'Y' : 'y'}ou#{' have' if have}#{' are' if are}#{' do' if do_}" %></if><else><do param="default"><name/><%= "#{' has' if have}#{' is' if are}#{' does' if do_}" %></do></else></def> -<def tag="You" attrs="have, are"> - <if test="&this == current_user">You <%= if have then 'have' elsif are then 'are' end %></if> - <else><do param="default"><name/> <%= if have then 'has' elsif are then 'is' end %></do></else> -</def> +<def tag="You"><you merge titleize/></def> <def tag="your"> <if test="&this == current_user">your</if> @@ -446,17 +402,6 @@ in the future - use at your own risk. --> </def> -<def tag="creation-details"> - <span class="creation-details"> - <view with="&this.send(this.class.creator_attribute)" class="creator" if="&this.class.creator_attribute" /> - <view:created_at class="created-at" if="&this.respond_to?(:created_at)"/> - </span> -</def> - -<def tag="primary-content"> - <view class="primary-content" field="&this.class.primary_content_attribute" if="&this.class.primary_content_attribute"/> -</def> - <def tag="live-search"> <div class="search"> <label for="search-field">Search</label><input type="search" id="search-field" name="search-field" class="search-bhv search"/> @@ -468,11 +413,6 @@ in the future - use at your own risk. --> </section> </def> -<def tag="count-dependents"> - <% assoc = this.class.dependent_collections.first if this.class.dependent_collections.length == 1 %> - <count field="&assoc" if="&assoc"/> -</def> - <def tag="a-or-an" attrs="word"><%= (word =~ /^[aeiouh]/i ? "an " : "a ") + word @@ -482,3 +422,15 @@ in the future - use at your own risk. --> <def tag="A-or-An" attrs="word"><%= (word =~ /^[aeiouh]/i ? "An " : "A ") + word %></def> + + +<def tag="filter-menu" attrs="param-name, options, no-filter"> + <% no_filter ||= "All" %> + <form action="&request.request_uri" method="get" class="filter-menu"> + <hidden-field name="filter-parameter" value="&param_name"/> + <select-menu name="&param_name" options="&options" selected="&params[param_name.gsub('-', '_')]" first-option="&no_filter" merge-params/> + </form> +</def> + + +<def tag="comma-list" attrs="separator"><%= this.join(separator || ", ") %></def> vendor/plugins/hobo/taglibs/rapid.dryml @@ -1,14 +1,14 @@ <def tag="editor" ><%= if !can_edit? view(attributes) - elsif this_type.respond_to?(:macro) - if this_type.macro == :belongs_to + elsif (refl = this_field_reflection) + if refl.macro == :belongs_to belongs_to_editor(attributes) else has_many_editor(attributes) end else - attrs = add_classes(attributes, "#{type_and_field}", "#{type_id}", "editor") + attrs = add_classes(attributes, type_id, type_and_field, "editor") call_polymorphic_tag("editor", attrs) or raise HoboError.new("<editor> not implemented for #{this.class.name}\##{this_field} " + "(#{this.inspect}:#{this_type})") @@ -43,8 +43,8 @@ <def tag="editor" for="big_integer"><%= in_place_editor "in_place_textfield_bhv", attributes %></def> -<def tag="editor" for="Hobo::EnumString"> - <string-select-editor values="&this_type.values"/> +<def tag="editor" for="HoboFields::EnumString"> + <string-select-editor values="&this_type.values" merge/> </def> @@ -56,36 +56,37 @@ else completer_model = completer_model.constantize if completer_model.is_a? String end - id ||= this_field_dom_id + "_completer" + id ||= dom_id + "_completer" url = object_url(completer_model, "completions", { :for => completer_attr }.update(attributes.select_hash {|k,v| k.to_s.starts_with? "where_"})) %> <input type="text" name="#{name}" id="#{id}" class="autocomplete-bhv" autocomplete-url="#{url}" value="#{value}" merge-attrs/> - <div id="<%= id %>-completions" class="completions-popup" style="display:none"></div> + <div id="#{id}-completions" class="completions-popup" style="display:none"></div> </def> -<def tag="belongs-to-menu-editor"><% +<def tag="belongs-to-menu-editor" attrs="sort"><% raise HoboError.new("Not allowed to edit") unless can_edit? - link_id = "#{this_field_dom_id}_editor" %> - <span id="#{link_id}" part="rapid-belongs-to-edit"> - <% select_options = this_type.klass.find(:all).select {|x| can_view?(x)}.map {|x| + link_id = "#{dom_id}_editor" %> + <span id="#{link_id}" part="rapid-belongs-to-edit" part-locals="sort"> + <% select_options = this_field_reflection.klass.find(:all).select {|x| can_view?(x)}.map {|x| [ name(:with => x, :no_wrapper => true), x.id ] } + select_options = select_options.sort if sort select_options.insert(0, ["(No #{this_type.name.to_s.titleize})", ""]) if this.nil? - link_id = "#{this_field_dom_id}_editor" + link_id = "#{dom_id}_editor" f = ajax_updater(object_url(this_parent), - "Change #{this_field.to_s.titleize}", [link_id], + [link_id], :method => "put", :params => { this_parent.class.name.underscore => { - this_type.primary_key_name => Hobo.raw_js('this.value') + this_field_reflection.primary_key_name => Hobo.raw_js('this.value') } }) %> <select onchange="#{f}"> - <%= options_for_select(select_options.sort, this ? this.id : "") %> - </select>&nbsp;<a if="&this">View</a> + <%= options_for_select(select_options, this ? this.id : "") %> + </select>&nbsp;<a if="&this && linkable?">View</a> </span> </def> @@ -94,9 +95,9 @@ <if-can-edit><% return object_link unless can_edit? - id ||= this_field_dom_id + "_completer" + id ||= dom_id + "_completer" f = ajax_updater(object_url(this_parent), - "Change #{this_field.to_s.titleize}", update, + update, :method => "put", :params => { this_parent.class.name.underscore => { this_field => Hobo.raw_js("$('#{id}').value") @@ -125,7 +126,7 @@ values = comma_split(values) f = ajax_updater(object_url(this_parent), - "Change #{this_field.to_s.titleize}", update, + update, :method => "put", :params => { this_parent.class.name.underscore => { this_field => Hobo.raw_js('this.value') @@ -141,9 +142,9 @@ <def tag="boolean-checkbox-editor" attrs="update, message"><% raise HoboError.new("Not allowed to edit") unless can_edit? f = ajax_updater(object_url(this_parent), - message || "Change #{this_field.to_s.titleize}", update, :method => "put", + :message => message, :spinner_next_to => Hobo.raw_js("this"), :params => { this_parent.class.name.underscore => { this_field => Hobo.raw_js('this.checked') @@ -159,11 +160,11 @@ <% base_class = this.class base_class = base_class.superclass while base_class.superclass != ActiveRecord::Base f = ajax_updater("#{base_url}/#{controller_for base_class}/#{this.id}", - "Change #{this_field.to_s.titleize}", update, - :method => "put", - :params => { base_class.name.underscore => { - "type" => Hobo.raw_js('this.value') - } }) + update, + :method => "put", + :params => { base_class.name.underscore => { + "type" => Hobo.raw_js('this.value') + } }) %> <select onchange="#{f}"> @@ -175,7 +176,7 @@ <def tag="integer-select-editor" attrs="min, max, update, nil-option, message"> <select class="number-editor-bhv" hobo-update="#{update}" - hobo-model-id="#{this_field_dom_id}" + hobo-model-id="#{dom_id}" merge-attrs="&message ? attributes.merge(:hobo_message => message) : attributes"> <if test="&this.nil?"><option value=""><%= nil_option || "Choose a value" %></option></if> <%= options_for_select((min.to_i..max.to_i).to_a, this) %> @@ -197,17 +198,17 @@ if obj == nil new = klass.new(fields) permission = if can_create?(new) - message ||= "Setting #{new.class.name.titleize}" class_name = new.class.name.underscore - checkbox_attrs[:onclick] = ajax_updater(object_url(new.class), message, update, - ({:params => { class_name => fields }} unless fields.empty?)) + ajax_options = { :message => message } + ajax_options[:params] = { class_name => fields } unless fields.empty? + checkbox_attrs[:onclick] = ajax_updater(object_url(new.class), update, ajax_options) end else permission = if can_delete?(obj) checkbox_attrs[:checked] = 'checked' message ||= "Unsetting #{obj.class.name.titleize}" class_name = obj.class.name.underscore - checkbox_attrs[:onclick] = ajax_updater(object_url(obj, "destroy"), message, update, {:method => 'delete'}) + checkbox_attrs[:onclick] = ajax_updater(object_url(obj, "destroy"), update, {:message => message, :method => 'delete'}) end end element(:input, add_classes(attributes.merge(checkbox_attrs), vendor/plugins/hobo/taglibs/rapid_editing.dryml @@ -20,58 +20,73 @@ %></def> -<def tag="form" attrs="message, update, hidden-fields, action, method, web-method"><%= +<def tag="form" attrs="update, hidden-fields, action, method, web-method"><%= ajax_attrs, html_attrs = attributes.partition_hash(Hobo::RapidHelper::AJAX_ATTRS) - html_attrs[:action] = action || object_url(this, web_method) + new_record = this.try.new_record? - new_record = this.respond_to?(:new_record?) && this.new_record? - method = if method.nil? (action || web_method || new_record) ? "post" : "put" else method.downcase end - if method == "put" - http_method_hidden = hidden_field_tag("_method", "PUT") - html_attrs[:method] = "post" - else - html_attrs[:method] = method - end - - if update || !ajax_attrs.empty? - message ||= "Creating #{this.class.name.titleize}" if new_record - # add an onsubmit to convert to an ajax form if `update` is given - function = ajax_updater(:post_form, message, update, ajax_attrs) - html_attrs[:onsubmit] = [html_attrs[:onsubmit], "#{function}; return false;"].compact.join("; ") - end - body, field_names = scope.new_scope do - scope[:in_form] = true - with_form_context { parameters.default } - end - - hiddens = hidden_fields(:fields => hidden_fields, :skip => field_names) if new_record - - auth_token = if request_forgery_protection_token.nil? - '' - else - element(:input, :type => "hidden", - :name => request_forgery_protection_token.to_s, - :value => form_authenticity_token) - end - - page_path_hidden = hidden_field_tag("page_path", view_name) - - body = [http_method_hidden, page_path_hidden, auth_token, hiddens, body].join + html_attrs[:action] = action || object_url(this, web_method, :method => method) - if web_method - add_classes!(html_attrs, "#{type_id}_#{web_method}_form") + if html_attrs[:action].nil? || (new_record && !this.user_can_create?(current_user)) + Hobo::Dryml.last_if = false + "" else - add_classes!(html_attrs, "#{'new_' if new_record}#{type_id}") + if method == "put" + # browsers don't support put -- use post and add the Rails _method hack + http_method_hidden = hidden_field_tag("_method", "PUT") + html_attrs[:method] = "post" + else + html_attrs[:method] = method + end + + if update || !ajax_attrs.empty? + # add an onsubmit to convert to an ajax form if `update` is given + function = ajax_updater(:post_form, update, ajax_attrs) + html_attrs[:onsubmit] = [html_attrs[:onsubmit], "#{function}; return false;"].compact.join("; ") + end + + body, field_names = scope.new_scope do + scope[:in_form] = true + with_form_context { parameters.default } + end + + hiddens = hidden_fields(:fields => hidden_fields, :skip => field_names) if new_record + + auth_token = if method.nil? || method == 'get' || request_forgery_protection_token.nil? + '' + else + element(:input, :type => "hidden", + :name => request_forgery_protection_token.to_s, + :value => form_authenticity_token) + end + + page_path = if request.post? || request.put? && params[:page_path] + params[:page_path] + else + view_name.sub(Hobo::Dryml::EMPTY_PAGE, params[:action]) + end + page_path_hidden = hidden_field_tag("page_path", page_path) unless method == "get" + + body = [http_method_hidden, page_path_hidden, auth_token, hiddens, body].join + + + if action.nil? # don't add automatic css classes if the action was specified + if web_method + add_classes!(html_attrs, "#{type_id}_#{web_method}_form") + else + add_classes!(html_attrs, "#{'new_' if new_record}#{type_id}") + end + end + + Hobo::Dryml.last_if = true + element("form", html_attrs, body) end - - element("form", html_attrs, body) %></def> @@ -89,19 +104,18 @@ elsif !can_edit? view else - attrs = add_classes(attributes, type_and_field) - the_input = if this_type.respond_to?(:macro) - if this_type.macro == :belongs_to - belongs_to_input(attrs) - elsif this_type.macro == :has_many - if this_type.options[:through] - has_many_through_input(attrs) + attrs = add_classes(attributes, type_id, type_and_field) + the_input = if (refl = this_field_reflection) + if refl.macro == :belongs_to + select_one(attrs) + elsif refl.macro == :has_many + if refl.options[:through] + select_many(attrs) else has_many_input(attrs) end end else - add_classes!(attrs, type_id) attrs[:name] ||= param_name_for_this the_input = call_polymorphic_tag('input', attrs) or raise HoboError, ("No input tag for #{this_field}:#{this_type} (this=#{this.inspect})") @@ -132,12 +146,12 @@ </def> <def tag="input" for="date" attrs="order"> - <% order = order.nil? ? [:year, :month, :day] : comma_split(order).every(:to_sym) -%> + <% order = order.nil? ? [:year, :month, :day] : comma_split(order).*.to_sym -%> <%= select_date(this || Time.now, attributes.merge(:prefix => param_name_for_this, :order => order)) %> </def> <def tag="input" for="datetime" attrs="order"> - <% order = order.nil? ? [:year, :month, :day, :hour, :minute] : comma_split(order).every(:to_sym) -%> + <% order = order.nil? ? [:year, :month, :day ] : comma_split(order).*.to_sym -%> <%= select_datetime(this || Time.now, attributes.merge(:prefix => param_name_for_this, :order => order)) %> </def> @@ -157,7 +171,7 @@ <%= text_field_tag(name, this, attributes) %> </def> -<def tag="input" for="Hobo::EnumString" attrs="labels,titleize"> +<def tag="input" for="HoboFields::EnumString" attrs="labels,titleize"> <% labels ||= {} %> <% titleize = true if titleize.nil? %> <select name="#{param_name_for_this}" merge-attrs> @@ -165,26 +179,18 @@ </select> </def> -<def tag="input" for="percentage" attrs="name"> - <%= text_field_tag(name, this, attributes.merge(:size => '3', :maxlength => '3')) %>% -</def> - - -<def tag="belongs-to-input"> - <%= belongs_to_menu_input(attributes) %> -</def> -<!--- Buttons ---> +<!-- Buttons --> -<def tag="remote-method-button" attrs="method, update, result-update, params, label, message"><%= +<def tag="remote-method-button" attrs="method, update, label"><%= ajax_attributes, html_attributes = attributes.partition_hash(Hobo::RapidHelper::AJAX_ATTRS) - url = object_url(this, method) + url = object_url(this, method, :method => :post) add_classes!(html_attributes, "button remote-method-button #{method}-button") - if update || result_update - message ||= method.titleize - func = ajax_updater(url, message, update, - ajax_attributes.merge(:params => params, :result_update => result_update)) + if update || result_update || !ajax_attrs.empty? + label ||= method.titleize + ajax_attributes[:message] ||= label + func = ajax_updater(url, update, ajax_attributes) html_attributes.update(:onclick => "var e = this; " + func, :type =>'button', :value => label) element(:input, html_attributes) else @@ -193,10 +199,10 @@ %></def> -<def tag="update-button" attrs="label, message, update, fields, params"><%= +<def tag="update-button" attrs="label, update, fields, params"><%= raise HoboError.new("no update specified") unless update - message ||= label - func = ajax_updater(object_url(this), message, update, + ajax_attributes[:message] ||= label + func = ajax_updater(object_url(this), update, :params => { this.class.name.underscore => fields }.merge(params || {}), :method => :put) element :input, add_classes(attributes.merge(:type =>'button', :onclick => func, :value => label), @@ -204,8 +210,10 @@ </def> -<def tag="delete-button" attrs="label, message, update, in-place, image, confirm, fade, subsite"><%= - if (Hobo::Dryml.last_if = can_delete?) +<def tag="delete-button" attrs="label, update, in-place, image, confirm, fade, subsite"><%= + in_place = false if in_place.nil? && this == @this && !request.xhr? + url = object_url(this, :method => :delete, :subsite => subsite) + if (Hobo::Dryml.last_if = url && can_delete?) attributes = attributes.merge(if image { :type => "image", :src => "#{base_url}/images/#{image}" } else @@ -217,15 +225,18 @@ add_classes!(attributes, image ? "image-button" : "button", "delete-button delete-#{this.class.name.underscore.dasherize}-button") - url = object_url(this, "destroy", :subsite => subsite) - if in_place == false - attributes[:confirm] = confirm if confirm - button_to(label, url, attributes) - else - fade = true if fade.nil? - attributes[:value] = label - attributes[:onclick] = "Hobo.removeButton(this, '#{url}', #{js_updates(update)}, {fade:#{fade}, confirm: #{confirm.inspect}})" - element(:input, attributes) + if url + if in_place == false + attributes[:confirm] = confirm if confirm + attributes[:method] = :delete + button_to(label, url, attributes) + else + fade = true if fade.nil? + scope.collection_contains_delete_button = true if fade + attributes[:value] = label + attributes[:onclick] = "Hobo.removeButton(this, '#{url}', #{js_updates(update)}, {fade:#{fade}, confirm: #{confirm.inspect}})" + element(:input, attributes) + end end else "" @@ -233,14 +244,14 @@ %></def> -<def tag="create-button" attrs="model, update, label, message, fields"><%= +<def tag="create-button" attrs="model, update, label, fields, message"><%= raise HoboError.new("no update specified") unless update fields ||= {} class_or_assoc = if model model.is_a?(String) ? model.constantize : model elsif Hobo.simple_has_many_association?(this) - fields[this.proxy_reflection.primary_key_name] = this.proxy_owner.id + fields[this_field_reflection.primary_key_name] = this.proxy_owner.id this else raise HoboError.new("invalid context for <create-button>") @@ -249,25 +260,27 @@ new.set_creator(current_user) if can_create?(new) label ||= "New #{new.class.name.titleize}" - message ||= label + ajax_attributes = { :message => message } + ajax_attributes[:params] = { class_name => fields } unless fields.empty? class_name = new.class.name.underscore - func = ajax_updater(object_url(new.class), message, update, - ({:params => { class_name => fields }} unless fields.empty?)) + func = ajax_updater(object_url(new.class), message, update, ajax_attributes) element :input, add_classes(attributes.merge(:type =>'button', :onclick => func, :value => label), - "button create-button create-#{class_name}-button") + "button create-button create-#{class_name}-button") end %></def> -<def tag="belongs-to-menu-input" attrs="include-none, blank-message, options"><% +<def tag="select-one" attrs="include-none, blank-message, options, sort"><% raise HoboError.new("Not allowed to edit") unless can_edit? blank_message ||= "(No #{this_type.name.to_s.titleize})" - options ||= this_type.klass.find(:all, :conditions => this_type.options[:conditions]).select {|x| can_view?(x)} - #Todo: switch to autocompleter for id_name when too many records, and id_name supported + conditions = ActiveRecord::Associations::BelongsToAssociation.new(this, this_field_reflection).conditions + options ||= this_field_reflection.klass.all(:conditions => conditions).select {|x| can_view?(x)} + #Todo: switch to autocompleter for id_name when too many records, and id_name supported select_options = options.map { |x| [ name(:with => x, :no_wrapper => true), x.id ] - }.sort + } + select_options = select_options.sort if sort select_options.insert(0, [blank_message, ""]) if include_none || (this.nil? && include_none != false) attributes = add_classes(attributes, "input", "belongs_to", type_and_field) %> @@ -277,18 +290,11 @@ </def> -<def tag="belongs-to-autocompleting-input"> -<% refl = this_type - completer_model ||= refl.klass - completer_attr ||= refl.klass.id_name_column - id ||= this_field_dom_id + "_completer" - where_attributes = attributes.select_hash {|k,v| k.to_s.starts_with? "where_"} - url = object_url(completer_model, :completions, { :for => completer_attr }.update(where_attributes)) - %> - - <input type="text" id="#{id}" class="autocomplete-bhv" autocomplete-url="#{url}" - name="#{param_name_for_this}" merge-attrs/> - <div id="#{id}-completions" class="completions-popup" style="display:none"></div> +<def tag="name-one" attrs="complete-target, completer"> + <input type="text" name="#{param_name_for_this}" + class="autocompleter #{type_and_field} complete-on:#{dom_id complete_target}:#{completer}" + merge-attrs/> + <div class="completions-popup" style="display:none"></div> </def> @@ -316,35 +322,52 @@ </def> -<def tag="name-array-input" attrs="targets, remove-label"> +<def tag="select-many" attrs="options, targets, remove-label, prompt"> <% - all ||= this.member_class.find(:all) + prompt ||= "Add a #{this_field.titleize.singularize}" + options ||= this.member_class.all values = this %> - <div class="input has-many-through" merge-attrs> + <div class="input select-many" merge-attrs> <div style="display:none" class="item-proto"> - <div class="item"> + <div class="item" param="proto-item"> <span></span> - <input type="hidden" name="#{param_name_for_this}[]" /> - <input type="button" class="remove-item" value="#{remove_label || 'Remove'}"/> + <input type="hidden" name="#{param_name_for_this}[]" param="proto-hidden"/> + <input type="button" class="remove-item" value="#{remove_label || 'Remove'}" param="proto-remove-button"/> </div> </div> <div class="items"> - <div class="item" repeat> - <span><%= this %></span> - <input type="hidden" name="#{param_name_for_this}[]" value="#{this}"/> - <input type="button" class="remove-item" value="#{remove_label || 'Remove'}"/> - </div> + <set param-name="&param_name_for_this"/> + <repeat> + <div class="item" param="item"> + <span><%= this %></span> + <input type="hidden" name="#{param_name}[]" value="#{this}" param="hidden"/> + <input type="button" class="remove-item" value="#{remove_label || 'Remove'}" param="remove-button"/> + </div> + </repeat> </div> <select> - <option value="">Add a <%= this_field.titleize.singularize %></option> - <option repeat="&all.sort_by {|x| name(:no_wrapper => true, :with => x).downcase}" + <option value=""><prompt/></option> + <option repeat="&options.sort_by {|x| name(:no_wrapper => true, :with => x).downcase}" merge-attrs="&{:style => 'display:none'} if this.in?(values)"><name/></option> </select> </div> </def> -<def tag="after-submit" attrs="uri"> - <input type="hidden" value="&params[:after_submit] || uri" name="after_submit"/> +<def tag="after-submit" attrs="uri, stay-here, go-back"> + <% uri = "stay-here" if stay_here %> + <% uri = session[:previous_uri] if go_back %> + <input type="hidden" value="&params[:after_submit] || uri" name="after_submit" if="&uri"/> +</def> + + +<def tag="hidden-field" attrs="name, value"><input type="hidden" name="&name" value="&value" merge-attrs/></def> + + +<def tag="select-menu" attrs="options, selected, first-option, first-value"> + <select merge-attrs param="default"> + <option value="#{first_value}" unless="&first_option.nil?"><first-option/></option> + <do param="options"><% options_for_select(options.*.to_s, selected) %></do> + </select> </def> vendor/plugins/hobo/taglibs/rapid_forms.dryml @@ -3,9 +3,10 @@ --> <!--- General Navigation --> - + +<!-- General purpose navigation bar. Renders a `<ul class="navigation">` --> <def tag="navigation" attrs="current"> - <ul merge-attrs> + <ul class="navigation" merge-attrs> <set-scoped current-navigation="&current"> <do param="default"/> </set-scoped> @@ -21,18 +22,22 @@ </def> +<def tag="main-nav"><magic-nav class="main-nav"/></def> + + <!--- Account Navigation (log in / out / signup) --> <def tag="account-nav"> - <ul class="account-nav"> + <ul with="&current_user" class="account-nav" param> <if test="&logged_in?"> - <li class='nav-item'>Logged in as <view:login with="&current_user"/></li> - <li class='nav-item'><a href="&logout_url">Log out</a></li> + <li class='nav-item' param="logged-in-as"><a to="&current_user">Logged in as <name/></a></li> + <li class='nav-item' param="account"><a action="account">Account</a></li> + <li class='nav-item' param="log-out"><a href="&logout_url">Log out</a></li> </if> <else> - <set user="&Hobo::UserController.user_models.first"/> - <li class='nav-item'><a href="&login_url(user)">Log in</a></li> - <li if="&signup_url(user)" class='nav-item'><a href="&signup_url(user)">Sign up</a></li> + <set user="&Hobo::User.default_user_model"/> + <li class='nav-item' param="log-in"><a href="&login_url(user)">Log in</a></li> + <li if="&signup_url(user)" class="nav-item" param="sign-up"><a href="&signup_url(user)">Sign up</a></li> </else> </ul> </def> @@ -41,54 +46,49 @@ <!--- Pagination Navigation --> <def tag="page-nav" attrs="params"> - <if test="&@pages && @pages.length > 1"> - <page-n-of-count/> - - <first-page-link params="&params">|&lt;</first-page-link> - <previous-page-link params="&params">Previous</previous-page-link> - <next-page-link params="&params">Next</next-page-link> - <last-page-link params="&params">&gt|</last-page-link> - </if> + <%= will_paginate this, attributes.symbolize_keys.reverse_merge(:inner_window => 2, :prev_label => "&laquo; Prev") %> </def> <def tag="page-n-of-count"> - Page <%= @pages.current_page.number %> of <%= @pages.length %> + Page <%= this.current_page %> of <%= this.page_count %> </def> <def tag="previous-page-link"> - <a if="&@pages && @pages.current.previous" - href="&url_for(params.merge(:page => @pages.current.previous))"> + <a if="&this.try.previous_page" + href="&url_for(params.merge(:page => this.previous_page))"> <do param="default">&laquo; Previous page</do> </a> </def> <def tag="next-page-link"> - <a if="&@pages && @pages.current.next" - href="&url_for(params.merge(:page => @pages.current.next))"> + <a if="&this.try.next_page" + href="&url_for(params.merge(:page => this.next_page))"> <do param="default">Next page &raqou;</do> </a> </def> <def tag="first-page-link"> - <a if="&@pages && @pages.first_page && @pages.current != @pages.first_page" - href="&url_for(params.merge(:page => @pages.first_page))"> + <a if="&this.try.current_page && this.current_page != 1" + href="&url_for(params.merge(:page => 1))"> <do param="default">&laquo; First page</do> </a> </def> <def tag="last-page-link"> - <a if="&@pages && @pages.last_page && @pages.current != @pages.last_page" - href="&url_for(params.merge(:page => @pages.last_page))"> + <a if="&this.try.current_page && this.current_page != this.page_count" + href="&url_for(params.merge(:page => this.page_count))"> <do param="default">Last page &raquo;</do> </a> </def> -<!-- magic nav, just to get you started --> -<!-- write your own navigation using the <navigation> tag --> + +<!-- magic nav, just to get you started. Don't try to customise this +but rather write your own navigation using the `<navigation>` tag --> <def tag="magic-nav"> <navigation merge-attrs> <nav-item href="#{base_url}/">Home</nav-item> vendor/plugins/hobo/taglibs/rapid_navigation.dryml @@ -1,9 +1,9 @@ -<def tag="base-page" attrs="title, doctype"> - <% title ||= default_page_title %> +<def tag="base-page" attrs="title, full-title, doctype"> + <% full_title ||= "#{title} : #{app_name}" %> <doctype param version="&doctype || 'HTML 4.01 STRICT'"/> <html> <head param> - <title param><%= title.gsub(/<.*?>/, '') %></title> + <title param><%= full_title.gsub(/<.*?>/, '') %></title> <do param="stylesheets"> <stylesheet name="reset"/> <stylesheet name="hobo-rapid"/> @@ -12,12 +12,13 @@ <do param="scripts"> <javascript param name="prototype, effects, dragdrop, controls, lowpro, hobo-rapid, application"/> + <do param="fix-ie6"><%= "<!--[if lt IE 7]>" %><javascript name="IE7"/><%= "<![endif]-->" %></do> <hobo-rapid-javascripts param/> </do> </head> <body onload="Hobo.applyEvents();" param/> -</html> + </html> </def> @@ -26,11 +27,11 @@ <body: param> <ajax-progress/> <header class="page-header" param> - <heading param="app-name"><a href="/#{base_url}"><app-name/></a></heading> - <live-search param if="&defined_route? :search"/> + <heading param="app-name"><a href="#{base_url}/"><app-name/></a></heading> + <live-search param if="&defined_route? :site_search"/> <nav param> - <account-nav if="&Hobo::UserController.user_models.first" param/> - <magic-nav class="main-nav" param="main-nav"/> + <account-nav if="&Hobo::User.default_user_model" param/> + <main-nav param/> </nav> </header> <section class="page-content" param="content"> @@ -41,6 +42,7 @@ <footer class="content-footer" param="content-footer"/> </section> <footer class="page-footer" param/> + <part-contexts-javascripts/> </body:> </base-page> </def> @@ -53,7 +55,7 @@ <section class="main-content" param="main-content"> <param-content for="content"/> </section> - <aside class="aside-content" param/> + <aside class="aside-content" empty param/> </content:> </simple-layout> </def> @@ -63,40 +65,44 @@ <def tag="index-page"> - <% model_name = @model.name.titleize %> - <page title="All #{model_name.pluralize}" merge> - <body: class="index-page #{@model.name.underscore}" param/> + <set model="&this.try.member_class || self.model"/> + <set model-name="&model.name.titleize"/> + <page title="All #{type_name :with => model, :plural => true}" merge> + <body: class="index-page #{type_id model}" param/> <content-header: param> - <heading param><%= model_name.pluralize %></heading> - <p class="note" param>There <do with="&@model"><count part="item-count" prefix="are"/></do></p> - </content-header> + <heading param><type-name with="&model" plural/></heading> + <p class="note" param="count"> + <if>There <count prefix="are"/></if> + <else>There aren't any <type-name lowercase plural/> yet.</else> + </p> + </content-header:> <content-body: param> <nav param="top-pagination-nav"><page-nav/></nav> - <collection param/> + <collection param><empty-message:></empty-message:></collection> <nav param="bottom-pagination-nav"><page-nav/></nav> </content-body> <content-footer: param> - <a to="&@model" action="new" param="new-link" if="&linkable?(@model, :new)"/> + <a to="&model" action="new" param="new-link"/> <else> - <do with="&new_for_current_user @model"> - <section class="create-new" if="&can_create?"> + <if with="&model.user_new current_user"> + <section class="create-new"> <h2>New <type-name/></h2> - <form><field-list/><submit label="Create #{type_name}"/></form> + <form><field-list param="new-field-list"/><submit label="Create"/></form> </section> - </do> + </if> </else> - </content-footer> + </content-footer:> </page> </def> <def tag="new-page"> <page title="New #{type_name}" merge> - <body: class="new-page #{type_name.underscore}" param/> + <body: class="new-page #{type_name :dasherize => true}" param/> <content-header: param> <heading param>New <type-name title/></heading> </content-header> @@ -105,7 +111,7 @@ <error-messages param/> <form param> - <field-list skip-associations="has_many" param/> + <field-list param/> <div class="actions" param="actions"> <submit label="Create #{type_name}" param/><do param="back-link"> or <a>Cancel</a></do> </div> @@ -115,89 +121,92 @@ </def> -<def tag="show-page"> - <% has_many_assocs = this.class.reflections.values.map do |refl| - this.send(refl.name) if Hobo.simple_has_many_association?(refl) - end.compact - dependent_collection = this.class.dependent_collections.first if this.class.dependent_collections.length == 1 - %> +<def tag="show-page" attrs="primary-collection"> + <set primary-collection-name="&(primary_collection || self.primary_collection_name).to_s" model="&this.class"/> + <set boolean-fields="&model.columns.select {|c| c.type == :boolean }.*.name"/> + <set skip-fields="&boolean_fields + [model.name_attribute, model.primary_content_attribute, model.creator_attribute, model.dependent_on.first].compact"/> + <set flags="&boolean_fields.map {|f| f.titleize if this.send(f)}.compact.join(', ')"/> + <page merge title="#{name :no_wrapper => true}"> - <body: class="show-page #{type_name.underscore}" param/> + + <body: class="show-page #{type_name :dasherize => true}" param/> + <content-header: param> <if with="&this.dependent_on.reject{|x| x.is_a?(Hobo::User)}.first"> - <div class="container"><a/></div> + <div class="container"><a>&laquo; <name/></a></div> </if> - <heading param><%= this %></heading> + <heading param><this/></heading> + + <div class="flags"><flags/></div> + <creation-details param/> - <do param="dependent-collection-count"><a class="dependent-collection-count" href="##{dependent_collection.to_s.underscore}" part="dependent-collection-count" part-locals="dependent_collection" if="&dependent_collection"><count-dependents/></a></do> - <a action="edit" if="&can_edit?" class="edit">Edit <type-name/></a> + <do field="&primary_collection_name" if="&primary_collection_name" param="primary-collection-count"> + <association-count class="primary-collection-count" part="primary-collection-count"/> + </do> + + <a action="edit" class="edit" if="&linkable?(:edit) && can_edit?" param="edit-link">Edit <type-name/></a> </content-header> <content-body: param> <primary-content param/> - <field-list skip="&[this.class.name_attribute, this.class.primary_content_attribute, this.class.creator_attribute, this.class.dependent_on.first].compact " - skip-associations="has_many" param/> + <field-list skip="&skip_fields" skip-associations="has_many" param/> - <if test="&dependent_collection"> - <section class="dependent-collection" field="&dependent_collection"> - <a name="#{dependent_collection.to_s.underscore}"/> - <h2 param="dependent-collection-title"><%= dependent_collection.to_s.titleize %></h2> + <with-primary-collection name="&primary_collection_name" if="&primary_collection_name"> + <section class="primary-collection"> + <h2 param="primary-collection-title"><primary-collection-name.titleize/></h2> - <do param="collection"> - <collection part="dependent-collection" part-locals="dependent_collection"> - <empty-message:>No <%= dependent_collection.to_s %> have been added yet.</empty-message> + <do param="primary-collection"> + <collection part="primary-collection"> + <card:><delete-button: update="primary-collection-count"></delete-button:></card:> </collection> </do> - - <do with="&new_for_current_user"> - <section class="create-new" if="&!linkable?(:new) && can_create?"> - <h2>Add <A-or-An word="&dependent_collection.to_s.singularize.titleize"/></h2> - <form update="dependent-collection, dependent-collection-count" message="Adding #{dependent_collection.to_s.singularize.titleize}..." reset-form> - <field-list skip="#{@this.class.reverse_reflection(@this.send(dependent_collection).proxy_reflection.name).name}" - skip-associations="has_many" param="dependent-collection-field-list"/> - <submit label="Create #{dependent_collection.to_s.singularize.titleize}"/> - </form> - </section> + + <do with="&@this.send(primary_collection_name)"> + <if test="&can_create?" param="primary-collection-add"> + <nav class="new-link"><a action="new" if="&linkable?(:new) && can_create?"/></nav> + <else> + <section class="create-new" with="&new_for_current_user"> + <h2>Add <A-or-An word="&primary_collection_name.singularize.titleize"/></h2> + <form update="primary-collection, primary-collection-count" + message="Adding #{primary_collection_name.singularize.titleize}..." reset-form> + <field-list skip="#{@this.class.reverse_reflection(@this.send(primary_collection_name).proxy_reflection.name).name}" + skip-associations="has_many" param="primary-collection-field-list"/> + <submit label="Add"/> + </form> + </section> + </else> + </if> </do> </section> - </if> - <else> - <section class="preview-collections"> - <with-fields associations="has_many"> - <section class="#{this_field.dasherize}"> - <h2>Recent <this-field.titleize/></h2> - <collection with="&this.recent"/> - <a class="more">More... (<count/>)</a> - </section> - </with-fields> - </section> - </else> - - <nav class="new-links" param="new-links"> - <ul with="&has_many_assocs"> - <li: replace><li if="&can_create? && linkable?(:new)"><a action="new"/></li></li> - </ul> - </nav> + </with-primary-collection> + </content-body:> + + <aside: param> + <section class="preview-collections"> + <with-fields fields="&non_through_collections - [(primary_collection_name.to_sym unless primary_collection_name.blank?)]"> + <collection-preview class="#{this_field.dasherize}"/> + </with-fields> + </section> + </aside:> - </content-body> </page> </def> <def tag="edit-page"> <page merge> - <body: class="edit-page #{this.class.name.underscore}" param/> + <body: class="edit-page #{type_name :dasherize => true}" param/> <content-header: param> - <heading><if test="&this.respond_to? :name"><name/></if><else><type-name/></else></heading> - <delete-button in-place="&false" label="Remove This #{this.class.name}" param/> + <heading param><if test="&this.respond_to? :name"><name/></if><else><type-name/></else></heading> + <delete-button label="Remove This #{type_name}" param/> </content-header> <content-body: param> <error-messages param/> <form param> - <field-list skip-associations="has_many" param/> + <field-list param/> <div class="actions" param="actions"> <submit label="Save Changes" param/><do param="back-link"> or <a>Cancel</a></do> </div> @@ -209,22 +218,22 @@ <def tag="new-in-collection-page"> - <set association-name="&@association.proxy_reflection.name.to_s.singularize.titleize"/> + <set association-name="&@association.origin_attribute.to_s"/> <page title="New #{type_name}" merge> - <body: class="new-in-collection-page #{type_name(:with => @owner)} #{type_name}" param/> + <body: class="new-in-collection-page #{association_name.underscore.dasherize} #{type_name :dasherize => true}" param/> <content-header: param> - <heading param>New <association-name/></heading> - <sub-heading param>For: <a with="&@owner" /></sub-heading> + <heading param>New <association-name.singularize.titleize/></heading> + <sub-heading param>For: <a with="&@association.origin"/></sub-heading> </content-header> <content-body: param> <error-messages/> <form param> - <field-list skip="#{@owner.class.reverse_reflection(@association.proxy_reflection.name).name}" - skip-associations="has_many" param/> + <field-list skip="#{@association.origin.class.reverse_reflection(association_name.to_sym).name}" param/> <div class="actions" param="actions"> - <submit label="Create #{association_name}" param/><do param="back-link"> or <a with="&@owner">Cancel</a></do> + <submit label="Create #{association_name.singularize.titleize}" param/> + <do param="back-link"> or <a with="&@association.origin">Cancel</a></do> </div> </form> </content-body> @@ -233,14 +242,14 @@ <def tag="show-collection-page"> - <% title = "#{@reflection.name.to_s.titleize} for #{name(:with => @owner)}" %> + <% title = "#{this.origin_attribute.to_s.titleize} for #{name(:with => this.origin)}" %> <page title="&title" merge> - <body: class="show-collection-page #{type_name(:with => @owner)} #{type_name(:pluralize => true)}" + <body: class="show-collection-page #{type_name(:with => this.origin)} #{type_name(:pluralize => true) rescue debugger}" param/> <content-header: param> - <nav>Back to <a with="&@owner"/></nav> + <nav>Back to <a:origin/></nav> <heading><%= title %></heading> - <sub-heading><count with="&@pages.item_count" label="&@reflection.klass.name.titleize"/></sub-heading> + <sub-heading><count/></sub-heading> </content-header> <content-body: param> @@ -250,114 +259,35 @@ <nav param="bottom-pagination-nav"><page-nav param/></nav> - <nav if="&Hobo.simple_has_many_association?(@association)" param="new-link"> - <a to="&@association" action="new"/> + <nav if="&Hobo.simple_has_many_association?(this)" param="new-link"> + <a action="new"/> </nav> </content-body> </page> </def> -<def tag="signup-page"> - <page layout="simple" title="Sign up to #{app_name}" merge> - <body: class="signup-page" param/> - - <live-search: replace/> - <nav: replace/> - - <content-header: param> - <heading param>Sign Up</heading> - </content-header> - - <content-body: param> - <error-messages/> - <form action="&request.request_uri" param> - <field-list fields="login, password, password_confirmation" param> - <password-confirmation-label:>Confirm Password</password-confirmation-label> - </field-list> - - <div class="actions" param="actions"> - <submit label='Sign Up'/> - </div> - </form> - </content-body> - - </page> -</def> - - -<def tag="login-page" attrs="remember-me"> - <page layout="simple" title="Log in to #{app_name}" merge> - - <body: class="login-page" param/> - - <live-search: replace/> - <nav: replace/> - +<def tag="permission-denied-page" attrs="message"> + <% message ||= "That operation is not allowed" %> + <page merge> + <body: class="permission-denied"/> <content-header: param> - <heading param>Log In</heading> + <heading param><message/></heading> </content-header> - - <content-body: param> - <form action="&request.request_uri" class="login" param> - <labelled-item-list> - <labelled-item> - <item-label param="login-label"><%= model.login_attr.to_s.titleize %></item-label> - <item-value><input type="text" name="login" id="login" class="string" param="login-input" /></item-value> - </labelled-item> - - <labelled-item> - <item-label param="password-label">Password</item-label> - <item-value><input type="password" name="password" id="password" class="string" param="password-input"/></item-value> - </labelled-item> - - <labelled-item if="&remember_me"> - <item-label class="field-label" param="remember-me-label">Remember me:</item-label> - <item-value><input type="checkbox" name="remember_me" id="remember-me" param="remember-me-input"/></item-value> - </labelled-item> - </labelled-item-list> - <set user="&Hobo::UserController.user_models.first"/> - <div class="actions" param="actions"> - <submit label='Log in' param/><if test="&signup_url(user)" class='nav-item'> or <a href="&signup_url(user)">Sign up</a></if> - </div> - </form> - </content-body> - </page> -</def> - - -<def tag="account-disabled-page"> - - <page layout="simple" title="#{app_name} - account not available" merge> - - <body: class="account-disabled-page" param/> - - <content-header: param><heading param>Account is not available</heading></content> - - <content-body: param> - <p>Your account is not available at this time.</p> - </content-body> </page> - </def> - -<def tag="permission-denied-page"> +<def tag="not-found-page" attrs="message"> + <% message ||= "The page you were looking for could not be found" %> <page merge> + <body: class="not-found"/> <content-header: param> - <heading param>That operation is not allowed</heading> + <heading param><message/></heading> </content-header> </page> </def> -<def tag="not-found-page"> - <page merge> - <content-header: param> - <heading param>The page you were looking for could not be found</heading> - </content-header> - </page> -</def> <def tag="doctype" attrs="version"><%= case version.upcase @@ -379,6 +309,7 @@ end %></def> + <def tag="stylesheet" attrs="name, media"> <repeat with="&comma_split(name)"> <link href="#{base_url}/stylesheets/#{this}.css" media="#{ media || 'all' }" @@ -386,6 +317,7 @@ </repeat> </def> + <def tag="javascript" attrs="name"> <if test="&name.is_a?(Symbol)"> <%= javascript_include_tag name %> @@ -397,11 +329,13 @@ </else> </def> + <def tag="flash-message" attrs="type"> <% type = type ? type.to_sym : :notice %> <div class="flash #{type}" if="&flash[type]" merge-attrs><%= flash[type] %></div> </def> + <def tag="ajax-progress"> <div id="ajax-progress"> <div> @@ -411,7 +345,15 @@ </def> -<def tag="app-name"><%= @hobo_app_name ||= File.basename(Dir.chdir(RAILS_ROOT) { Dir.getwd }).strip.titleize %></def> - <def tag="default-page-title"><%= t = this.to_s; ; "#{t.blank? ? '' : t + ' - '}#{app_name}" %></def> + +<def tag="with-primary-collection" attrs="name"><% + ivar = "@#{this.class.name.underscore}_#{name}" + + if (collection = instance_variable_get(ivar)) + %><do with="&collection" param="default"/><% + else + %><do field="&name" param="default"/><% + end +%></def> vendor/plugins/hobo/taglibs/rapid_pages.dryml @@ -1,18 +1,19 @@ <def tag="table-plus" attrs="sort-field, sort-direction, sort-columns" > <% sort_field ||= @sort_field; sort_direction ||= @sort_direction; sort_columns ||= {} %> + <% sort_columns['this'] ||= this.member_class.name_attribute %> <div class="table-plus" merge-attrs="&attributes - attrs_for(:with_fields) - attrs_for(:table)"> <div class="header" param="header"> <div class="search"> <form param="search-form" method="get" action=""> <hidden-fields for-query-string skip="page, search_form"/> - Search - <input class="search-field" type="search" name="search" value="&params[:search]"/> + <span>Search</span> + <input class="search" type="search" name="search" value="&params[:search]"/> <submit label="Go" class="search-button" param="search-submit"/> </form> </div> </div> - <table merge-attrs="&attributes & (attrs_for(:table) + attrs_for(:with_fields))" merge-params> + <table merge-attrs="&attributes & (attrs_for(:table) + attrs_for(:with_fields))" empty merge-params> <field-heading-row:> <with-field-names merge-attrs="&all_attributes & attrs_for(:with_fields)"> <% col = sort_columns[scope.field_path] || scope.field_path @@ -32,12 +33,24 @@ <th if="&all_parameters[:controls]" class="controls"/> </field-heading-row> </table> - <else> - <do param="empty-message"/> - </else> + <do param="empty-message" if="empty?"/> - <nav class="page"> + <nav class="page" if="&this.respond_to? :page_count"> <page-nav param/> </nav> </div> </def> + + +<def tag="change-password-form"> + <form class="change-password" param> + <field-list fields="current_password, password, password_confirmation" param> + <password-label:>New Password</password-label:> + <password-confirmation-label:>Confirm New Password</password-confirmation-label:> + </field-list> + + <div class="actions" param="actions"> + <submit label="Change Password" param/> + </div> + </form> +</def> vendor/plugins/hobo/taglibs/rapid_plus.dryml @@ -1,12 +1,13 @@ <def tag="with-fields" attrs="fields, associations, skip, skip-associations, include-timestamps, force-all"><% + fields.nil? || associations.nil? or raise ArgumentError, "with-fields -- specify either fields or associations but not both" + field_names = if associations == "has_many" this.class.reflections.values.select { |refl| refl.macro == :has_many }.map { |refl| refl.name.to_s } elsif fields.nil? || fields == "*" || fields.is_a?(Class) klass = fields.is_a?(Class) ? fields : this.class - columns = klass.content_columns.every(:name) - columns -= %w{created_at updated_at created_on updated_on} unless - include_timestamps + columns = klass.content_columns.*.name + columns -= %w{created_at updated_at created_on updated_on} unless include_timestamps if skip_associations == "has_many" assocs = this.class.reflections.values.reject {|r| r.macro == :has_many }.map &its.name.to_s @@ -22,13 +23,19 @@ end field_names -= comma_split(skip) if skip field_names = field_names.select {|f| can_view?(this, f)} unless force_all - field_names.each do |field| %><with field="&field"><do param="default"/></with><% end + field_names.each do |field| + if field == "this" + %><do param="default"/><% + else + %><with field="&field"><do param="default"/></with><% + end + end %></def> <def tag="with-field-names" attrs="fields, skip, skip-associations, include-timestamps"><%= field_names = if fields.nil? || fields == "*" || fields.is_a?(Class) - klass = fields.is_a?(Class) ? fields : this.proxy_reflectin.class - columns = klass.content_columns.every(:name) + klass = fields.is_a?(Class) ? fields : this.member_class + columns = klass.content_columns.*.name columns -= %w{created_at updated_at created_on updated_on} unless include_timestamps if skip_associations == "has_many" @@ -47,7 +54,7 @@ field_names -= comma_split(skip) if skip scope.new_scope do field_names.map do |n| - scope.field_name = n.to_s.gsub("." , "_") + scope.field_name = n == "this" ? this.member_class.name : n.to_s.gsub("." , "_") scope.field_path = n parameters.default end vendor/plugins/hobo/taglibs/rapid_support.dryml @@ -100,7 +100,7 @@ def fix_file(filename) # happy @src = "<root>" + src + "</root>" begin - doc = REXML::Document.new(Hobo::Dryml::RexSource.new(@src), :dryml_mode => true) + doc = Hobo::Dryml::Parser::Document.new(Hobo::Dryml::Parser::Source.new(@src)) rescue REXML::ParseException => e raise Exception, "File: #{@template_path}\n#{e}" end vendor/plugins/hobo/tasks/fix_dryml.rake @@ -0,0 +1,17 @@ +namespace :hobo do + + desc "Replace commonly used hobo assets with symlinks into the plugin so that they stay up to date" + task :symlink_assets do + + Dir.chdir(RAILS_ROOT) do + Dir.chdir("public/javascripts") do + puts "hobo-rapid.js" + `rm -f hobo-rapid.js` + `ln -s ../../vendor/plugins/hobo/generators/hobo_rapid/templates/hobo-rapid.js` + end + end + + end + +end + vendor/plugins/hobo/tasks/hobo_tasks.rake app/views/taglibs/themes/clean/application.dryml public/hobothemes/clean/stylesheets/hobo.css vendor/plugins/classic_pagination/CHANGELOG vendor/plugins/classic_pagination/README vendor/plugins/classic_pagination/Rakefile vendor/plugins/classic_pagination/init.rb vendor/plugins/classic_pagination/install.rb vendor/plugins/classic_pagination/lib/pagination.rb vendor/plugins/classic_pagination/lib/pagination_helper.rb vendor/plugins/classic_pagination/test/fixtures/companies.yml vendor/plugins/classic_pagination/test/fixtures/company.rb vendor/plugins/classic_pagination/test/fixtures/developer.rb vendor/plugins/classic_pagination/test/fixtures/developers.yml vendor/plugins/classic_pagination/test/fixtures/developers_projects.yml vendor/plugins/classic_pagination/test/fixtures/project.rb vendor/plugins/classic_pagination/test/fixtures/projects.yml vendor/plugins/classic_pagination/test/fixtures/replies.yml vendor/plugins/classic_pagination/test/fixtures/reply.rb vendor/plugins/classic_pagination/test/fixtures/schema.sql vendor/plugins/classic_pagination/test/fixtures/topic.rb vendor/plugins/classic_pagination/test/fixtures/topics.yml vendor/plugins/classic_pagination/test/helper.rb vendor/plugins/classic_pagination/test/pagination_helper_test.rb vendor/plugins/classic_pagination/test/pagination_test.rb vendor/plugins/hobo/generators/hobo_migration/hobo_migration_generator.rb vendor/plugins/hobo/generators/hobo_migration/templates/migration.rb vendor/plugins/hobo/generators/hobo_rapid/templates/themes/clean/public/stylesheets/application.css vendor/plugins/hobo/generators/hobo_rapid/templates/themes/clean/views/application.dryml vendor/plugins/hobo/lib/active_record/table_definition.rb vendor/plugins/hobo/lib/extensions.rb vendor/plugins/hobo/lib/hobo/email_address.rb vendor/plugins/hobo/lib/hobo/enum_string.rb vendor/plugins/hobo/lib/hobo/field_declaration_dsl.rb vendor/plugins/hobo/lib/hobo/field_spec.rb vendor/plugins/hobo/lib/hobo/html_string.rb vendor/plugins/hobo/lib/hobo/lazy_hash.rb vendor/plugins/hobo/lib/hobo/markdown_string.rb vendor/plugins/hobo/lib/hobo/migrations.rb vendor/plugins/hobo/lib/hobo/model_queries.rb vendor/plugins/hobo/lib/hobo/password_string.rb vendor/plugins/hobo/lib/hobo/percentage.rb vendor/plugins/hobo/lib/hobo/predicate_dispatch.rb vendor/plugins/hobo/lib/hobo/proc_binding.rb vendor/plugins/hobo/lib/hobo/text.rb vendor/plugins/hobo/lib/hobo/textile_string.rb vendor/plugins/hobo/lib/hobo/where_fragment.rb vendor/plugins/hobo/lib/rexml.rb 1d074b1ad8d343b703d42925c28999bc6192eef2 Blake Barnett bdb@bdb-debvm1.stanford.edu http://github.com/shadoi/puppetshow/commit/aa14be64d4ede0cc1c531d1bebf1a2f20da71e3d aa14be64d4ede0cc1c531d1bebf1a2f20da71e3d 2008-05-01T18:20:00-07:00 2008-05-01T18:20:00-07:00 Yeah.. so I didn't actually commit all the hobo 0.7.5 changes before, this should do it. 3b4e1516d4457ce663091d29ee9c5672be360e0f Blake Barnett bdb@bdb-debvm1.stanford.edu