hobo 1.1.0 → 1.3.0.RC

data/lib/active_record/association_reflection.rb

@@ -1,20 +0,0 @@
-class ActiveRecord::Reflection::AssociationReflection
-
-  alias_method :association_name, :name
-
-  def klass_with_create_polymorphic_class
-    if options[:polymorphic]
-      begin
-        klass_without_create_polymorphic_class
-      rescue NameError => e
-        name = "#{active_record.name}::#{class_name}"
-        Object.class_eval "class #{name}; end"
-        active_record.const_get class_name
-      end
-    else
-      klass_without_create_polymorphic_class
-    end
-  end
-  alias_method_chain :klass, :create_polymorphic_class
-
-end

data/lib/active_record/viewhints_validations_interceptor.rb

@@ -1,9 +0,0 @@
-module Hobo
-  module ViewHintsValidationsInterceptor
-    def human_attribute_name(attribute_key_name, opt={})
-      view_hints_field_names = self.view_hints.field_names
-      attribute_key_name!="" && view_hints_field_names.include?(attribute_key_name.to_sym) ?
-      view_hints_field_names[attribute_key_name.to_sym] : super
-    end
-  end
-end

data/lib/hobo/accessible_associations.rb

@@ -1,183 +0,0 @@
-module Hobo
-  
-  module AccessibleAssociations
-    
-    extend self
-    
-    def prepare_has_many_assignment(association, association_name, array_or_hash)
-      owner = association.proxy_owner
-
-      array = params_hash_to_array(array_or_hash)
-      array.map! do |record_hash_or_string|
-        if association.conditions.nil?
-          finder = association.member_class
-        else
-          finder = association.member_class.scoped :conditions => association.conditions
-        end
-        find_or_create_and_update(owner, association_name, finder, record_hash_or_string) do |id|
-          # The block is required to either locate find an existing record in the collection, or build a new one
-          if id
-            # TODO: We don't really want to find these one by one
-            association.find(id)
-          else
-            association.build
-          end
-        end
-      end
-      array.compact
-    end
-    
-    
-    def find_or_create_and_update(owner, association_name, finder, record_hash_or_string)
-      if record_hash_or_string.is_a?(String)
-        return nil if record_hash_or_string.blank?
-
-        # An ID or a name - the passed block will find the record
-        record = find_by_name_or_id(finder, record_hash_or_string)
-      
-      elsif record_hash_or_string.is_a?(Hash)
-        # A hash of attributes
-        hash = record_hash_or_string
-
-        # Remove completely blank hashes
-        return nil if hash.values.all?(&:blank?)
-
-        id = hash.delete(:id)
-
-        record = yield id
-        record.attributes = hash
-        if owner.new_record? && record.new_record?
-          # work around
-          # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/3510-has_many-build-does-not-set-reverse-reflection
-          # https://hobo.lighthouseapp.com/projects/8324/tickets/447-validation-problems-with-has_many-accessible-true
-          reverse = owner.class.reverse_reflection(association_name)
-          if reverse && reverse.macro==:belongs_to
-            method = "#{reverse.name}=".to_sym
-            record.send(method, owner) if record.respond_to? method
-          end
-        else
-          owner.include_in_save(association_name, record) unless owner.class.reflections[association_name].options[:through]
-        end        
-      else
-        # It's already a record
-        record = record_hash_or_string
-      end
-      record
-    end
-
-    
-    def params_hash_to_array(array_or_hash)
-      if array_or_hash.is_a?(Hash)
-        array = array_or_hash.get(*array_or_hash.keys.sort_by(&:to_i))
-      elsif array_or_hash.is_a?(String)
-        # Due to the way that rails works, there's no good way to tell
-        # the difference between an empty array and a params hash that
-        # just isn't making any updates to the array.  So we're
-        # hacking this in: if you pash an empty string where an array
-        # is expected, we assume you wanted an empty array.
-        []
-      else
-        array_or_hash
-      end
-    end
-    
-
-    def find_by_name_or_id(finder, id_or_name)
-      if id_or_name =~ /^@(.*)/
-        id = $1
-        finder.find(id)
-      else
-        finder.named(id_or_name)
-      end
-    end
-
-    def finder_for_belongs_to(record, name)
-      refl = record.class.reflections[name]
-      conditions = ActiveRecord::Associations::BelongsToAssociation.new(record, refl).conditions
-      finder = refl.klass.scoped(:conditions => conditions)
-    end
-
-  end
-  
-  classy_module(AccessibleAssociations) do
-    
-    include Hobo::IncludeInSave
-    
-    # --- has_many mass assignment support --- #
-    
-    def self.has_many_with_accessible(name, options={}, &block)
-      has_many_without_accessible(name, options, &block)
-      
-      if options[:accessible]
-        class_eval %{
-          def #{name}_with_accessible=(array_or_hash)
-            __items = Hobo::AccessibleAssociations.prepare_has_many_assignment(#{name}, :#{name}, array_or_hash)
-            self.#{name}_without_accessible = __items
-            # ensure the loaded array contains any changed records
-            self.#{name}.proxy_target[0..-1] = __items
-          end
-        }, __FILE__, __LINE__ - 7
-        alias_method_chain :"#{name}=", :accessible
-      end
-    end
-    metaclass.alias_method_chain :has_many, :accessible
-    
-    
-    
-    # --- belongs_to assignment support --- #
-    
-    def self.belongs_to_with_accessible(name, options={}, &block)
-      belongs_to_without_accessible(name, options, &block)
-      
-      if options[:accessible]
-        class_eval %{
-          def #{name}_with_accessible=(record_hash_or_string)
-            finder = Hobo::AccessibleAssociations.finder_for_belongs_to(self, :#{name})
-            record = Hobo::AccessibleAssociations.find_or_create_and_update(self, :#{name}, finder, record_hash_or_string) do |id|
-              if id
-                raise ArgumentError, "attempted to update the wrong record in belongs_to association #{self}##{name}" unless 
-                  #{name} && id.to_s == self.#{name}.id.to_s
-                #{name}
-              else
-                finder.new
-              end
-            end
-            self.#{name}_without_accessible = record
-          end
-        }, __FILE__, __LINE__ - 15
-        alias_method_chain :"#{name}=", :accessible
-      else
-        # Not accessible - but finding by name and ID is still supported
-        class_eval %{
-          def #{name}_with_finder=(record_or_string)
-            record = if record_or_string.is_a?(String)
-                       finder = Hobo::AccessibleAssociations.finder_for_belongs_to(self, :#{name})
-                       Hobo::AccessibleAssociations.find_by_name_or_id(finder, record_or_string)
-                     else # it is a record
-                       record_or_string
-                     end
-            self.#{name}_without_finder = record
-          end
-        }, __FILE__, __LINE__ - 12
-        alias_method_chain :"#{name}=", :finder
-      end
-    end
-    metaclass.alias_method_chain :belongs_to, :accessible
-    
-    
-    # Add :accessible to the valid keys so AR doesn't complain
-
-    def self.valid_keys_for_has_many_association_with_accessible
-      valid_keys_for_has_many_association_without_accessible + [:accessible]
-    end
-    metaclass.alias_method_chain :valid_keys_for_has_many_association, :accessible
-
-    def self.valid_keys_for_belongs_to_association_with_accessible
-      valid_keys_for_belongs_to_association_without_accessible + [:accessible]
-    end
-    metaclass.alias_method_chain :valid_keys_for_belongs_to_association, :accessible
-    
-    
-  end    
-  
-end

data/lib/hobo/authentication_support.rb

@@ -1,131 +0,0 @@
-module Hobo
-
-  module AuthenticationSupport
-
-    # Filter method to enforce a login requirement.
-    def logged_in?
-      not current_user.guest?
-    end
-
-
-    # Check if the user is authorized.
-    #
-    # Override this method in your controllers if you want to restrict access
-    # to only a few actions or if you want to check if the user
-    # has the correct rights.
-    #
-    # Example:
-    #
-    #  # only allow nonbobs
-    #  def authorize?
-    #    current_user.login != "bob"
-    #  end
-    def authorized?
-      true
-    end
-
-    #
-    # To require logins for all actions, use this in your controllers:
-    #
-    #   before_filter :login_required
-    #
-    # To require logins for specific actions, use this in your controllers:
-    #
-    #   before_filter :login_required, :only => [ :edit, :update ]
-    #
-    # To skip this in a subclassed controller:
-    #
-    #   skip_before_filter :login_required
-    #
-    def login_required(user_model=nil)
-      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
-      end
-      if logged_in? && authorized? && (user_model.nil? || current_user.is_a?(user_model))
-        true
-      else
-        access_denied(auth_model)
-      end
-    end
-
-    # Redirect as appropriate when an access request fails.
-    #
-    # The default action is to redirect to the login screen.
-    #
-    # Override this method in your controllers if you want to have special
-    # behavior in case the user is not authorized
-    # to access the requested action.  For example, a popup window might
-    # simply close itself.
-    def access_denied(user_model)
-      respond_to do |accepts|
-        accepts.html do
-          store_location
-          redirect_to(login_url(user_model))
-        end
-        accepts.xml do
-          headers["Status"]           = "Unauthorized"
-          headers["WWW-Authenticate"] = %(Basic realm="Web Password")
-          render :text => ht("hobo.messages.unauthenticated", :default=>["Couldn't authenticate you"]), :status => '401 Unauthorized'
-        end
-      end
-      false
-    end
-
-    # Store the URI of the current request in the session.
-    #
-    # We can return to this location by calling #redirect_back_or_default.
-    def store_location
-      session[:return_to] = request.request_uri
-    end
-
-    # Redirect to the URI stored by the most recent store_location call or
-    # to the passed default.
-    def redirect_back_or_default(default)
-      session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)
-      session[:return_to] = nil
-    end
-
-    # When called with before_filter :login_from_cookie will check for an :auth_token
-    # cookie and log the user back in if apropriate
-    def login_from_cookie
-      if (user = authenticated_user_from_cookie)
-        user.remember_me
-        self.current_user = user
-        create_auth_cookie
-      end
-    end
-    
-    
-    def authenticated_user_from_cookie
-      !logged_in? and
-          cookie = cookies[:auth_token] and
-          (token, model_name = cookie.split) and
-          user_model = model_name._?.safe_constantize and
-          user = user_model.find_by_remember_token(token) and
-          user.remember_token? and
-          user
-    end
-
-    def create_auth_cookie
-      cookies[:auth_token] = { :value => "#{current_user.remember_token} #{current_user.class.name}",
-                               :expires => current_user.remember_token_expires_at }
-    end
-
-    private
-    @@http_auth_headers = %w(X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION Authorization)
-    # gets BASIC auth info
-    def get_auth_data
-      auth_key  = @@http_auth_headers.detect { |h| request.env.has_key?(h) }
-      auth_data = request.env[auth_key].to_s.split unless auth_key.blank?
-      username, pw = if auth_data && auth_data[0] == 'Basic'
-                       Base64.decode64(auth_data[1]).split(':')[0..1]
-                     else
-                       [nil, nil]
-                     end
-    end
-
-  end
-
-end

data/lib/hobo/generator.rb

@@ -1,26 +0,0 @@
-require 'find'
-require "rails_generator"
-
-class Hobo::Generator < Rails::Generator::Base
-
-  def with_source_in(path)
-    root = source_path(path)
-    Find.find(root) do |f|
-      Find.prune if File.basename(f) == ".svn"
-      full_path = f[(source_root.length)..-1]
-      rel_path = f[(root.length)..-1]
-      yield full_path, rel_path
-    end
-  end
-
-  def create_all(m, src, dest)
-    with_source_in(src) do |full, rel|
-      if File.directory?(source_path(full))
-        m.directory File.join(dest, rel)
-      else
-        m.file full, File.join(dest, rel)
-      end
-    end
-  end
-
-end

data/lib/hobo/guest.rb

@@ -1,25 +0,0 @@
-module Hobo
-
-  class Guest
-
-    alias_method :has_hobo_method?, :respond_to?
-
-    def to_s
-      "guest"
-    end
-
-    def guest?
-      true
-    end
-
-    def signed_up?
-      false
-    end
-
-    def login
-      "guest"
-    end
-
-  end
-
-end

data/lib/hobo/include_in_save.rb

@@ -1,55 +0,0 @@
-module Hobo
-  
-  IncludeInSave = classy_module do
-    
-    attr_accessor :included_in_save
-    
-    validate         :validate_included_in_save
-    before_save      :save_included
-    after_save       :clear_included_in_save    
-    
-    def include_in_save(association, *records)
-      self.included_in_save ||= Hash.new {|h, k| h[k] = []}
-      included_in_save[association.to_sym].concat records
-    end
-    
-    def validate_included_in_save
-      if included_in_save
-        included_in_save._?.each_pair do |association, records|
-          next if self.class.reflections[association].options[:validate]==false
-          added = false
-          records.each do |record|
-            # we want to call valid? on each one, but only add the error to self once
-            
-            record.with_acting_user(acting_user) do
-              unless record.valid?
-                unless added
-                  errors.add association, "..."
-                  added = true
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-
-    def save_included
-      if included_in_save
-        included_in_save.each_pair do |association, records|
-          records.each do |record|
-            # save_without_validation means without transactions too
-            record.with_acting_user(acting_user) { record.save_without_validation }
-          end
-        end
-      end
-    end
-
-    def clear_included_in_save
-      included_in_save._?.clear
-    end
-
-  end
-
-end