hobo 1.3.3 → 1.4.0.pre2

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rake'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rake/testtask'
 require 'tmpdir'
 
@@ -9,13 +9,16 @@ $:.unshift File.expand_path('../lib', __FILE__)
 $:.unshift File.expand_path('../../hobo_support/lib', __FILE__)
 $:.unshift File.expand_path('../../hobo_fields/lib', __FILE__)
 $:.unshift File.expand_path('../../dryml/lib', __FILE__)
+
 require 'hobo'
 
+include Rake::DSL
+
 RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
 RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
 
 GEM_ROOT = File.expand_path('../', __FILE__)
-TESTAPP_PATH = File.join Dir.tmpdir, 'hobo_testapp'
+TESTAPP_PATH = ENV['TESTAPP_PATH'] || File.join(Dir.tmpdir, 'hobo_testapp')
 BIN = File.expand_path('../bin/hobo', __FILE__)
 require 'hobo_support/common_tasks'
 include HoboSupport::CommonTasks
@@ -37,9 +40,16 @@ Rake::TestTask.new(:test) { |t|
 namespace "test" do
   desc "Run the doctests"
   task :doctest do |t|
-    files=Dir['doctests/**/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
+    files=Dir['test/doctest/**/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
     exit(1) if !system("#{RUBYDOCTEST} #{files}")
   end
+
+  desc "Run the irt tests"
+  task :irt => :prepare_testapp do |t|
+    chdir TESTAPP_PATH
+    sh %(irt #{File.expand_path('.',GEM_ROOT)})
+  end
+
 end
 
 # --- RDoc --- #

data/TODO-1.4.txt

@@ -0,0 +1,69 @@
+# TODO
+
+## regressions
+
+ * after-submit, sortable-input-many and name-many do not work
+ * Hobo 1.4 breaks default_scope.  If you're setting the order, you
+   can use Hobo's set_default_order as a stopgap although once it's
+   fixed please switch back to default_scope as set_default_order
+   is deprecated.
+ * remote-method-button, create-button, update-button,
+   transition-button: normal usages of these tags work, but they do
+   not work if you ask them to do AJAX
+ * live-search works, but it's not 'live'.  You have to press return
+   to start the search
+ * remove-button, remote-method-button, create-button & update-button
+   used to display inline but now display as a block.   In other
+   words, they now display one per line rather than several in a
+   single line.
+ * the rapid_summary tags have been moved out
+   of core Hobo into their own plugin,
+   https://github.com/Hobo/hobo_summary, which is not yet in a working state
+
+## documentation
+
+ * document themes/plugins
+ * FAQ
+ * agility
+ * admin subsite
+ * books
+ * ajax manual section
+
+## Cookbook
+
+ * captcha
+ * search
+ * actually use Hobo 1.4's new caching abilities
+ * auto-link tags in manual
+ * create fakedef manual entries for DRYML tags not in taglibs entry
+
+## new features that aren't "done"
+
+ * create_response: mirror update_response
+ * taglib cleanup
+ * clean_sidemenu -> plugin
+ * nested-cache: csrf workaround
+ * nested-cache: enhanced sweeper version
+ * monkey patch will_paginate if my patches are not upstreamed
+
+It's quite likely that some of the new tag definitions are missing
+useful id, class, merge or param attributes.  This doesn't impact core
+functionality, but it does limit your ability to extend the tags.  If
+you notice any such omissions, please let us know, it is easy to fix..
+
+## stuff that we really want to do
+
+ * fixup deprecation warnings
+ * port to Rails 3.2 and/or 4.0
+ * nuke any remaining prototype code
+ * add a sane default for non-AJAX JSON requests.
+ * trawl the lighthouse && pull requests
+ * steal the tags from Portal
+ * fixup hobo-contrib
+
+## would be nice:
+
+ * parametrize the clean theme
+ * create a bootstrap theme
+ * add theme chooser to setup wizard
+ * add support for has-one

data/VERSION

@@ -1 +1 @@
-1.3.3
+1.4.0.pre2

data/app/helpers/hobo_debug_helper.rb

@@ -0,0 +1,16 @@
+module HoboDebugHelper
+  extend HoboHelperBase
+  protected
+    def abort_with(*args)
+      raise args.*.pretty_inspect.join("-------\n")
+    end
+
+    def log_debug(*args)
+      return if not logger
+      logger.debug("\n### DRYML Debug ###")
+      logger.debug(args.*.pretty_inspect.join("-------\n"))
+      logger.debug("DRYML THIS = #{this.typed_id rescue this.inspect}")
+      logger.debug("###################\n")
+      args.first unless args.empty?
+    end
+end

data/app/helpers/hobo_deprecated_helper.rb

@@ -0,0 +1,45 @@
+# as far as I can tell, these functions are no longer used.   It's
+# theoretically possible that they are used in user apps somewhere,
+# but unlikely
+module HoboDeprecatedHelper
+  if Rails.application.config.hobo.include_deprecated_helper
+    protected
+    def uid
+      @hobo_uid ||= 0
+      @hobo_uid += 1
+    end
+
+    def update_elements_class(updates)
+      'update::'+comma_split(updates).join(':') unless updates.blank?
+    end
+
+    def js_str(s)
+      if s.is_a? Hobo::RawJs
+        s.to_s
+      else
+        "'" + s.to_s.gsub("'"){"\\'"} + "'"
+      end
+    end
+
+
+    def make_params_js(*args)
+      ("'" + make_params(*args) + "'").sub(/ \+ ''$/,'')
+    end
+
+
+    def nl_to_br(s)
+      s.to_s.gsub("\n", "<br/>") if s
+    end
+
+    def transpose_with_field(field, collection=nil)
+      collection ||= this
+      matrix = collection.map {|obj| obj.send(field) }
+      max_length = matrix.*.length.max
+      matrix = matrix.map do |a|
+        a + [nil] * (max_length - a.length)
+      end
+      matrix.transpose
+    end
+
+  end
+end

data/app/helpers/hobo_helper_base.rb

@@ -0,0 +1,8 @@
+module HoboHelperBase
+
+    def add_to_controller(controller)
+      controller.send(:include, self)
+      controller.hide_action(self.instance_methods)
+    end
+
+end

data/app/helpers/hobo_permissions_helper.rb

@@ -0,0 +1,136 @@
+module HoboPermissionsHelper
+  extend HoboHelperBase
+  protected
+
+    def current_user
+      # simple one-hit-per-request cache
+      @current_user ||= begin
+                          id = session._?[:user]
+                          (id && Hobo::Model.find_by_typed_id(id) rescue nil) || ::Guest.new
+                        end
+    end
+
+
+    def logged_in?
+      !current_user.guest?
+    end
+
+
+    def can_create?(object=this)
+      if object.is_a?(Class) and object < ActiveRecord::Base
+        object = object.new
+      elsif (refl = object.try.proxy_reflection) && refl.macro == :has_many
+        if Hobo.simple_has_many_association?(object)
+          object = object.new
+          object.set_creator(current_user)
+        else
+          return false
+        end
+      end
+      object.creatable_by?(current_user)
+    end
+
+
+    def can_update?(object=this)
+      object.updatable_by?(current_user)
+    end
+
+
+    def can_edit?(*args)
+      object, field = if args.empty?
+                        if this.respond_to?(:editable_by?) && !this_field_reflection
+                          [this, nil]
+                        elsif this_parent && this_field
+                          [this_parent, this_field]
+                        else
+                          [this, nil]
+                        end
+                      elsif args.length == 2
+                        args
+                      else
+                        [this, args.first]
+                      end
+
+      if !field && (origin = object.try.origin)
+        object, field = origin, object.origin_attribute
+      end
+
+      object.editable_by?(current_user, field)
+    end
+
+
+    def can_delete?(object=this)
+      object.destroyable_by?(current_user)
+    end
+
+
+
+    def can_call?(*args)
+      method = args.last
+      object = args.length == 2 ? args.first : this
+
+      object.method_callable_by?(current_user, method)
+    end
+
+
+    # can_view? has special behaviour if it's passed a class or an
+    # association-proxy -- it instantiates the class, or creates a new
+    # instance "in" the association, and tests the permission of this
+    # object. This means the permission methods in models can't rely
+    # on the instance being properly initialised.  But it's important
+    # that it works like this because, in the case of an association
+    # proxy, we don't want to loose the information that the object
+    # belongs_to the proxy owner.
+    def can_view?(*args)
+      # TODO: Man does this need a big cleanup!
+
+      if args.empty?
+        # if we're repeating over an array, this_field ends up with the current index. Is this useful to anybody?
+        if this_parent && this_field && !this_field.is_a?(Integer)
+          object = this_parent
+          field = this_field
+        else
+          object = this
+        end
+      elsif args.first.is_one_of?(String, Symbol)
+        object = this
+        field  = args.first
+      else
+        object, field = args
+      end
+
+      if field
+        # Field can be a dot separated path
+        if field.is_a?(String) && (path = field.split(".")).length > 1
+          _, _, object = Dryml.get_field_path(object, path[0..-2])
+          field = path.last
+        end
+      elsif (origin = object.try.origin)
+        object, field = origin, object.origin_attribute
+      end
+
+      @can_view_cache ||= {}
+      @can_view_cache[ [object, field] ] ||=
+        if !object.respond_to?(:viewable_by?)
+          true
+        elsif object.viewable_by?(current_user, field)
+          # If possible, we also check if the current *value* of the field is viewable
+          if field.is_one_of?(Symbol, String) && (v = object.send(field)) && v.respond_to?(:viewable_by?)
+            if v.is_a?(Array)
+              v.new_candidate.viewable_by?(current_user, nil)
+            else
+              v.viewable_by?(current_user, nil)
+            end
+          else
+            true
+          end
+        else
+          false
+        end
+    end
+
+
+    def select_viewable(collection=this)
+      collection.select {|x| can_view?(x)}
+    end
+end

data/app/helpers/hobo_route_helper.rb

@@ -0,0 +1,196 @@
+module HoboRouteHelper
+  extend HoboHelperBase
+  protected
+    def base_url
+      "#{Rails.application.config.action_controller.relative_url_root}"
+    end
+
+    def controller_for(obj)
+      if obj.is_a? Class
+        obj.name.underscore.pluralize
+      else
+        obj.class.name.underscore.pluralize
+      end
+    end
+
+
+    def subsite
+      params[:controller]._?.match(/([^\/]+)\//)._?[1]
+    end
+
+    IMPLICIT_ACTIONS = [:index, :show, :create, :update, :destroy]
+
+    def object_url(obj, *args)
+      params = args.extract_options!
+      action = args.first._?.to_sym
+      options, params = params.partition_hash([:subsite, :method, :format])
+      options[:subsite] ||= self.subsite
+      subsite, method = options.get :subsite, :method
+
+      if obj.respond_to?(:member_class) && obj.respond_to?(:origin) && obj.origin
+        # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
+
+        refl = obj.origin.class.reverse_reflection(obj.origin_attribute)
+        owner_name = refl.name.to_s
+        owner_name = owner_name.singularize if refl.macro == :has_many
+        if action == :new
+          action_path = "#{obj.origin_attribute}/new"
+          action = :"new_for_#{owner_name}"
+        elsif action.nil?
+          action_path = obj.origin_attribute
+          if method.to_s == 'post'
+            action = :"create_for_#{owner_name}"
+          else
+O            action = :"index_for_#{owner_name}"
+          end
+        end
+        klass = obj.member_class
+        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
+
+        if options[:method].to_s == 'post' && obj.try.new_record?
+          # Asking for url to post new record to
+          obj = obj.class
+        end
+
+        klass = if obj.is_a?(Class)
+                  obj
+                elsif obj.respond_to?(:member_class)
+                  obj.member_class # We get here if we're passed a scoped class
+                else
+                  obj.class
+                end
+      end
+
+      if Hobo::Routes.linkable?(klass, action, options)
+
+        url = base_url_for(obj, subsite, action)
+        url += "/#{action_path || action}" unless action.in?(IMPLICIT_ACTIONS)
+
+        params = make_params(params)
+        params.blank? ? url : "#{url}?#{params}"
+      end
+    end
+
+
+    def linkable?(*args)
+      options = args.extract_options!
+      target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
+      action = args.first
+      return false if action.nil? && target.try.new_record?
+
+      if target.respond_to?(:member_class) && (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
+      else
+        klass = target.class
+        action ||= :show
+      end
+
+      Hobo::Routes.linkable?(klass, action, options.reverse_merge(:subsite => subsite))
+    end
+
+    def base_url_for(object, subsite, action)
+      path = object.to_url_path or Hobo::Error.new("cannot create url for #{object.inspect} (#{object.class})")
+      "#{base_url}#{'/' + subsite unless subsite.blank?}/#{path}"
+    end
+
+
+    def recognize_page_path
+      # round tripping params through the router will remove
+      # unnecessary params
+      Rails.application.routes.recognize_path(params[:page_path] || url_for(params))
+    end
+
+    def url_for_page_path(options={})
+      url_for recognize_page_path.merge(options)
+    end
+
+    def controller_action_from_page_path
+      recognize_page_path.values_at(:controller,:action)
+    end
+
+    def defined_route?(r)
+      @view.respond_to?("#{r}_url")
+    end
+
+    def _as_params(name, obj)
+      if obj.is_a? Array
+        obj.map {|x| _as_params("#{name}[]", x)}.join("&")
+      elsif obj.is_a? Hash
+        obj.map {|k,v| _as_params("#{name}[#{k}]", v)}.join("&")
+      elsif obj.is_a? Hobo::RawJs
+        "#{name}=' + #{obj} + '"
+      else
+        v = if obj.is_one_of?(ActiveRecord::Base, Array)
+              "@" + typed_id(obj)
+            else
+              obj.to_s.gsub("'"){"\\'"}
+            end
+        "#{name}=#{v}"
+      end
+    end
+
+    def make_params(*hashes)
+      hash = {}
+      hashes.each {|h| hash.update(h) if h}
+      hash.map {|k,v| _as_params(k, v)}.join("&")
+    end
+
+    def current_page_url
+      request.fullpath.match(/^([^?]*)/)._?[1]
+    end
+
+    # Login url for a given user record or user class
+    def forgot_password_url(user_class=Hobo::Model::UserBase.default_user_model)
+      send("#{user_class.name.underscore}_forgot_password_url") rescue nil
+    end
+
+
+    # Login url for a given user record or user class
+    def login_url(user_class=Hobo::Model::UserBase.default_user_model)
+      send("#{user_class.name.underscore}_login_url") rescue nil
+    end
+
+
+    # Sign-up url for a given user record or user class
+    def signup_url(user_class=Hobo::Model::UserBase.default_user_model)
+      send("#{user_class.name.underscore}_signup_url") rescue nil
+    end
+
+
+    # Login url for a given user record or user class
+    def logout_url(user_or_class=nil)
+      c = if user_or_class.nil?
+            current_user.class
+          elsif user_or_class.is_a?(Class)
+            user_or_class
+          else
+            user_or_class.class
+          end
+      send("#{c.name.underscore}_logout_url") rescue nil
+    end
+
+    def new_for_current_user(model_or_assoc=nil)
+      model_or_assoc ||= this
+      if model_or_assoc.respond_to?(:new_candidate)
+        model_or_assoc.user_new_candidate(current_user)
+      else
+        model_or_assoc.user_new(current_user)
+      end
+    end
+
+end