hobo 1.1.0 → 1.3.0.RC

data/lib/hobo/tasks/rails.rb

@@ -1,4 +0,0 @@
-# This file is used to load the Hobo rake tasks when running Hobo as a gem
-
-tasks_home = File.join File.dirname(__FILE__), "..", "..", "..", "tasks"
-Dir["#{tasks_home}/**/*.rake"].sort.each { |ext| load ext }

data/lib/hobo/translations.rb

@@ -1,93 +0,0 @@
-module Hobo
-
-  module Translations
-
-    # --- 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
-    # 
-    # Otherwise with features as the ht method, step 1, 2 and 3 above. 
-    def self.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
-      
-      # 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
-    
-      # add :"hobo.#{key}" as the first fallback
-      options[:default].unshift("hobo.#{subkey}".to_sym)
-    
-      # translate the model
-      unless model.blank?
-        translated_model = I18n.translate( "activerecord.models.#{model.singularize.underscore}", :default=>model).titleize
-        options[:model] = translated_model
-      end
-    
-      key_prefix = "<span class='translation-key'>#{key}</span>" if defined?(HOBO_SHOW_LOCALE_KEYS) && HOBO_SHOW_LOCALE_KEYS
-    
-      Rails.logger.info "..translate(#{key}, #{options.inspect}) to #{I18n.locale}" if defined?(HOBO_VERBOSE_TRANSLATIONS)
-      
-      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
-    end
-
-    # if somebody includes us, give them ht as an instance method
-    def self.included(base)
-      translation_class = self
-      base.class_eval do
-        define_method :ht do |*args|
-          translation_class.ht(*args)
-        end
-      end
-    end
-  end
-end

data/lib/hobo/undefined_access_error.rb

@@ -1,5 +0,0 @@
-module Hobo
-
-  class UndefinedAccessError < RuntimeError; end
-
-end

data/lib/hobo/user.rb

@@ -1,182 +0,0 @@
-require 'digest/sha1'
-
-module Hobo
-
-  module User
-
-    @user_models = []
-
-    def self.default_user_model
-      @user_models.first._?.constantize
-    end
-
-    AUTHENTICATION_FIELDS = [:salt, :crypted_password, :remember_token, :remember_token_expires_at]
-
-    # Extend the base class with AuthenticatedUser functionality
-    # This includes:
-    # - plaintext password during login and encrypted password in the database
-    # - plaintext password validation
-    # - login token for rembering a login during multiple browser sessions
-    def self.included(base)
-      @user_models << base.name
-
-      base.extend(ClassMethods)
-
-      base.class_eval do
-
-        fields do
-          crypted_password          :string, :limit => 40
-          salt                      :string, :limit => 40
-          remember_token            :string
-          remember_token_expires_at :datetime
-        end
-
-        validates_confirmation_of :password,              :if => :new_password_required?
-        validate :validate_password
-        validate :validate_current_password_when_changing_password
-
-        # Virtual attributes for setting and changing the password
-        # note that :password_confirmation= is also defined by
-        # validates_confirmation_of, so this line must follow any
-        # validates_confirmation_of statements.
-        # https://hobo.lighthouseapp.com/projects/8324-hobo/tickets/530
-        attr_accessor :current_password, :password, :password_confirmation, :type => :password
-
-        before_save :encrypt_password
-        after_save :stash_current_password
-
-        never_show *AUTHENTICATION_FIELDS
-
-        attr_protected *AUTHENTICATION_FIELDS
-
-
-      end
-    end
-
-    # Additional classmethods for authentication
-    module ClassMethods
-
-      def login_attribute=(attr, validate=true)
-        @login_attribute = attr = attr.to_sym
-        unless attr == :login
-          alias_attribute(:login, attr)
-          declare_attr_type(:login, attr_type(attr)) if table_exists? # this breaks if the table doesn't exist
-        end
-
-        if validate
-          validates_length_of     attr, :within => 3..100
-          validates_uniqueness_of attr, :case_sensitive => false
-        end
-      end
-
-      inheriting_cattr_reader :login_attribute
-
-
-      # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
-      def authenticate(login, password)
-        u = find(:first, :conditions => ["#{@login_attribute} = ?", login]) # need to get the salt
-
-        if u && u.authenticated?(password)
-          if u.respond_to?(:last_login_at) || u.respond_to?(:login_count)
-            u.last_login_at = Time.now if u.respond_to?(:last_login_at)
-            u.login_count = (u.login_count.to_i + 1) if u.respond_to?(:login_count)
-            u.save
-          end
-          u
-        else
-          nil
-        end
-      end
-
-      # Encrypts some data with the salt.
-      def encrypt(password, salt)
-        Digest::SHA1.hexdigest("--#{salt}--#{password}--")
-      end
-
-    end
-
-    def account_active?
-      lifecycle.active_state?
-    end
-
-    # Encrypts the password with the user salt
-    def encrypt(password)
-      self.class.encrypt(password, salt)
-    end
-
-    # Check if the encrypted passwords match
-    def authenticated?(password)
-      crypted_password == encrypt(password)
-    end
-
-    # Do we still need to remember the login token, or has it expired?
-    def remember_token?
-      remember_token_expires_at && Time.now.utc < remember_token_expires_at
-    end
-
-    # These create and unset the fields required for remembering users between browser closes
-    def remember_me
-      self.remember_token_expires_at = 2.weeks.from_now.utc
-      self.remember_token            = encrypt("#{login}--#{remember_token_expires_at}")
-      save(false)
-    end
-
-    # Expire the login token, resulting in a forced login next time.
-    def forget_me
-      self.remember_token_expires_at = nil
-      self.remember_token            = nil
-      save(false)
-    end
-
-    def guest?
-      false
-    end
-
-    def signed_up?
-      true
-    end
-
-    protected
-    # Before filter that encrypts the password before having it stored in the database.
-    def encrypt_password
-      return if password.blank?
-      self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if salt.blank?
-      self.crypted_password = encrypt(password)
-    end
-
-    # after filter that sets current_password so we can pass
-    # validate_current_password_when_changing_password if you save
-    # again.  See
-    # https://hobo.lighthouseapp.com/projects/8324-hobo/tickets/590
-    def stash_current_password
-      @current_password ||= password
-    end
-
-    def changing_password?
-      !new_record? && !lifecycle_changing_password? &&
-        (current_password.present? || password.present? || password_confirmation.present?)
-    end
-    
-    
-    def lifecycle_changing_password?
-      self.class.has_lifecycle? && lifecycle.active_step && :password.in?(lifecycle.active_step.parameters)
-    end
-
-    # Is a new password (and confirmation) required? (i.e. signing up or changing password)
-    def new_password_required?
-      lifecycle_changing_password? || changing_password?
-    end
-
-
-    def validate_current_password_when_changing_password
-      changing_password? && !authenticated?(current_password) and errors.add :current_password, Hobo::Translations.ht("hobo.messages.current_password_is_not_correct", :default => "is not correct")
-    end
-
-    # Validation of the plaintext password.   Override this function
-    # to change your validation.
-    def validate_password
-      errors.add(:password, Hobo::Translations.ht("hobo.messages.validate_password", :default => "must be at least 6 characters long and must not consist solely of lowercase letters.")) if new_password_required? && (password.nil? || password.length<6 || /^[[:lower:]]*$/.match(password))
-    end
-  end
-
-end

data/lib/hobo/view_hints.rb

@@ -1,115 +0,0 @@
-module Hobo
-  
-  class ViewHints
-    
-    def self.enable
-      if ActiveSupport::Dependencies.respond_to?(:autoload_paths)
-        ActiveSupport::Dependencies.autoload_paths |= [ "#{RAILS_ROOT}/app/viewhints" ]
-      else
-        ActiveSupport::Dependencies.load_paths |= [ "#{RAILS_ROOT}/app/viewhints" ]
-      end
-    end
-  
-    def self.setter(name, default=nil, &block)
-      ivname = name.to_s.remove(/\?$/)
-      metaclass.send :define_method, name do |*args|
-        if args.empty?
-          val = instance_variable_get("@#{ivname}")
-          if val.nil?
-            val = default.is_a?(Proc) ? instance_eval(&default) : default
-            instance_variable_set("@#{ivname}", val)
-          end
-          val
-        else 
-          arg = if block
-                  instance_exec(*args, &block)
-                else
-                  args.first
-                end
-          instance_variable_set("@#{ivname}", arg)
-        end
-      end
-    end
-
-    setter :field_names, {}
-    
-    setter :field_help,  {}
-    
-    setter :children,    [] do |*args|
-      # Setting children also gives a default parent using the reverse association
-      child_model = model.reflections[args.first].klass
-      if child_model.view_hints.parent.nil? and !child_model.view_hints.parent_defined
-        parent = model.reverse_reflection(args.first)
-        child_model.view_hints.parent(parent.name, :undefined => true) if parent
-      end
-      args
-    end
-    
-    setter :parent,         nil do |*args|
-      options = args.extract_options!
-      parent_defined(true) unless options[:undefined]
-      args.first
-    end
-
-    setter :parent_defined, nil
-    
-    setter :paginate?,    proc { !sortable? }
-    
-    setter :sortable?,    proc { defined?(ActiveRecord::Acts::List::InstanceMethods) && 
-                                 model < ActiveRecord::Acts::List::InstanceMethods &&
-                                 model.new.try.scope_condition == "1 = 1" }
-
-    setter :inline_booleans, [] do |*args|
-     if args[0] == true
-       model.columns.select { |c| c.type == :boolean }.*.name
-     else
-       args.*.to_s
-     end
-    end
-
-    # Accessors
-
-    class << self
-
-      def _name
-        @_name ||= name.sub(/Hints$/, '')
-      end
-      
-      def model_name(new_name=nil)
-        if new_name.nil?
-          @model_name ||= Hobo::Translations.ht("#{_name.tableize}.model_name", :default => _name.titleize)
-        else
-          @model_name = Hobo::Translations.ht("#{_name.tableize}.model_name", :default => new_name)
-        end
-      end
-                
-      def model_name_plural(new_name=nil)
-        if new_name.nil?
-          @model_name_plural ||= Hobo::Translations.ht("#{_name.tableize}.model_name_plural", :default => model_name.pluralize)
-        else
-          @model_name_plural = Hobo::Translations.ht("#{_name.tableize}.model_name_plural", :default => new_name)
-        end
-      end
-          
-      def model
-        @model ||= _name.constantize
-      end
-        
-
-      def field_name(field)
-        Hobo::Translations.ht("#{_name.tableize}.#{field}", :default => field_names.fetch(field.to_sym, field.to_s.titleize))
-      end
-    
-      def primary_children
-        children.first
-      end
-      
-      def secondary_children
-        children.rest
-      end
-      
-    end
-    
-  end
-  
-end    

data/rails/init.rb

@@ -1,10 +0,0 @@
-module ::Hobo
-  class << self
-    attr_accessor :rails_initializer
-  end
-end
-::Hobo.rails_initializer = initializer
-
-require File.dirname(__FILE__) + "/../lib/hobo"
-require 'rails_generator'
-Hobo.enable

data/rails_generators/hobo/USAGE

@@ -1,4 +0,0 @@
-Description:
-
-    Adds support for the basic Hobo & DRYML system, not including
-    Rapid.

data/rails_generators/hobo/hobo_generator.rb

@@ -1,53 +0,0 @@
-class HoboGenerator < Rails::Generator::Base
-
-  def manifest
-    if options[:add_gem]
-      add_to_file "config/environment.rb", "Rails::Initializer.run do |config|", "  config.gem 'hobo'\n"
-      add_to_file "Rakefile", "require 'tasks/rails'", "\nrequire 'hobo/tasks/rails'"
-    end
-    
-    if options[:add_routes]
-      add_to_file "config/routes.rb", "ActionController::Routing::Routes.draw do |map|", "\n  Hobo.add_routes(map)\n"
-    end
-
-    record do |m|
-      m.directory                     File.join("app/views/taglibs")
-      m.directory                     File.join("app/views/taglibs/themes")
-      m.template "application.dryml", File.join("app/views/taglibs/application.dryml")
-      m.directory                     File.join("public/hobothemes")
-
-      m.directory                     File.join("app/models")
-      m.file "guest.rb",              File.join("app/models/guest.rb")
-
-      m.directory                     File.join("public/stylesheets")
-      m.file "application.css",       File.join("public/stylesheets/application.css")
-      m.file "dryml-support.js",      File.join("public/javascripts/dryml-support.js")
-
-      m.file "initializer.rb",        File.join("config/initializers/hobo.rb")
-    end
-  end
-  
-  protected
-    def banner
-      "Usage: #{$0} #{spec.name} [--add-routes] [--add-gem]"
-    end
-
-    def add_options!(opt)
-      opt.separator ''
-      opt.separator 'Options:'
-      opt.on("--add-routes",
-             "Add Hobo routes to config/routes.rb") { |v| options[:add_routes] = v }
-      opt.on("--add-gem",
-             "Edit environment.rb to require the hobo gem") { |v| options[:add_gem] = v }
-    end
-    
-    def add_to_file(filename, after_line, new_line)
-      filename = File.join(RAILS_ROOT, filename)
-      src = File.read filename
-      unless src.include? new_line
-        src.sub!(after_line, after_line + "\n" + new_line)
-        File.open(filename, 'w') {|f| f.write(src) }
-      end
-    end
-
-end