hobo 1.3.0.RC4 → 1.3.0.pre10

data/lib/hobo/helper/translations.rb

@@ -2,52 +2,103 @@ module Hobo
   module Helper
     module Translations
 
-      include Normalizer
-
-=begin
-
-hobo_translate / ht
-
-Wrapper around the Rails :translate helper with hobo added features.
-
-It can be used as a regular helper or as a dryml tag.
-
-Hobo Added Features
-
-The first part of the key must be a model name (e.g.: user.index.title -> user). This method will add a "model" interpolation variable set to the translated and pluralized Model.model_name.human. Besides, it will add a default 'hobo.' fallback, (e.g.: hobo.index.title) at the beginning of the fallback chain.
-
-You can also pass any other :translate option like for example :count.
+      # --- Translation Helper --- #
+      #
+      # Uses RoR native I18n.translate.
+      #
+      # Adds some conventions for easier hobo translation.
+      # 1. Assumes the first part of the key to be a model name (e.g.: users.index.title -> user)
+      # 2. Tries to translate the model by lookup for: (e.g.: user-> activerecord.models.user)
+      # 3. Adds a default fallback to the beginning of the fallback chain
+      #    by replacing the first part of the key with "hobo" and using the translated model name
+      #    as additional attribute. This allows us to have default translations
+      #    (e.g.: hobo.index.title: "{{model}} Index")
+      #
+      # Is also used as a tag in the dryml-view files. The syntax is:
+      # <ht key="my.app">My Application</ht>
+      #   --> Will lookup the "my.app"-key for your locale and replaces the "My Application" content
+      #       if found.
+      #
+      # <ht key="my" app="Program">My Application</ht>
+      #   --> Will look up both the "my"- and "app"-key for your locale, and replaces the
+      #       "My Application" with the "my"-key contents (interpolated using the "app"-key.
+      #       sample.en.yml-file:
+      #       "no":
+      #         my: "Mitt {{app}}"
+      #       The output should be: Mitt Program
+      #
+      # The "count" option set the integer passed or to the Model.count if : dynamic is passed.
+      # The following lines are the same:
+      #
+      # <ht key="modelname.any.key" count="&:dynamic">
+      # <ht key="modelname.any.key" count="&model.count">
+      #
+      # Otherwise with features as the ht method, step 1, 2 and 3 above.
+      def ht(key, options={})
+
+        # Check if called as a tag, i.e. like this <ht></ht>
+        if (key.class == Hash)
+          if key.has_key?(:default) && !key[:default].blank?
+            Rails.logger.warn "hobo-i18n: 'default' should not be used as an attribute on the ht-tag. If used, then you need to make sure that the tags inner-contents are not used. These are normally treated as defaults automatically, but if there is a default attribute then that inner-content will be hidden from this method - and will not be replaced with the translation found."
+          end
+          defaults = options[:default];
+          # Swap key and options, remove options[:key]
+          options = key
+          key = options.delete(:key) # returns value for options[:key] as well as deleting it
+          # Set options[:default] to complete the tag-argument-conversion process.
+          options[:default] = (defaults.class == Proc) ? [defaults.call(options)] : (options[:default].blank? ? [] : [options[:default]])
+        else
+          # Not called as a tag. Prepare options[:default].
+          if options[:default].nil?
+            options[:default]=[]
+          elsif options[:default].class != Array
+            options[:default] = [options[:default]]
+          end
+        end
 
-Example:
+        # assume the first part of the key to be the model
+        keys = key.to_s.split(".")
+        if keys.length > 1
+          model = keys.shift()
+          subkey = keys.join(".")
+        else
+          subkey = key
+        end
 
-<%= ht :key=>'user.index.title', :default=>'Index'  %>
-<ht key="user.index.title">Index</ht>
-#=> "Index" # if "user.index.title" or "hobo.index.title" is not found
-#=> "User Index" # with the below en.yml file
+        # will skip useless code in case the first part of the key is 'hobo'
+        model = '' if model.eql?('hobo')
+
+        unless model.blank?
+          klass = begin
+                    model.singularize.camelize.constantize
+                  rescue NameError
+                  end
+          # add :"hobo.#{key}" as the first fallback
+          options[:default].unshift("hobo.#{subkey}".to_sym)
+          # set the count option in order to allow multiple pluralization
+          count = options.delete(:count)
+          count = default_count if count.blank?
+          c = count.try.to_i || count==:dynamic && klass.try.count
+          # translate the model
+          # the singularize method is used because Hobo does not keep the ActiveRecord convention in its tags
+          # no default needed because human_name defaults to the model name
+          # try because Hobo class is not an ActiveRecord::Base subclass
+          translated_pluralized_model = klass.try.model_name.try.human(:count=>c)
+          options[:model] = translated_pluralized_model
+        end
+        options[:count] = c
 
-=== en.yml ===
-en:
-  hobo:
-    index:
-      title: %{model} Index
+        key_prefix = "<span class='translation-key'>#{key}</span>" if defined?(HOBO_SHOW_LOCALE_KEYS) && HOBO_SHOW_LOCALE_KEYS
 
-=end
+        Rails.logger.info "..translate(#{key}, #{options.inspect}) to #{I18n.locale}" if defined?(HOBO_VERBOSE_TRANSLATIONS)
 
-      def hobo_translate(*args)
-        key, options = normalize_args(*args)
-        keys = key.to_s.split(".")
-        model_name = keys.shift
-        model_class = begin model_name.camelize.constantize; rescue; end
-        unless model_class && model_class < ActiveRecord::Base
-          raise Hobo::I18nError, %(wrong model name: "#{model_name}" (extracted from translation key: "#{key}"). You might want to use the translate/t tag/method instead.)
+        translation = I18n.translate(key.to_sym, options)
+        if translation.respond_to? :to_str
+          key_prefix ? translation.to_str+key_prefix : translation
+        else
+          "translation invalid: #{key}"
         end
-        options[:default].unshift("hobo.#{keys.join(".")}".to_sym)
-        options[:model] = model_class.model_name.human(:count=>(options[:count] || 1).to_i)
-        translate key.to_sym, options
       end
-      alias_method :ht, :hobo_translate
-
-
 
     end
   end

data/lib/hobo/model.rb

@@ -33,6 +33,14 @@ module Hobo
         alias_method_chain :attr_accessor, :creator_metadata
 
         alias_method_chain :has_one, :new_method
+
+        def inherited(klass)
+          super
+          fields(false) do
+            Hobo.register_model(klass)
+            field(klass.inheritance_column, :string)
+          end
+        end
       end
 
       base.fields(false) # force hobo_fields to load
@@ -45,45 +53,18 @@ module Hobo
 
         WillPaginate::Collection.class_eval do
           attr_accessor :member_class, :origin, :origin_attribute
-
-          # make paginate_by_sql, etc. carry metadata
-          def replace_with_hobo_metadata(array)
-            result = replace_without_hobo_metadata(array)
-            self.member_class = array.try.member_class
-            self.origin = array.try.origin
-            self.origin_attribute = array.try.origin_attribute
-            result
-          end
-          alias_method_chain :replace, :hobo_metadata
         end
 
-        WillPaginate::ActiveRecord::Pagination.class_eval do
-
-          def apply_hobo_metadata(collection)
-            klass = Object.instance_method(:class).bind(self).call
-            is_relation = klass <= ActiveRecord::Relation
-            is_association_proxy = klass <= ActiveRecord::Associations::AssociationProxy
-            collection.member_class     = (is_relation || is_association_proxy) ? member_class : self
+        WillPaginate::Finders::Base.class_eval do
+          def paginate_with_hobo_metadata(*args, &block)
+            collection = paginate_without_hobo_metadata(*args, &block)
+            collection.member_class     = self
             collection.origin           = try.proxy_owner
             collection.origin_attribute = try.proxy_reflection._?.name
             collection
           end
-
-          # NOTE: as of will_paginate 3.0.0, the standard paginate method calls the page method.
-          # However, it converts an association proxy into a relation first (via adding a limit clause),
-          # which causes the proxy_owner and proxy_reflection methods to disappear.
-          def paginate_with_hobo_metadata(*args, &block)
-            collection = paginate_without_hobo_metadata(*args, &block)
-            apply_hobo_metadata(collection)
-          end
           alias_method_chain :paginate, :hobo_metadata
 
-          def page_with_hobo_metadata(*args, &block)
-            collection = page_without_hobo_metadata(*args, &block)
-            apply_hobo_metadata(collection)
-          end
-          alias_method_chain :page, :hobo_metadata
-
         end
 
       end
@@ -132,6 +113,7 @@ module Hobo
       end
     end
 
+
     module ClassMethods
 
       # TODO: should this be an inheriting_cattr_accessor as well? Probably.
@@ -157,22 +139,10 @@ module Hobo
         self.creator_attribute         = name.to_sym if options.delete(:creator)
         validate = options.delete(:validate) {true}
 
-        #FIXME - this should be in Hobo::Model::UserBase
+        #FIXME - this should be in Hobo::Model::User
         send(:login_attribute=, name.to_sym, validate) if options.delete(:login) && respond_to?(:login_attribute=)
       end
 
-      # eval avoids the ruby 1.9.2 "super from singleton method ..." error
-      eval %(
-        def inherited(klass)
-          super
-          Hobo::Model.register_model(klass)
-          # TODO: figure out when this is needed, as Hobofields already does this
-          fields(false) do
-            field(klass.inheritance_column, :string)
-          end
-        end
-      )
-
       private
 
       def attrib_names
@@ -189,27 +159,22 @@ module Hobo
       def belongs_to_with_test_methods(name, options={}, &block)
         belongs_to_without_test_methods(name, options, &block)
         refl = reflections[name]
-        id_method = refl.options[:primary_key] || refl.klass.primary_key
         if options[:polymorphic]
           # TODO: the class lookup in _is? below is incomplete; a polymorphic association to an STI base class
           #       will fail to match an object of a derived type
           #       (ie X belongs_to Y (polymorphic), Z is a subclass of Y; @x.y_is?(some_z) will never pass)
           class_eval %{
             def #{name}_is?(target)
-              target.class.name == self.#{refl.options[:foreign_type]} && target.#{id_method} == self.#{refl.primary_key_name}
+              target.class.name == self.#{refl.options[:foreign_type]} && target.id == self.#{refl.primary_key_name}
             end
             def #{name}_changed?
               #{refl.primary_key_name}_changed? || #{refl.options[:foreign_type]}_changed?
             end
           }
         else
-          id_method = refl.options[:primary_key] || refl.klass.primary_key
           class_eval %{
             def #{name}_is?(target)
-              our_id = self.#{refl.primary_key_name}
-              # if our_id is nil, only return true if target is nil
-              return target.nil? unless our_id
-              target.class <= ::#{refl.klass.name} && target.#{id_method} == our_id
+              target.class <= ::#{refl.klass.name} && target.id == self.#{refl.primary_key_name}
             end
             def #{name}_changed?
               #{refl.primary_key_name}_changed?
@@ -365,20 +330,7 @@ module Hobo
 
       def view_hints
         class_name = "#{name}Hints"
-        class_name.safe_constantize or Object.class_eval("class #{class_name} < Hobo::Model::ViewHints; end; #{class_name}")
-      end
-
-      def children(*args)
-        view_hints.children *args
-      end
-
-      def inline_booleans(*args)
-        view_hints.inline_booleans *args
-      end
-
-      def table_exists?
-        @table_exists_cache = super if @table_exists_cache.nil?
-        @table_exists_cache
+        class_name.safe_constantize or Object.class_eval("class #{class_name} < Hobo::ViewHints; end; #{class_name}")
       end
 
 
@@ -389,7 +341,7 @@ module Hobo
 
 
     def to_url_path
-      "#{self.class.to_url_path}/#{to_param}"
+      "#{self.class.to_url_path}/#{to_param}" unless new_record?
     end
 
 
@@ -470,11 +422,7 @@ module Hobo
           if parts.include?(0)
             nil
           else
-            begin
-              Date.new(*parts)
-            rescue ArgumentError => ex
-              Time.time_with_datetime_fallback(ActiveRecord::Base.default_timezone, *parts).to_date
-            end
+            Date.new(*parts)
           end
         else
           value
@@ -486,7 +434,7 @@ module Hobo
           if parts[0..2].include?(0)
             nil
           else
-            field_type <= Time ? Time.utc(*parts) : Time.zone.local(*parts)
+            Time.zone ? Time.zone.local(*parts) : Time.local(*parts)
           end
         else
           value

data/lib/hobo/model/lifecycles.rb

@@ -34,7 +34,7 @@ module Hobo
 
             module_eval "class ::#{name}::LifecycleStateField < HoboFields::Types::LifecycleState; end"
             state_field_class = self::LifecycleStateField
-            state_field_class.model_name = name
+            state_field_class.table_name = name.tableize
           end
 
           dsl = Hobo::Model::Lifecycles::DeclarationDSL.new(lifecycle)
@@ -56,15 +56,14 @@ module Hobo
 
         end
 
-        # eval avoids the ruby 1.9.2 "super from singleton method ..." error
-        eval %(
-          def valid?(context=nil)
-            if context.nil? && self.class.has_lifecycle? && (step = lifecycle.active_step)
-              context = step.name
-            end
-            super(context)
+
+        def valid?(context=nil)
+          if context.nil? && self.class.has_lifecycle? && (step = lifecycle.active_step)
+            context = step.name
           end
-        )
+          super(context)
+        end
+
 
         def lifecycle
           @lifecycle ||=  if self.class.const_defined?(:Lifecycle)
@@ -103,9 +102,9 @@ module Hobo
         end
 
         def transition(name, change, options={}, &block)
-          change.each do |k,v|
-		    @lifecycle.def_transition(name, Array(k), v, block, options)
-          end
+          @lifecycle.def_transition(name,
+                                    Array(change.keys.first), change.values.first,
+                                    block, options)
         end
 
         def invariant(&block)

data/lib/hobo/model/lifecycles/lifecycle.rb

@@ -41,7 +41,7 @@ module Hobo
           Creator.new(self, name.to_s, on_create, options)
         end
 
-        def self.def_transition(name, start_states, end_state, on_transition, options)
+        def self.def_transition(name, start_state, end_states, on_transition, options)
           class_eval %{
                        def #{name}!(user, attributes=nil)
                          transition(:#{name}, user, attributes)
@@ -50,7 +50,7 @@ module Hobo
                          can_transition?(:#{name}, user)
                        end
                       }
-          Transition.new(self, name.to_s, start_states, end_state, on_transition, options)
+          Transition.new(self, name.to_s, start_state, end_states, on_transition, options)
         end
 
         def self.state_names
@@ -149,11 +149,7 @@ module Hobo
         end
 
         def publishable_transitions_for(user)
-          record.with_acting_user(user) do
-            available_transitions_for(user).select do |t|
-              t.publishable_by(user, t.available_to, record)
-            end
-          end
+          available_transitions_for(user).select {|t| t.publishable_by(user, t.available_to, record)}
         end
 
 
@@ -202,7 +198,7 @@ module Hobo
           timestamp = record.read_attribute(key_timestamp_field)
           if timestamp
             timestamp = timestamp.getutc
-            Digest::SHA1.hexdigest("#{record.id}-#{state_name}-#{timestamp}-#{Rails.application.config.secret_token}")
+            Digest::SHA1.hexdigest("#{record.id}-#{state_name}-#{timestamp}")
           end
         end
 
@@ -215,10 +211,6 @@ module Hobo
           provided_key && provided_key == key && !key_expired?
         end
 
-        def clear_key
-          record.send :write_attribute, key_timestamp_field, nil
-        end
-
         def invariants_satisfied?
           self.class.invariants.all? { |i| record.instance_eval(&i) }
         end

data/lib/hobo/model/lifecycles/transition.rb

@@ -34,7 +34,6 @@ module Hobo
 
 
         def change_state(record)
-          record.lifecycle.clear_key unless options[:new_key] || options[:keep_key]
           record.lifecycle.become(get_state(record, end_state))
         end
 

data/lib/hobo/model/permissions.rb

@@ -19,6 +19,8 @@ module Hobo
           attr_accessor :acting_user, :origin, :origin_attribute
 
           bool_attr_accessor :exempt_from_edit_checks
+
+          define_callbacks :after_user_new
         end
       end
 
@@ -46,7 +48,7 @@ module Hobo
             r.set_creator user
             yield r if block_given?
             r.user_view(user)
-            r.with_acting_user(user) { r.try.after_user_new }
+            r.with_acting_user(user) { r.send :run_callbacks, :after_user_new }
           end
         end
 
@@ -161,7 +163,6 @@ module Hobo
 
 
       def with_acting_user(user)
-        return yield if user == acting_user
         old = acting_user
         self.acting_user = user
         result = yield

data/lib/hobo/model/scopes/apply_scopes.rb

@@ -4,7 +4,7 @@ module Hobo
       module ApplyScopes
 
         def apply_scopes(scopes)
-          result = scoped
+          result = self
           scopes.each_pair do |scope, arg|
             if arg.is_a?(Array)
               result = result.send(scope, *arg) unless arg.first.blank?