hobo 1.1.0 → 1.3.0.RC

data/lib/hobo/engine.rb

@@ -0,0 +1,80 @@
+require 'hobo'
+require 'rails'
+require 'rails/generators'
+
+
+module Hobo
+  class Engine < Rails::Engine
+
+    ActiveSupport.on_load(:before_configuration) do
+      h = config.hobo = ActiveSupport::OrderedOptions.new
+      h.app_name = self.class.name.split('::').first.underscore.titleize
+      h.developer_features = Rails.env.in?(["development", "test"])
+      h.routes_path = Pathname.new File.expand_path('config/hobo_routes.rb', Rails.root)
+      h.rapid_generators_path = Pathname.new File.expand_path('lib/hobo/rapid/generators', Hobo.root)
+      h.auto_taglibs_path = Pathname.new File.expand_path('app/views/taglibs/auto', Rails.root)
+      h.read_only_file_system = !!ENV['HEROKU_TYPE']
+      h.show_translation_keys = false
+      h.dryml_only_templates = false
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      require 'hobo/extensions/action_controller/hobo_methods'
+      require 'hobo/extensions/action_mailer/helper'
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      require 'hobo/extensions/active_record/associations/collection'
+      require 'hobo/extensions/active_record/associations/proxy'
+      require 'hobo/extensions/active_record/associations/reflection'
+      require 'hobo/extensions/active_record/hobo_methods'
+      require 'hobo/extensions/active_record/permissions'
+      require 'hobo/extensions/active_record/associations/scope'
+      require 'hobo/extensions/active_record/relation_with_origin'
+      require 'hobo/extensions/active_model/name'
+      require 'hobo/extensions/active_model/translation'
+      # added legacy namespace for backward compatibility
+      # TODO: remove the following line if Hobo::VERSION > 1.3.x
+      Hobo::ViewHints = Hobo::Model::ViewHints
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      require 'hobo/extensions/action_view/tag_helper'
+      require 'hobo/extensions/action_view/translation_helper'
+      include Hobo::Helper::Translations::Normalizer
+    end
+
+    ActiveSupport.on_load(:before_initialize) do
+      require 'hobo/undefined'
+      HoboFields.never_wrap(Hobo::Undefined)
+      h = config.hobo
+      Dryml::DrymlGenerator.enable([h.rapid_generators_path], h.auto_taglibs_path)
+    end
+
+    initializer 'hobo.i18n' do |app|
+      require 'hobo/extensions/i18n' if app.config.hobo.show_translation_keys
+    end
+
+    initializer 'hobo.routes' do |app|
+      h = app.config.hobo
+      # generate at first boot, so no manual generation is required
+      unless File.exists?(h.routes_path)
+        raise Hobo::Error, "No #{h.routes_path} found!" if h.read_only_file_system
+        Rails::Generators.invoke('hobo:routes', %w[-f -q])
+      end
+      app.routes_reloader.paths << h.routes_path
+      app.config.to_prepare do
+        Rails::Generators.invoke('hobo:routes', %w[-f -q])
+      end
+    end
+
+    initializer 'hobo.dryml' do |app|
+      unless app.config.hobo.read_only_file_system
+        app.config.to_prepare do
+          Dryml::DrymlGenerator.run
+        end
+      end
+    end
+
+  end
+end

data/lib/hobo/extensions/action_controller/hobo_methods.rb

@@ -0,0 +1,44 @@
+ActionController::Base.class_eval do
+
+  def self.hobo_user_controller
+    include Hobo::Controller::Model
+    include Hobo::Controller::User
+  end
+
+  def self.hobo_model_controller
+    include Hobo::Controller::Model
+  end
+
+  def self.hobo_controller
+    include Hobo::Controller
+  end
+
+  def home_page
+    base_url
+  end
+
+  # moved here from authentication_support.rb for easy overriding
+  # 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 => t("hobo.messages.unauthenticated", :default=>["Couldn't authenticate you"]), :status => '401 Unauthorized'
+      end
+    end
+    false
+  end
+
+end

data/lib/hobo/extensions/action_mailer/helper.rb

@@ -0,0 +1,38 @@
+module Hobo
+  module MailerHelper
+    attr_reader :app_name, :host
+
+    def initialize(*)
+      super
+      @app_name = Rails.application.config.hobo.app_name
+      if self.class.default_url_options.empty?
+        # might be set later in the before filter so we try to set it here
+        d = Rails.application.config.action_mailer.default_url_options
+        self.class.default_url_options = d.dup if d
+      end
+      @host = self.class.default_url_options[:host]
+    end
+
+
+    module ClassMethods
+      def app_name
+        @app_name ||= Rails.application.config.hobo.app_name
+      end
+
+      def host
+        @host ||= begin
+          if default_url_options[:host].nil?
+            d = Rails.application.config.action_mailer.default_url_options
+            d && d[:host].dup
+          else
+            default_url_options[:host]
+          end
+        end
+      end
+    end
+
+  end
+end
+
+ActionMailer::Base.send :include, Hobo::MailerHelper
+ActionMailer::Base.extend Hobo::MailerHelper::ClassMethods

data/lib/{action_view_extensions/helpers → hobo/extensions/action_view}/tag_helper.rb

@@ -1,7 +1,10 @@
-module ActionView::Helpers::TagHelper
+ActionView::Helpers::TagHelper.module_eval do
+
   alias_method :tag_without_doctype, :tag
+
   def tag(name, options = nil, open = false, escape = true)
     open = !scope.xmldoctype if defined?(scope)
     tag_without_doctype(name, options, open, escape)
   end
-end
+
+end

data/lib/hobo/extensions/action_view/translation_helper.rb

@@ -0,0 +1,25 @@
+ActionView::Helpers::TranslationHelper.module_eval do
+
+  # simple wrapper around the translate helper
+  # it implements a dryml <translate> and a <t> tag
+  # Improved security: interpolated variables are escaped
+  # Improved management: when it returns a string it is always html_safe
+  # It assumes the base translation string is html_safe
+  # It removes the <span> tag when the key is missing, because it would mess up
+  # the dryml tags when ht or t is used in some place
+
+  def translate(key, options={})
+    key, options = normalize_args(key, options)
+    translation = I18n.translate(scope_key_by_partial(key), options.merge!(:raise => true))
+    if translation.respond_to?(:html_safe)
+      translation.html_safe
+    else
+      translation
+    end
+  rescue I18n::MissingTranslationData => e
+    keys = I18n.normalize_keys(e.locale, e.key, e.options[:scope]).join('.')
+    "[MISSING: #{keys}]"
+  end
+  alias_method :t, :translate
+
+end

data/lib/hobo/extensions/active_model/name.rb

@@ -0,0 +1,16 @@
+ActiveModel::Name.class_eval do
+    # adds a default pluralization for english
+    # useful to avoid to set a locale 'en' file and avoid
+    # to pass around pluralize calls for 'en' defaults in hobo
+    def human_with_en_pluralization_default(options={})
+      if I18n.locale.to_s.match(/^en/)
+        unless options[:count] == 1 || options[:count].blank?
+          default = ActiveSupport::Inflector.pluralize(@human)
+          options.merge! :default => default
+        end
+      end
+      human_without_en_pluralization_default(options)
+    end
+    alias_method_chain :human, :en_pluralization_default
+
+end

data/lib/hobo/extensions/active_model/translation.rb

@@ -0,0 +1,35 @@
+ActiveModel::Translation.class_eval do
+
+    # adds a default pluralization and singularization for english
+    # useful to avoid to set a locale 'en' file and avoid
+    # to pass around pluralize calls for 'en' defaults in hobo
+    def human_attribute_name_with_en_pluralization_default(attribute, options={})
+      if I18n.locale.to_s.match(/^en/)
+        unless options[:count].blank? # skip default if we don't pass any count
+          default = options[:count] == 1 ?
+                    attribute.to_s.singularize.humanize : # singularize possible plural attributes
+                    attribute.to_s.pluralize.humanize
+          options.merge! :default => default
+        end
+      end
+      human_attribute_name_without_en_pluralization_default(attribute, options)
+    end
+    alias_method_chain :human_attribute_name, :en_pluralization_default
+
+    # Similar to human_name_attributes, this method retrieves the localized help string
+    # of an attribute if it is defined as the key "activemodel.attribute_help.<attribute_name>",
+    # otherwise it returns "".
+    def attribute_help(attribute, options = {})
+      defaults = lookup_ancestors.map do |klass|
+        :"#{self.i18n_scope}.attribute_help.#{klass.to_s.underscore}.#{attribute}"
+      end
+
+      defaults << :"attribute_help.#{attribute}"
+      defaults << options.delete(:default) if options[:default]
+      defaults << ''
+
+      options.reverse_merge! :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
+    end
+
+end

data/lib/{active_record/association_collection.rb → hobo/extensions/active_record/associations/collection.rb}

@@ -2,7 +2,7 @@ module ActiveRecord
   module Associations
     class AssociationCollection
 
-      include Hobo::Scopes::ApplyScopes
+      include Hobo::Model::Scopes::ApplyScopes
 
 
       def hobo_association_collection?
@@ -25,24 +25,19 @@ module ActiveRecord
         record
       end
 
-      def member_class
-        proxy_reflection.klass
-      end
-
       # DO NOT call super here - AssociationProxy's version loads the collection, and that's bad.
       # TODO: this really belongs in Rails; migrate it there ASAP
       def respond_to?(*args)
-        return super if has_one_collection?
-        proxy_respond_to?(*args) || [].respond_to?(*args)
+        proxy_respond_to?(*args) || Array.new.respond_to?(*args)
       end
 
+      # TODO: send this patch into Rails. There's no reason to load the collection just to find out it acts like an array.
       def is_a?(klass)
-        if has_one_collection?
-          load_target
-          @target.is_a?(klass)
-        else
-          [].is_a?(klass)
-        end
+        [].is_a?(klass)
+      end
+
+      def member_class
+        proxy_reflection.klass
       end
 
       private
@@ -57,10 +52,6 @@ module ActiveRecord
           end
         end
 
-        def has_one_collection?
-          proxy_reflection.macro == :has_one
-        end
-
     end
   end
 end

data/lib/{active_record/association_proxy.rb → hobo/extensions/active_record/associations/proxy.rb}

@@ -2,17 +2,16 @@ module ActiveRecord
   module Associations
     class AssociationProxy #:nodoc:
 
-    def origin
-      proxy_owner
-    end
+      def origin
+        proxy_owner
+      end
 
-    def origin_attribute
-      proxy_reflection.name
-    end
+      def origin_attribute
+        proxy_reflection.name
+      end
 
       private
 
-
       def raise_on_type_mismatch(record)
         # Don't complain if the interface type of a polymorphic association doesn't exist
         klass = @reflection.klass rescue nil

data/lib/hobo/extensions/active_record/associations/reflection.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Reflection
+    class AssociationReflection
+
+      alias_method :association_name, :name
+
+      def klass_with_create_polymorphic_class
+        if options[:polymorphic]
+          begin
+            klass_without_create_polymorphic_class
+          rescue NameError => e
+            Object.class_eval "class #{e.missing_name} < ActiveRecord::Base; set_table_name '#{active_record.name.tableize}'; end"
+            e.missing_name.constantize
+          end
+        else
+          klass_without_create_polymorphic_class
+        end
+      end
+      alias_method_chain :klass, :create_polymorphic_class
+
+    end
+  end
+end

data/lib/hobo/extensions/active_record/associations/scope.rb

@@ -0,0 +1,35 @@
+# Add support for :scope => :my_scope to associations
+
+module ActiveRecord
+  module Associations
+    module ThroughAssociationScope
+
+      def construct_scope_with_scope
+        s = construct_scope_without_scope
+        s[:find][:scope] = @reflection.options[:scope]
+        s
+      end
+      alias_method_chain :construct_scope, :scope
+
+      end
+    end
+
+  module SpawnMethods
+
+    def apply_finder_options_with_scope(options)
+      scopes = []
+      Array.wrap(options.delete(:scope)).each do |s|
+        if s.is_a?(Hash)
+          s.each_pair{|k,v| scopes << [k,v] }
+        else
+          scopes << [s]
+        end
+      end
+      relation = apply_finder_options_without_scope(options)
+      return relation if scopes.empty?
+      scopes.inject(relation) {|r, s| r.send *s }
+    end
+    alias_method_chain :apply_finder_options, :scope
+
+  end
+end

data/lib/hobo/extensions/active_record/hobo_methods.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Base.class_eval do
+  def self.hobo_model
+    include Hobo::Model
+    fields(false) # force hobo_fields to load
+  end
+  def self.hobo_user_model
+    include Hobo::Model
+    include Hobo::Model::UserBase
+  end
+  alias_method :has_hobo_method?, :respond_to_without_attributes?
+end

data/lib/hobo/extensions/active_record/permissions.rb

@@ -0,0 +1,159 @@
+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 = records.map { |record| record.quoted_id }.join(',')
+    @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 => 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.where(construct_join_attributes(r)).first
+        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
+