hobo_rapid 1.4.0.pre2

data/README.markdown

@@ -0,0 +1,5 @@
+RAPID is the standard Hobo tag library.
+
+#### Note
+
+Many of the tags require a javascript plugin such as hobo_jquery to function.

data/VERSION

@@ -0,0 +1 @@
+1.4.0.pre2

data/app/controllers/dev_controller.rb

@@ -0,0 +1,25 @@
+class DevController < ActionController::Base
+
+  hobo_controller
+
+  before_filter :developer_modes_only
+
+  def set_current_user
+    model = params[:model] || Hobo::Model::UserBase.default_user_model
+    self.current_user = if params[:login]
+                          model.where(model.login_attribute => params[:login]).first
+                        else
+                          model.find(params[:id])
+                        end
+    redirect_to(request.env["HTTP_REFERER"] ? :back : home_page)
+  end
+
+  private
+
+  def developer_modes_only
+    # Belt and braces. In addition to this check, the routes only get
+    # defined when developer_features is true
+    render :text => "Permission Denied", :status => 403 unless Rails.application.config.hobo.developer_features
+  end
+
+end

data/app/helpers/hobo_rapid_helper.rb

@@ -0,0 +1,197 @@
+module HoboRapidHelper
+    AJAX_CALLBACKS = [ :success, :failure, :complete, :before ]
+
+    AJAX_UPDATE_ATTRS = [  :update, :updates, :ajax ]
+
+    AJAX_EFFECT_ATTRS = [ :hide, :show ]
+
+    AJAX_SPINNER_ATTRS = [:spinner_next_to, :spinner_options, :spinner_at, :no_spinner, :message]
+
+    AJAX_PUSHSTATE_ATTRS = [:push_state, :new_title]
+
+    AJAX_ATTRS = AJAX_CALLBACKS + AJAX_UPDATE_ATTRS + AJAX_EFFECT_ATTRS + AJAX_SPINNER_ATTRS + AJAX_PUSHSTATE_ATTRS
+    [:params, :errors_ok,
+     :reset_form, :refocus_form ]
+
+    def app_name(add_subsite=true)
+      an = Rails.application.config.hobo.app_name
+      if add_subsite && subsite
+        subsite_name = t 'hobo.admin.subsite_name', :default => subsite.titleize
+        an = an + " - #{subsite_name}"
+      end
+      an
+    end
+
+    def comma_split(x)
+      case x
+      when nil
+        []
+      when String
+        x.strip.split(/\s*,\s*/)
+      else
+        x.compact.map{|e| comma_split(e)}.flatten
+      end
+    end
+
+    def a_or_an(word)
+      if word =~ /^[aeiouh]/
+        "an #{word}"
+      else
+        "a #{word}"
+      end
+    end
+
+
+    def no_break(s)
+      s = new_context { yield } if block_given?
+      s.gsub(' ', ' ')
+    end
+
+    # returns the number of items in the collection.  See LH #889
+    def collection_count
+      this.try.to_int || this.try.total_entries || (this.try.loaded? && this.try.length) || this.try.count || this.try.length
+    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 non_through_collections(object=this)
+      names = object.class.reflections.values.select do |refl|
+        refl.macro == :has_many
+      end.*.name
+
+      names - through_collection_names
+    end
+
+    def standard_fields(model, include_timestamps=false)
+      fields = model.attr_order.*.to_s & model.content_columns.*.name
+      fields -= %w{created_at updated_at created_on updated_on deleted_at} unless include_timestamps
+      fields.reject! { |f| model.never_show? f }
+      fields
+    end
+
+    def current_time
+      Time.zone ? Time.zone.now : Time.now
+    end
+
+    # provides the meat for hidden-fields for-query-string and anybody
+    # else who wants a list of relevant parameters.   options: :skip, :only
+    def query_parameters_filtered(options = {})
+      query_params = (request.query_parameters | request.request_parameters)
+      if options[:only]
+        query_params = query_params & options[:only]
+      else
+        query_params = query_params - [:render, :render_options, :"_", :page_path, :authenticity_token]
+        if form_field_path
+          query_params = query_params - [form_field_path[0]]
+        end
+      end
+      query_params = query_params - options[:skip] if options[:skip]
+      query_params
+    end
+
+    # this function provides the meat for the form and formlet tags.  It
+    # returns a tuple of:
+    #   body: html body
+    #   html_attrs:  class, id, etc.
+    #   ajax_attrs:  update, spinner-next-to, etc
+    #   form_attrs:  action, method, enctype
+    def form_helper(attributes, parameters)
+      attrs, other_attrs = attributes.partition_hash([:hidden_fields, :action, :method, :web_method, :lifecycle, :owner, :multipart])
+      ajax_attrs, html_attrs = other_attrs.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+      form_attrs = {}
+
+      if html_attrs[:confirm]
+        if ajax_attrs.blank?
+          html_attrs["data-confirm"] = html_attrs.delete(:confirm) # rely on rails_ujs
+        else
+          ajax_attrs[:confirm] = html_attrs.delete(:confirm)
+        end
+      end
+
+      form_attrs[:enctype] = html_attrs[:enctype] if html_attrs[:enctype]
+      form_attrs[:enctype] ||= "multipart/form-data" if attrs[:multipart]
+
+      new_record = self.this.try.new_record?
+
+      method = if attrs[:method].nil?
+                 (attrs[:action] || attrs[:web_method] || new_record) ? "post" : "put"
+               else
+                 attrs[:method].downcase
+               end
+
+      form_attrs[:action] = attrs[:action] ||
+        begin
+          target = if attrs[:owner]
+                     collection_name = this.class.reverse_reflection(attrs[:owner]).name
+                     this.send(attrs[:owner]).send(collection_name)
+                   else
+                     this
+                   end
+          attrs[:action] = attrs[:web_method] || attrs[:lifecycle]
+          object_url(target, attrs[:action], :method => method)
+        end
+
+      if attrs[:action].nil? && (form_attrs[:action].nil? ||
+                                 (attrs[:lifecycle].nil? && new_record && !this.creatable_by?(current_user)) ||
+                                 (attrs[:lifecycle].nil? && !new_record && !can_edit?))
+        Dryml.last_if = false
+        logger.info("unable to render form")
+        return nil
+      else
+        if method == "put" || method == "delete"
+          # browsers don't support put -- use post and add the Rails _method hack
+          http_method_hidden = hidden_field_tag("_method", method.upcase)
+          form_attrs[:method] = "post"
+        else
+          http_method_hidden = ""
+          form_attrs[:method] = method
+        end
+
+        hiddens = ""
+        body = with_form_context do
+          # It is important to evaluate parameters.default first, in order to populate scope.form_field_names
+          b = parameters.default
+          hiddens = self.hidden_fields(:fields => attrs[:hidden_fields]) if new_record
+          b
+        end
+
+        auth_token = if method.nil? || method == 'get' || !protect_against_forgery?
+                       ''
+                     else
+                       element(:input, {:type => "hidden",
+                                 :name => request_forgery_protection_token.to_s,
+                                 :value => form_authenticity_token}, nil, true, true)
+                     end
+
+        unless method == "get"
+          page_path = if (request.post? || request.put? || request.delete?) && params[:page_path]
+                        params[:page_path]
+                      else
+                        request.fullpath
+                      end
+          page_path_hidden = hidden_field_tag("page_path", page_path)
+        end
+
+        hiddens_div = element(:div, {:class => "hidden-fields"}, [http_method_hidden, page_path_hidden, auth_token, hiddens].safe_join)
+
+        body = [hiddens_div, body].safe_join
+
+        if attrs[:action].nil? # don't add automatic css classes if the action was specified
+          if attrs[:web_method]
+            add_classes!(html_attrs, "#{type_id.dasherize}-#{web_method}-form")
+          else
+            add_classes!(html_attrs, "#{'new ' if new_record}#{type_id.dasherize}")
+          end
+        end
+
+        Dryml.last_if = true
+        [body, html_attrs, ajax_attrs, form_attrs]
+      end
+    end
+
+end

data/hobo_rapid.gemspec

@@ -0,0 +1,26 @@
+name = File.basename( __FILE__, '.gemspec' )
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+require 'date'
+
+Gem::Specification.new do |s|
+
+  s.authors = ['Tom Locke, Bryan Larsen']
+  s.email = 'tom@tomlocke.com'
+  s.homepage = 'http://hobocentral.net'
+  s.rubyforge_project = 'hobo'
+  s.summary = 'The RAPID tag library for Hobo'
+  s.description = 'The RAPID tag library for Hobo'
+
+  s.add_runtime_dependency('hobo', ["= #{version}"])
+
+  s.files = `git ls-files -x #{name}/* -z`.split("\0")
+
+  s.name = name
+  s.version = version
+  s.date = Date.today.to_s
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib", "vendor"]
+
+end

data/lib/hobo_rapid/railtie.rb

@@ -0,0 +1,6 @@
+require 'hobo_rapid'
+require 'rails'
+module HoboRapid
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/hobo_rapid.rb

@@ -0,0 +1,13 @@
+module HoboRapid
+
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
+  @@root = Pathname.new File.expand_path('../..', __FILE__)
+  def self.root; @@root; end
+
+  EDIT_LINK_BASE = "https://github.com/tablatom/hobo_tree_table/edit/master/hobo_rapid"
+
+  require 'hobo_rapid/railtie' if defined?(Rails)
+
+  class Engine < ::Rails::Engine
+  end
+end

data/taglibs/buttons/buttons.dryml

@@ -0,0 +1 @@
+<!-- Buttons that do stuff. -->

data/taglibs/buttons/create_button.dryml

@@ -0,0 +1,40 @@
+<!-- Provides an ajax create button that will send a RESTful "POST" to the server to create a new resource.
+
+All of the standard ajax attributes are supported (see the main taglib documention for Rapid Forms).
+
+### Attributes
+
+ - model: The class to instantiate, pass either the class name or the class object.
+
+ -->
+<def tag="create-button" attrs="model, update, label, fields, message"><%=
+  raise Hobo::Error.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)
+                     id_method = this_field_reflection.options[:primary_key] || this_field_reflection.klass.primary_key
+                     fields[this_field_reflection.foreign_key] = this.proxy_owner.send(id_method)
+                     this
+                   else
+                     raise Hobo::Error.new("invalid context for <create-button>")
+                   end
+  new = class_or_assoc.new(fields)
+  new.set_creator(current_user)
+  if can_create?(new)
+    label ||= ht("#{new.class.to_s.underscore}.actions.new", :default=>"New #{new.class.model_name.human}")
+    class_name = new.class.name.underscore
+    params ||= params || {}
+    params = params.merge(class_name => fields) unless fields.blank?
+
+    ajax_attributes, html_attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+
+    ajax_attributes.reverse_merge!(:message => message, :params => params)
+    func = ajax_updater(object_url(new.class, :method => :post), update, ajax_attributes)
+    html_attributes.reverse_merge!(:type =>'button', :onclick => func, :value => label)
+
+    element :input, add_classes(html_attributes,
+                                "button create-button create-#{class_name}-button"), nil, true, true
+  end
+%></def>

data/taglibs/buttons/delete-button.dryml

@@ -0,0 +1,75 @@
+<!-- Provides either an ajax or non-ajax delete button to send a
+     RESTful "DELETE". The context should be a record for which you to
+     want provide a delete button.
+
+There are three possible types of `delete-button` created.
+
+### Non-Ajax
+
+No Ajax is used if
+
+ - the `update`, `updates` and `ajax` attributes are not set AND EITHER
+ - `in-place` is explicitly set false OR
+ - the context for the delete is the same as the top-level context for the page.   In other words, if you're trying to delete the entire page.
+
+### Standard form Ajax
+
+If you set the `update`, `updates` or `ajax` attributes, standard form/part AJAX is used.   It's assumed that the part you're specifying includes the item to be deleted so that it will be removed from the page by the update.
+
+### "Magic" Ajax
+
+If:
+
+ - the `update`, `updates` and `ajax` attributes are not set AND EITHER
+ - `in-place` is explicitly set true OR
+ - the context for the delete is not the same as the top-level context for the page.   In other words, if you're not trying to delete the entire page.
+
+then `delete-button` performs an Ajax delete and then attempts to fix up the page.   It does this by removing all items on the page that have their hobo-rapid-context set to the item being deleted.   If said deletion results in an empty list, it shows the `.empty-collection-message`.   This procedure should work with `<collection>`, `<table>` and their children (`<sortable-collection>`, `<table-plus>`, etc.).
+
+### Attributes
+
+All the standard ajax attributes *except the callbacks* are supported (see the main taglib documention for Rapid Forms).
+
+ - label: The label for the button. Default: "Remove".  (Alternately, use the hobo.actions.remove translation to customize)
+
+ - in-place: see above
+
+ - image: URL of an image for the button.
+
+ - fade: Perform the fade effect (true/false)? Default: true
+
+ - confirm: has a default value of "Are you sure?" or hobo.messages.confirm translated.  You must explicitly set this to false if you don't want a confirm message.
+
+  -->
+<def tag="delete-button" attrs="label, in-place, image, confirm, fade, subsite"><%
+  url = object_url(this, :method => :delete, :subsite => subsite)
+  if url && can_delete?
+    in_place = !(this == @this && request.method.downcase == "get") if in_place.nil?
+    update_attrs, attributes = attributes.partition_hash(HoboRapidHelper::AJAX_UPDATE_ATTRS)
+    ajax_attrs, attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+    attributes[src] = "#{base_url}/images/#{image}" if image
+    label ||= t("hobo.actions.remove", :default=>"Remove")
+    confirm = t("hobo.messages.confirm", :default=>"Are you sure?") if confirm.nil?
+    ajax_attrs[:confirm] = confirm if confirm
+
+    add_classes!(attributes,
+                 image ? "image-button" : "button",
+                 "delete-button delete-#{this.class.name.underscore.dasherize}-button")
+
+    if in_place && update_attrs.blank?
+      data_rapid = data_rapid(:delete_button)
+      ajax_attrs[:update] ||= ""   # force form ajax
+    elsif !update_attrs.blank?
+      ajax_attrs.merge!(update_attrs)
+      data_rapid = nil
+    else
+      data_rapid = nil
+    end
+  end
+%>
+  <if test="&url && can_delete?">
+    <form method="delete" action="&url" class="button_to" merge-attrs="&ajax_attrs" data-rapid="&data_rapid" data-rapid-context="&typed_id">
+      <input type="submit" value="&label" merge/>
+    </form>
+  </if>
+</def>

data/taglibs/buttons/remote_method_button.dryml

@@ -0,0 +1,34 @@
+<!-- Provides either an ajax or non-ajax button to invoke a "remote method" or "web method" declared in the controller.
+Web Methods provide support for the RPC model of client-server interaction, in contrast to the REST model. The
+preference in Rails is to use REST as much as possible, but we are pragmatists, and sometimes you just to need a remote
+procedure call.
+
+The URL that the call is POSTed to is the `object_url` of `this`, plus the method name
+
+`<remote-method-button>` supports all of the standard ajax attributes (see the main taglib documention for Rapid
+Forms). If any ajax attributes are given, the button becomes an ajax button, if not, Rails' `button_to` is used, which behaves similarly to a standard link.
+
+### Attributes
+
+ - method: the name of the web-method to call
+
+ - label: the label on the button
+
+ -->
+<def tag="remote-method-button" attrs="method, update, label, confirm, url"><%=
+  ajax_attributes, html_attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+
+  url ||= object_url(this, method.to_s.gsub('-', '_'), :method => :post)
+  raise ArgumentError, "no such web method '#{method}' on #{this.typed_id}" unless url
+
+  add_classes!(html_attributes, "button remote-method-button #{method}-button")
+  label ||= method.titleize
+  if update || !ajax_attributes.empty?
+    ajax_attributes[:message] ||= label
+    func = ajax_updater(url, update, ajax_attributes.merge(:confirm => confirm))
+    html_attributes.update(:onclick => "var e = this; " + func, :type =>'button', :value => label)
+    element(:input, html_attributes, nil, true, true)
+  else
+    button_to(label, url, html_attributes.merge(:confirm => confirm))
+  end
+%></def>

data/taglibs/buttons/transition_button.dryml

@@ -0,0 +1,71 @@
+<!-- A push-button to invoke a lifecycle transition either as a page-reload or as an ajax call.
+
+### Attributes
+
+ - `transition` - the name of the transition to invoke. Required
+ - `update` - one or more DOM IDs of ajax parts to update after the transition
+ - `label` - the label on the button. Defaults to the name of the transition
+
+All of the [standard ajax attributes](/api_taglibs/rapid_forms) are also supported.
+
+### Warning
+
+Transitions with parameters are implemented using a form.  HTML does not allow forms to be nested, so a transitions with parameters should not be placed inside of a form.
+
+### Invalid transitions
+
+If the transition could not be found, the user does not have permissions for the transition or the object is not in the correct state for the transition, the transition-button displays nothing.  You can use an `<else>` to display an appropriate message.
+
+     <transition-button transition="mogrify"/><else>Cannot mogrify</else>
+
+  -->
+<def tag="transition-button" attrs="transition, update, label"><%=
+    if transition.is_a?(String)
+      transition = this.lifecycle.find_transition(transition, current_user)
+    end
+    if transition.nil?
+      Dryml.last_if = false
+      return ""
+    end
+    transition_name = transition.name
+    has_params = !transition.options[:params].blank?
+    ajax_attributes, html_attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+
+    html_attributes[:method] ||= has_params ? :get : :put
+    add_classes!(html_attributes, "transition-button #{transition_name}-button")
+    label = t("activerecord.attributes.#{this.class.to_s.underscore}.lifecycle.transitions.#{transition_name}", :default => (label || transition_name.to_s.titleize))
+    title = t("activerecord.attribute_help.#{this.class.to_s.underscore}.lifecycle.transitions.#{transition_name}")
+    html_attributes.update(:title => title) unless title.empty? 
+    url = object_url(this, transition_name, :method => html_attributes[:method])
+
+    if (update || !ajax_attributes.empty?) && !has_params
+      ajax_attributes[:message] ||= label
+      ajax_attributes[:method] = html_attributes[:method]
+      func = ajax_updater(url, update, ajax_attributes)
+      html_attributes.update(:onclick => "var e = this; " + func, :type =>'button', :value => label)
+      element(:input, html_attributes, nil, true, true)
+    else
+      button_to(label, url, html_attributes)
+    end
+  %>
+</def>
+
+<!-- Renders a div containing transition buttons for every transition available to the current user.
+
+For example, you could use this on a `Friendship` card: the person invited to have friendship would automatically see 'Accept' and 'Decline' buttons, while the person initiating the invite would see 'Retract'.
+
+This tag behaves similarly to repeat: an else tag may be used to handle the case of no buttons:
+
+    <transition-buttons/><else>Sorry, no buttons to press.</else>
+  -->
+<def tag="transition-buttons">
+  <% ajax_attrs, html_attrs = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS) %>
+  <div merge-attrs="&html_attrs" class="transitions">
+    <% transitions = this.lifecycle.publishable_transitions_for(current_user) %>
+    <if test="&transitions">
+      <% transitions.each do |t| %>
+        <transition-button merge-attrs="&ajax_attrs" transition="&t"/>
+      <% end %>
+    </if>
+  </div>
+</def>

data/taglibs/buttons/transition_link.dryml

@@ -0,0 +1,22 @@
+<!-- Displays a link to a lifecycle transition page if the transition is valid.  If the transition is valid, this is equivalent to:
+
+    <a action="&transition" ...
+
+If the transition is invalid, you may use the `<else>` tag to display an appropriate message:
+
+    <transition-link transition="mogrify">Mogrify</transition-link>
+    <else>Cannot mogrify</else>
+
+### Attributes
+
+All attributes and parameters for the `<a>` tag are also valid.
+
+ - `transition` - the name of the transition to invoke. Required
+  -->
+<def tag="transition-link" attrs="transition"><%
+    trans = this.lifecycle.find_transition(transition, current_user) %>
+    <if test="&trans">
+      <a action="&transition" merge/>
+    </if>
+</def>
+

data/taglibs/buttons/update_button.dryml

@@ -0,0 +1,29 @@
+<!-- Provides an ajax button to send a RESTful update or "PUT" to the server. i.e. to udate one or more fields of a
+record.
+
+Note that unlike simliar tags, `<update-button>` does not support both ajax and non-ajax modes at this time. It only
+does ajax.
+
+`<update-button>` supports all of the standard ajax attributes (see the main taglib documention for Rapid Forms).
+
+### Attributes
+
+ - label: The label on the button.
+
+ - fields: A hash with new field values pairs to update the resource with. The items in the hash will be converted to
+   HTTP parameters.
+
+ - params: Another hash with additional HTTP parameters to include in the ajax request
+
+  -->
+<def tag="update-button" attrs="label, update, fields, params"><%=
+   raise Hobo::Error.new("no update specified") unless update
+
+   ajax_attributes, html_attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
+   params = (params || {}).merge(this.class.name.underscore => fields)
+   ajax_attributes.reverse_merge!(:message => label, :params => params, :method => :put)
+   func = ajax_updater(object_url(this), update, ajax_attributes)
+   html_attributes.reverse_merge!(:type =>'button', :onclick => func, :value => label)
+
+   element :input, add_classes(html_attributes, "button update-button update-#{this.class.name.underscore}-button"), nil, true, true %>
+</def>

data/taglibs/cache/cache.dryml

@@ -0,0 +1 @@
+<!-- Tags for caching -->