hobo 0.5.3

data/hobo_files/plugin/lib/extensions.rb

@@ -0,0 +1,245 @@
+module Kernel
+  
+  def extract_options_from_args!(args) #:nodoc:
+    args.last.is_a?(Hash) ? args.pop : {}
+  end
+
+end
+
+class Object
+
+  def in?(array)
+    array.include?(self)
+  end
+
+  def not_in?(array)
+    not array.include?(self)
+  end
+  
+  alias_method :is_a_without_multiple_args?, :is_a?
+  def is_a?(*args)
+    args.any? {|a| is_a_without_multiple_args?(a) }
+  end
+  
+  # metaid
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+end
+
+
+class Module
+  
+  def inheriting_attr_accessor(*names)
+    for name in names
+      class_eval %{
+        def #{name}
+          if defined? @#{name}
+            @#{name}
+          elsif superclass.respond_to?('#{name}')
+            superclass.#{name}
+          end
+        end
+      }
+    end
+  end
+  
+  # Custom alias_method_chain that won't cause inifinite recursion if
+  # called twice.
+  # Calling alias_method_chain on alias_method_chain
+  # was just way to confusing, so I copied it :-/
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    without = "#{aliased_target}_without_#{feature}#{punctuation}"
+    unless without.in?(instance_methods)
+      alias_method without, target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+  end
+
+  
+  # Fix delegate so it doesn't go bang if 'to' is nil
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{method}(*args, &block)
+          (_to = #{to}) && _to.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+
+
+end
+
+module Enumerable
+
+  def omap(method = nil, &b)
+    if method
+      map(&method)
+    else
+      map {|x| x.instance_eval(&b)}
+    end
+  end
+
+  def oselect(method = nil, &b)
+    if method
+      select(&method)
+    else
+      select {|x| x.instance_eval(&b)}
+    end
+  end
+
+  def ofind(method=nil, &b)
+    if method
+      find(&method)
+    else
+      find {|x| x.instance_eval(&b)}
+    end
+  end
+
+  def search(not_found=nil)
+    each do |x|
+      val = yield(x)
+      return val if val
+    end
+    not_found
+  end
+
+  def oany?(method=nil, &b)
+    if method
+      any?(&method)
+    else
+      any? {|x| x.instance_eval(&b)}
+    end
+  end
+
+  def oall?(method=nil, &b)
+    if method
+      all?(&method)
+    else
+      all? {|x| x.instance_eval(&b)}
+    end
+  end
+
+  def every(proc)
+    map(&proc)
+  end
+  
+  def map_with_index
+    res = []
+    each_with_index {|x, i| res << yield(x, i)}
+    res
+  end
+
+end
+
+class Hash
+
+  def self.build(array)
+    array.inject({}) do |res, x|
+      k, v = yield x
+      res[k] = v
+      res
+    end
+  end
+
+  def select_hash(new_keys=nil)
+    res = {}
+    if block_given?
+      each {|k,v| res[k] = v if yield(k,v) }
+    else
+      new_keys.each {|k| res[k] = self[k] if self.has_key?(k)}
+    end
+    res
+  end
+  
+  def map_hash
+    res = {}
+    each {|k,v| res[k] = yield(k,v) }
+    res
+  end
+
+  #alias_method :hobo_original_reject, :reject
+  def rejectX(keys=nil, &b)
+    if b
+      hobo_original_reject(&b)
+    else
+      res = {}.update(self) # can't use dup because it breaks with symbols
+      keys.each {|k| res.delete(k)}
+      res
+    end
+  end
+
+  def partition_hash(keys=nil)
+    yes = {}
+    no = {}
+    each do |k,v|
+      if block_given? ? yield(k,v) : keys.include?(k)
+        yes[k] = v
+      else
+        no[k] = v
+      end
+    end
+    [yes, no]
+  end
+  
+end
+
+class <<ActiveRecord::Base
+  alias_method :[], :find
+end
+
+
+# --- Fix Chronic - can't parse '12th Jan' --- #
+begin
+  require 'chronic'
+  
+  module Chronic
+    
+    class << self
+      def parse_with_hobo_fix(s)
+        parse_without_hobo_fix(if s =~ /^\s*\d+\s*(st|nd|rd|th)\s+[a-zA-Z]+(\s+\d+)?\s*$/
+                                 s.sub(/\s*\d+(st|nd|rd|th)/) {|s| s[0..-3]}
+                               else
+                                 s
+                               end)
+      end
+      alias_method_chain :parse, :hobo_fix
+    end
+  end
+rescue MissingSourceFile; end
+
+
+
+# --- Fix pp dumps - these break sometimes without this --- #
+require 'pp'
+module PP::ObjectMixin
+
+  alias_method :orig_pretty_print, :pretty_print
+  def pretty_print(q)
+    orig_pretty_print(q)
+  rescue
+    "[#PP-ERROR#]"
+  end
+
+end
+

data/hobo_files/plugin/lib/extensions/test_case.rb

@@ -0,0 +1,130 @@
+
+class Test::Unit::TestCase
+
+  def self.fixture_objects(model, *names)
+    fixtures model
+    names.each do |name|
+      class_eval "def #{name}; #{model}(:#{name}); end"
+    end
+  end
+  
+  protected
+
+  module HoboTesting
+
+    class HoboHelpers
+      include Hobo::ControllerHelpers
+      
+      def urlb
+        "http://example.com"
+      end
+    end
+    
+    attr_reader :current_user
+
+    def is_redirected_to(x)
+      url = x.is_a?(String) ? x : object_url(x)
+      assert_response :redirect
+      assert_redirected_to(url)
+      follow_redirect!
+      assert_response :success
+    end
+
+    def logs_in_as(user, password)
+      @current_user = user
+      post login_url, :login => user.login, :password => password
+      assert_response :redirect, "#{user.login} failed to log in"
+      get homepage_url
+      assert_response :success
+    end
+
+    def visits(obj, action=nil, params={})
+      get object_url(obj, action, params)
+      assert_response :success
+    end
+    
+    def cant_visit(obj, action=nil)
+      get object_url(obj, action)
+      assert_response :forbidden
+    end
+    
+    def creates(klass, params)
+      replace_objects_in_params!(params)
+      post object_url(klass), klass.name.underscore => params
+      new_obj = assigns["this"]
+      flunk "validation errors: #{new_obj.errors.full_messages.join("\n")}" unless new_obj.errors.empty?
+      assert_response :redirect
+      new_obj
+    end
+    
+    def deletes(object)
+      post object_url(object, "destroy")
+      assert_raise(ActiveRecord::RecordNotFound) { object.class.find(object.id) }
+      assert_response :redirect
+    end
+    
+    def cant_create(klass, params)
+      replace_objects_in_params!(params)
+      post object_url(klass), klass.name.underscore => params
+      assert_response :forbidden
+    end
+    
+    def can_see(s)
+      assert_select("body", Regexp.new(s.split.map { |w| Regexp.escape(w) }.join("\s*")),
+                    current_should("be able to see: #{s}"))
+    end
+    
+    alias_method :sees, :can_see
+    
+    def cant_see(s)
+      assert_select("body", { :text => Regexp.new(s.split.map { |w| Regexp.escape(w) }.join("\s*")), :count => 0 },
+                    current_should("not be able to see: #{s}"))
+    end
+    
+    def creates_and_visits(klass, params)
+      new_obj = creates(klass, params)
+      visits(new_obj)
+      new_obj
+    end
+    
+    def calls_method(object, method, params={})
+      post object_url(object, method), params
+      assert_response :success
+    end
+    
+    def current_should(s)
+      "#{current_user.login} should #{s}"
+    end
+    
+    def object_url(obj, action=nil, *param_hashes)
+      HoboHelpers.new.send(:object_url, obj, action, *param_hashes)
+    end
+    
+    def replace_objects_in_params!(hash)
+      hash.each do |k,v|
+        if v.is_a? ActiveRecord::Base
+          hash[k] = "@" + Hobo.dom_id(v)
+        elsif v.is_a? Hash
+          replace_objects_in_params!(v)
+        end
+      end
+    end
+    
+  end
+
+  def new_session
+    open_session do |sess|
+      sess.extend(HoboTesting)
+      session_opened(sess) if respond_to? :session_opened
+      yield sess if block_given?
+    end
+  end
+
+  def new_session_as(person, password)
+    new_session do |sess|
+      sess.logs_in_as(person, password)
+      yield sess if block_given?
+    end
+  end
+  
+end

data/hobo_files/plugin/lib/hobo.rb

@@ -0,0 +1,353 @@
+class HoboError < RuntimeError; end
+
+module Hobo
+
+  class RawJs < String; end
+
+  @models = []
+
+  class << self
+
+    attr_accessor :current_theme
+    attr_writer :developer_features
+
+    def developer_features?
+      @developer_features
+    end
+
+
+    def raw_js(s)
+      RawJs.new(s)
+    end
+
+
+    def user_model=(model)
+      @user_model = model && model.name
+    end
+
+    
+    def user_model
+      @user_model && @user_model.constantize
+    end
+
+    
+    def models=(models)
+      @models = models.every(:name)
+    end
+
+    
+    def models
+      unless @models_loaded
+        Dir.entries("#{RAILS_ROOT}/app/models/").map do |f|
+          f =~ /.rb$/ and f.sub(/.rb$/, '').camelize.constantize
+        end
+        @models_loaded = true
+      end
+      @models.omap{constantize}
+    end
+
+    
+    def register_model(model)
+      @models << model.name unless @models.include? model.name
+    end
+
+
+    def object_from_dom_id(dom_id)
+      return nil if dom_id == 'nil'
+
+      _, name, id, attr = *dom_id.match(/^([a-z_]+)_([0-9]+(?:_[0-9]+)*)(_[a-z_]+)?$/)
+      raise ArgumentError.new("invalid model-reference in dom id") unless name
+      if name
+        model_class = name.camelize.constantize rescue (raise ArgumentError.new("no such class in dom-id"))
+        return nil unless model_class
+        attr = attr[1..-1] if attr
+        obj = if false and attr and model_class.reflections[attr.to_sym].klass.superclass == ActiveRecord::Base
+                # DISABLED - Eager loading is broken - doesn't support ordering
+                # http://dev.rubyonrails.org/ticket/3438
+                # Don't do this for STI subclasses - it breaks!
+                model_class.find(id, :include => attr)
+              else
+                model_class.find(id)
+              end
+        attr ? obj.send(attr) : obj
+      end
+    end
+
+    def dom_id(obj, attr=nil)
+      if obj.nil?
+        raise HoboError, "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.respond_to?(:typed_id)
+        if attr
+          return dom_id(get_field(obj, attr))
+        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
+          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)
+          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
+    end
+
+    def add_routes(map)
+      require "#{RAILS_ROOT}/app/controllers/application" unless Object.const_defined? :ApplicationController
+
+      for model in Hobo.models
+        controller_name = "#{model.name.pluralize}Controller"
+        controller = controller_name.constantize if
+          File.exists?("#{RAILS_ROOT}/app/controllers/#{controller_name.underscore}.rb")
+        if controller
+          web_name = model.name.underscore.pluralize.downcase
+
+          # Simple support for composite models, we might later need a CompositeModelController
+          if model < Hobo::CompositeModel
+            map.connect "#{web_name}/:id", :controller => web_name, :action => 'show'
+
+          elsif controller < Hobo::ModelController
+            
+            map.resources web_name, :collection => { :completions => :get }
+            
+            for collection in controller.collections
+              new_method = Hobo.simple_has_many_association?(model.reflections[collection])
+              Hobo.add_collection_routes(map, web_name, collection, new_method)
+            end
+            
+            for method in controller.web_methods
+              map.named_route("#{web_name.singularize}_#{method}",
+                              "#{web_name}/:id/#{method}",
+                              :controller => web_name,
+                              :action => method.to_s,
+                              :conditions => { :method => :post })
+            end
+            
+            for view in controller.show_actions
+              map.named_route("#{web_name.singularize}_#{view}",
+                              "#{web_name}/:id;#{view}",
+                              :controller => web_name,
+                              :action => view.to_s,
+                              :conditions => { :method => :get })
+            end
+          end
+        end
+      end
+    end
+    
+    
+    def add_collection_routes(map, controller_name, collection_name, new_method)
+      singular_name = collection_name.to_s.singularize
+      map.with_options :controller => controller_name, :conditions => { :method => :get } do |m|
+        m.named_route("#{controller_name.singularize}_#{collection_name}",
+                      "#{controller_name}/:id/#{collection_name}",
+                      :action => "show_#{collection_name}")
+
+        m.named_route("new_#{controller_name.singularize}_#{singular_name}",
+                      "#{controller_name}/:id/#{collection_name}/new",
+                      :action => "new_#{singular_name}") if new_method
+      end
+    end
+
+
+    def all_controllers
+      Hobo.models.map {|m| m.name.underscore.pluralize}
+    end
+
+
+    def simple_has_many_association?(array_or_reflection)
+      refl = array_or_reflection.is_a?(Array) ? array_or_reflection.proxy_reflection : array_or_reflection
+      return false unless refl.is_a?(ActiveRecord::Reflection::AssociationReflection)
+      refl.macro == :has_many and
+        (not refl.through_reflection) and
+        (not refl.options[:conditions])
+    end
+    
+    
+    def get_field(object, field)
+      if field.to_s =~ /\d+/
+        object[field.to_i]
+      else
+        object.send(field)
+      end
+    end
+    
+    
+    # --- Permissions --- #
+
+
+    def can_create?(person, object)
+      if object.is_a?(Class) and object < ActiveRecord::Base
+        object = object.new
+        object.created_by(person)
+      elsif Hobo.simple_has_many_association?(object)
+        object = object.new_without_appending
+        object.created_by(person)
+      end
+      check_permission(:create, person, object)
+    end
+
+
+    def can_update?(person, object, new)
+      check_permission(:update, person, object, new)
+    end
+
+
+    def can_edit?(person, object, field)
+      setter = "#{field}="
+      return false unless can_view?(person, object, field) and object.respond_to?(setter)
+      
+      refl = object.class.reflections[field.to_sym] if object.is_a?(ActiveRecord::Base)
+      
+      # has_many and polymorphic associations are not editable (for now)
+      return false if refl and (refl.macro == :has_many or refl.options[:polymorphic])
+
+      current = object.send(field)
+      new = object.duplicate
+      new.send(setter, if current == true
+                         false
+                       elsif current == false
+                         true
+                       elsif refl and refl.macro == :belongs_to
+                         Hobo::Undefined.new(refl.klass)
+                       else
+                         Hobo::Undefined.new
+                       end)
+
+      begin
+        if object.new_record?
+          check_permission(:create, person, new)
+        else
+          check_permission(:update, person, object, new)
+        end
+      rescue Hobo::UndefinedAccessError
+        false
+      end
+    end
+
+
+    def can_delete?(person, object)
+      check_permission(:delete, person, object)
+    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 (new_without_appending), 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?(person, object, field=nil)
+      if field
+        field = field.to_sym if field.is_a? String
+        return false if object.is_a?(ActiveRecord::Base) and object.class.never_show?(field)
+      else
+        # Special support for classes (can view instances?)
+        if object.is_a?(Class) and object < ActiveRecord::Base
+          object = object.new
+        elsif object.is_a?(Array)
+          if object.respond_to?(:new_without_appending)
+            object = object.new_without_appending
+          elsif object.respond_to?(:member_class)
+            object = object.member_class.new
+          end          
+        end
+      end
+      viewable = check_permission(:view, person, object, field)
+      if viewable and field and
+          ( (field_val = get_field(object, field)).is_a?(ActiveRecord::Base) or field_val.is_a?(Array) )
+        # also ask the current value if it is viewable
+        can_view?(person, field_val)
+      else
+        viewable
+      end
+    end
+    
+    
+    def can_call?(person, object, method)
+      return true if person.respond_to?(:super_user?) && person.super_user?
+
+      m = "#{method}_callable_by?"
+      object.respond_to?(m) && object.send(m, person)
+    end 
+    
+    # --- end permissions -- #
+    
+    
+    def static_tags
+      @static_tags ||= begin
+                         path = File.join(File.dirname(__FILE__), "hobo/static_tags")
+                         File.readlines(path).omap{chop} 
+                       end
+    end
+
+    
+    private
+
+
+    def check_permission(permission, person, object, *args)
+      return true if person.respond_to?(:super_user?) and person.super_user?
+      
+      return true if permission == :view && !(object.is_a?(ActiveRecord::Base) || object.is_a?(Hobo::CompositeModel))
+
+      obj_method = case permission
+                   when :create; :creatable_by?
+                   when :update; :updatable_by?
+                   when :delete; :deletable_by?
+                   when :view;   :viewable_by?
+                   end
+      p = if object.respond_to?(obj_method)
+            begin
+              object.send(obj_method, person, *args)
+            rescue Hobo::UndefinedAccessError
+              false
+            end
+          elsif object.class.respond_to?(obj_method)
+            object.class.send(obj_method, person, *args)
+          elsif !object.is_a?(Class) # No user fallback for class-level permissions
+            person_method = "can_#{permission}?".to_sym
+            if person.respond_to?(person_method)
+              person.send(person_method, object, *args)
+            else
+              # The object does not define permissions - you can only view it
+              permission == :view
+            end
+          end
+    end
+
+  end
+
+end