hobo 1.1.0 → 1.3.0.RC

data/lib/hobo/permissions/associations.rb

@@ -1,175 +0,0 @@
-module Hobo
-  
-  module Permissions
-    
-    module Associations
-    
-      def self.enable
-      
-        # Re-open AR classes...
-      
-        ActiveRecord::Associations::HasManyAssociation.class_eval do
-
-          # Helper - the user acting on the owner (if there is one)
-          def acting_user
-            @owner.acting_user if @owner.is_a?(Hobo::Model)
-          end
-
-
-          def delete_records(records)
-            case @reflection.options[:dependent]
-              when :destroy
-                records.each { |r| r.is_a?(Hobo::Model) ? r.user_destroy(acting_user) : r.destroy }
-              when :delete_all
-                # No destroy permission check if the :delete_all option has been chosen
-                @reflection.klass.delete(records.map(&:id))
-              else
-                nullify_keys(records)
-            end
-          end
-        
-
-          # Set the fkey used by this has_many to null on the passed records, checking for permission first if both the owner
-          # and record in question are Hobo models
-          def nullify_keys(records)
-            if (user = acting_user)
-              records.each { |r| r.user_update_attributes!(user, @reflection.primary_key_name => nil) if r.is_a?(Hobo::Model) }
-            end
-
-            # Normal ActiveRecord implementatin
-            ids = quoted_record_ids(records)
-            @reflection.klass.update_all(
-              "#{@reflection.primary_key_name} = NULL", 
-              "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
-            )
-          end
-
-
-          def insert_record(record, force = false, validate = true)
-            set_belongs_to_association_for(record)
-            if (user = acting_user) && record.is_a?(Hobo::Model)
-              if force
-                record.user_save!(user)
-              else
-                record.user_save(user, validate)
-              end
-            else
-               if force 
-                 record.save!
-               else
-                 record.save(validate)
-               end
-            end
-          end
-          
-          def viewable_by?(user, field=nil)
-            # view check on an example member record is not supported on associations with conditions
-            return true if @reflection.options[:conditions]
-            new_candidate.viewable_by?(user, field)
-          end
-        
-        end
-      
-        ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
-        
-          def acting_user
-            @owner.acting_user if @owner.is_a?(Hobo::Model)
-          end
-
-        
-          def create!(attrs = nil)
-            klass = @reflection.klass
-            user = acting_user if klass < Hobo::Model
-            klass.transaction do
-              object = if attrs
-                         klass.send(:with_scope, :create => attrs) { user ? klass.user_create!(user) : klass.create! }
-                       else
-                         user ? klass.user_create!(user) : klass.create!
-                       end
-              self << object
-              object
-            end
-          end
-
-
-          def create(attrs = nil)
-            klass = @reflection.klass
-            user = acting_user if klass < Hobo::Model
-            klass.transaction do
-              object = if attrs
-                         klass.send(:with_scope, :create => attrs) { user ? klass.user_create(user) : klass.create }
-                       else
-                         user ? klass.user_create(user) : klass.create
-                       end
-              self << object
-              object
-            end
-          end
-        
-        
-          def insert_record(record, force=true, validate=true)
-            user = acting_user if record.is_a?(Hobo::Model)
-            if record.new_record?
-              if force
-                user ? record.user_save!(user) : record.save!
-              else
-                return false unless (user ? record.user_save(user, validate) : record.save(validate))
-              end
-            end
-            klass = @reflection.through_reflection.klass
-            @owner.send(@reflection.through_reflection.name).proxy_target << 
-              klass.send(:with_scope, :create => construct_join_attributes(record)) { user ? klass.user_create!(user) : klass.create! }
-          end
-
-
-          # TODO - add dependent option support
-          def delete_records_with_hobo_permission_check(records)
-            klass  = @reflection.through_reflection.klass
-            user = acting_user
-            if user && records.any? { |r|
-                joiner = klass.find(:first, :conditions => construct_join_attributes(r))
-                joiner.is_a?(Hobo::Model) && !joiner.destroyable_by?(user)
-              }
-              raise Hobo::PermissionDeniedError, "#{@owner.class}##{proxy_reflection.name}.destroy"
-            end
-            delete_records_without_hobo_permission_check(records)
-          end
-          alias_method_chain :delete_records, :hobo_permission_check
-        
-        end
-      
-        ActiveRecord::Associations::AssociationCollection.class_eval do
-        
-          # Helper - the user acting on the owner (if there is one)
-          def acting_user
-            @owner.acting_user if @owner.is_a?(Hobo::Model)
-          end
-                
-          def create(attrs = {})
-            if attrs.is_a?(Array)
-              attrs.collect { |attr| create(attr) }
-            else
-              create_record(attrs) do |record|
-                yield(record) if block_given?
-                user = acting_user if record.is_a?(Hobo::Model)
-                user ? record.user_save(user) : record.save
-              end
-            end
-          end
-
-          def create!(attrs = {})
-            create_record(attrs) do |record|
-              yield(record) if block_given?
-              user = acting_user if record.is_a?(Hobo::Model)
-              user ? record.user_save!(user) : record.save!
-            end
-          end
-        
-        end
-      
-      end
-    
-    end
-  end  
-  
-end

data/lib/hobo/rapid_helper.rb

@@ -1,157 +0,0 @@
-module Hobo::RapidHelper
-
-  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 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
-    js_options['form']          = options[:form] if options[:form]
-    js_options['params']        = make_params_js(options[:params]) if options[:params]
-    js_options['resultUpdate']  = js_result_updates(options[:result_update]) if options[:result_update]
-    js_options['resetForm']     = options[:reset_form] if options.has_key?(:reset_form)
-    js_options['refocusForm']   = options[:refocus_form] if options.has_key?(:refocus_form)
-    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
-
-
-  def js_updates(updates)
-    return '[]' unless updates
-    updates = [updates] unless updates.is_a? Array
-    updates = comma_split(updates).map do |u|
-      if u.to_s == "self"
-        "Hobo.partFor(this)"
-      else
-        js_str(u)
-      end
-    end
-    "[#{updates * ', '}]"
-  end
-
-
-  def js_result_updates(updates)
-    return '[]' unless updates
-    updates = [updates] unless updates.is_a? Array
-    pairs = comma_split(updates).map &it.split(/\s*=\s*/)
-    '[' + pairs.map{|p| "{id: #{js_str(p[0])}, result: #{js_str(p[1])}}"}.join(", ") + ']'
-  end
-
-
-  def ajax_updater(url_or_form, update, options={})
-    options ||= {}
-    options.symbolize_keys!
-
-    target = if url_or_form == :post_form
-               target = "this"
-             else
-               js_str(url_or_form)
-             end
-    js_options = options_for_hobo_ajax(options)
-    args = [target, js_updates(update), js_options].compact
-
-    confirm = options.delete(:confirm)
-
-    func = "Hobo.ajaxRequest(#{args * ', '})"
-    if confirm
-      "if (confirm(#{js_str(confirm)})) { #{func} }"
-    else
-      func
-    end
-  end
-
-
-  def a_or_an(word)
-    if word =~ /^[aeiouh]/
-      "an #{word}"
-    else
-      "a #{word}"
-    end
-  end
-
-
-  def no_break(s)
-    s = new_context { yield } if block_given?
-    s.gsub(' ', ' ')
-  end
-
-
-
-
-  def in_place_editor(attributes, this=nil)
-    blank_message = attributes.delete(:blank_message) || "(click to edit)"
-
-    attributes = add_classes(attributes, "in-place-edit", model_id_class(this_parent, this_field))
-    attributes.update(:hobo_blank_message => blank_message,
-                      :if_blank => blank_message,
-                      :no_wrapper => false)
-    
-    edit_text = this._?.to_s
-    attributes.update(:hobo_edit_text => edit_text) unless edit_text.nil?
-
-    update = attributes.delete(:update)
-    attributes[:hobo_update] = update if update
-
-    view(attributes)
-  end
-
-
-
-  AJAX_CALLBACKS = [ :before, :success, :failure, :complete ]
-
-  AJAX_ATTRS = AJAX_CALLBACKS + [ :update, :type, :method,
-                                  :script, :form, :params, :confirm, :message,
-                                  :reset_form, :refocus_form, :result_update, :spinner_next_to ]
-
-
-  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
-end

data/lib/hobo/scopes.rb

@@ -1,43 +0,0 @@
-module Hobo
-
-  module Scopes
-
-    def self.included_in_class(klass)
-      klass.class_eval do
-        extend ClassMethods
-        metaclass.alias_method_chain :valid_keys_for_has_many_association,   :scopes
-        metaclass.alias_method_chain :valid_keys_for_has_one_association,    :scopes
-        metaclass.alias_method_chain :valid_keys_for_belongs_to_association, :scopes
-      end
-    end
-
-    module ClassMethods
-
-      include AutomaticScopes
-
-      include ApplyScopes
-
-      # --- monkey-patches to allow :scope key on has_many, has_one and belongs_to ---
-      
-      def valid_keys_for_has_many_association_with_scopes
-        valid_keys_for_has_many_association_without_scopes + [:scope]
-      end
-
-      def valid_keys_for_has_one_association_with_scopes
-        valid_keys_for_has_one_association_without_scopes + [:scope]
-      end
-
-      def valid_keys_for_belongs_to_association_with_scopes
-        valid_keys_for_belongs_to_association_without_scopes + [:scope]
-      end
-
-    end
-
-  end
-
-end
-
-ActiveRecord::Associations::AssociationProxy.send(:include, Hobo::Scopes::AssociationProxyExtensions)
-ActiveRecord::Associations::AssociationCollection.send(:include, Hobo::Scopes::AssociationCollectionExtensions)
-ActiveRecord::Associations::HasManyThroughAssociation.send(:include, Hobo::Scopes::HasManyThroughAssociationExtensions)
-require "hobo/scopes/named_scope_extensions"

data/lib/hobo/scopes/apply_scopes.rb

@@ -1,23 +0,0 @@
-module Hobo
-
-  module Scopes
-
-    module ApplyScopes
-
-      def apply_scopes(scopes)
-        result = self
-        scopes.each_pair do |scope, arg|
-          if arg.is_a?(Array)
-            result = result.send(scope, *arg) unless arg.first.blank?
-          else
-            result = result.send(scope, arg) unless arg.blank?
-          end
-        end
-        result
-      end
-
-    end
-
-  end
-
-end

data/lib/hobo/scopes/association_proxy_extensions.rb

@@ -1,62 +0,0 @@
-# Add support for :scope => :my_scope to has_many and belongs_to
-
-module Hobo
-
-  module Scopes
-
-    AssociationProxyExtensions = classy_module do
-
-      def scope_conditions(reflection)
-        scope_name = reflection.options[:scope]
-        return nil if scope_name.nil?
-        target_class = reflection.klass
-        return nil if target_class.nil?
-        if scope_name.respond_to? :map
-          combine_conditions(*(scope_name.map {|scope| target_class.send(*scope).scope(:find)[:conditions]}))
-        else
-          target_class.send(scope_name).scope(:find)[:conditions]
-        end
-      end
-
-
-      def combine_conditions(*conditions)
-        parts = conditions.compact.map { |c| "(#{sanitize_sql c})" }
-        parts.empty? ? nil : parts.join(" AND ")
-      end
-
-
-      def conditions_with_hobo_scopes
-        scope_conditions = self.scope_conditions(@reflection)
-        unscoped_conditions = conditions_without_hobo_scopes
-        combine_conditions(scope_conditions, unscoped_conditions)
-      end
-      alias_method_chain :conditions, :hobo_scopes
-
-    end
-
-    HasManyThroughAssociationExtensions = classy_module do
-
-      def build_conditions_with_hobo_scopes
-        scope_conditions         = self.scope_conditions(@reflection)
-        through_scope_conditions = self.scope_conditions(@reflection.through_reflection)
-        unscoped_conditions = build_conditions_without_hobo_scopes
-        combine_conditions(scope_conditions, through_scope_conditions, unscoped_conditions)
-      end
-      alias_method_chain :build_conditions, :hobo_scopes
-      public :conditions
-      
-    end
-    
-    AssociationCollectionExtensions = classy_module do
-      
-      def proxy_respond_to_with_automatic_scopes?(method, include_priv = false)
-        proxy_respond_to_without_automatic_scopes?(method, include_priv) ||
-          (@reflection.klass.create_automatic_scope(method) if @reflection.klass.respond_to?(:create_automatic_scope))
-      end
-      alias_method_chain :proxy_respond_to?, :automatic_scopes
-      
-    end
-
-  end
-
-end