padrino-core 0.2.9 → 0.4.5

data/Rakefile

@@ -12,6 +12,7 @@ begin
     gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
     gem.executables = ["padrino"]
     gem.add_runtime_dependency     "sinatra",       ">= 0.9.2"
+    gem.add_runtime_dependency     "i18n",          ">= 0.3.2"
     gem.add_runtime_dependency     "thor",          ">= 0.11.8"
     gem.add_development_dependency "haml",          ">= 2.2.1"
     gem.add_runtime_dependency     "bundler",       ">= 0.5.0"
@@ -28,7 +29,7 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
+  test.libs << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end

data/VERSION

@@ -1 +1 @@
-0.2.9
+0.4.5

data/bin/padrino

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 %w[rubygems thor].each { |gem| require gem }
-require File.dirname(__FILE__) + "/../lib/padrino-core/support_lite"
 require File.dirname(__FILE__) + "/../lib/padrino-core/tasks"
 
 arguments = ARGV.any? ? ARGV : ['-h']

data/lib/padrino-core/application.rb

@@ -28,16 +28,29 @@ module Padrino
         include(*extensions)  if extensions.any?
       end
 
+      # With this method we can use layout like rails do or if a block given like sinatra
+      # By default we look in your/app/views/layouts/application.(haml|erb|etc)
+      # 
+      # If you define:
+      # 
+      #   layout :custom
+      # 
+      # Padrino look for your/app/views/layouts/custom.(haml|erb|etc)
+      def layout(name=:layout, &block)
+        return super if block_given?
+        @_layout = name
+      end
+
       # Reloads the application files from all defined load paths
       def reload!
         reset_routes! # remove all existing user-defined application routes
         Padrino.load_dependency(self.app_file)  # reload the app file
-        load_paths.each { |path| Padrino.load_dependencies(File.join(self.root, path)) }
+        load_paths.each { |path| Padrino.load_dependencies(File.join(self.root, path)) } # reload dependencies
       end
 
       # Resets application routes to only routes not defined by the user
       def reset_routes!
-        @routes = Padrino::Application.dupe_routes
+        @routes = Padrino::Application.respond_to?(:dupe_routes) ? Padrino::Application.dupe_routes : {}
       end
 
       # Setup the application by registering initializers, load paths and logger
@@ -49,81 +62,134 @@ module Padrino
         self.register_initializers
         self.require_load_paths
         self.disable :logging # We need do that as default because Sinatra use commonlogger.
+        I18n.locale = self.locale
+        I18n.load_path += self.translations
+        self.get(""){ redirect("#{options.uri_root}/") } if self.uri_root != "/"
         @_configured = true
       end
 
       protected
+        # Defines default settings for Padrino application
+        def default_configuration!
+          # Overwriting Sinatra defaults
+          set :app_file, caller_files.first || $0 # Assume app file is first caller
+          set :environment, PADRINO_ENV.to_sym
+          set :raise_errors, true if development?
+          set :logging, false # !test?
+          set :sessions, true
+          # Padrino specific
+          set :uri_root, "/"
+          set :reload, development?
+          set :app_name, self.to_s.underscore.to_sym
+          set :default_builder, 'StandardFormBuilder'
+          set :flash, defined?(Rack::Flash)
+          set :authentication, false
+          # Padrino locale
+          set :locale, :en
+          set :translations, Proc.new { Dir[File.join(self.root, "/locale/**/*.{rb,yml}")] }
+          set :auto_locale, false
+          # Plugin specific
+          set :padrino_mailer, defined?(Padrino::Mailer)
+          set :padrino_helpers, defined?(Padrino::Helpers)
+        end
 
-      # Defines default settings for Padrino application
-      def default_configuration!
-        # Overwriting Sinatra defaults
-        set :app_file, caller_files.first || $0 # Assume app file is first caller
-        set :environment, PADRINO_ENV.to_sym
-        set :raise_errors, true if development?
-        set :logging, false#!test?
-        set :sessions, true
-        # Padrino specific
-        set :reload, development?
-        set :app_name, self.to_s.underscore.to_sym
-        set :default_builder, 'StandardFormBuilder'
-        set :flash, defined?(Rack::Flash)
-        # Plugin specific
-        set :padrino_mailer, defined?(Padrino::Mailer)
-        set :padrino_helpers, defined?(Padrino::Helpers)
-      end
+        # Calculates any required paths after app_file and root have been properly configured
+        # Executes as part of the setup_application! method
+        def calculate_paths
+          raise ApplicationSetupError.new("Please define 'app_file' option for #{self.name} app!") unless self.app_file
+          set :views, find_view_path if find_view_path
+          set :images_path, File.join(self.public, "/images") unless self.respond_to?(:images_path)
+        end
 
-      # Calculates any required paths after app_file and root have been properly configured
-      # Executes as part of the setup_application! method
-      def calculate_paths
-        raise ApplicationSetupError.new("Please define 'app_file' option for #{self.name} app!") unless self.app_file
-        set :views, find_view_path if find_view_path
-        set :images_path, File.join(self.public, "/images") unless self.respond_to?(:images_path)
-      end
+        # Requires the middleware and initializer modules to configure components
+        def register_initializers
+          use Padrino::RackLogger
+          use Padrino::Reloader   if reload?
+          use Rack::Flash         if flash?
+          register DatabaseSetup  if defined?(DatabaseSetup)
+          @initializer_path ||= Padrino.root + '/config/initializers/*.rb'
+          Dir[@initializer_path].each { |file| register_initializer(file) }
+        end
 
-      # Requires the middleware and initializer modules to configure components
-      def register_initializers
-        use Padrino::RackLogger
-        use Padrino::Reloader              if reload?
-        use Rack::Flash                    if flash?
-        register DatabaseSetup             if defined?(DatabaseSetup)
-        @initializer_path ||= Padrino.root + '/config/initializers/*.rb'
-        Dir[@initializer_path].each { |file| register_initializer(file) }
-      end
+        # Registers all desired padrino extension helpers/routing
+        def register_framework_extensions
+          register Padrino::Mailer        if padrino_mailer?
+          register Padrino::Helpers       if padrino_helpers?
+          register Padrino::AccessControl if authentication?
+        end
 
-      # Registers all desired padrino extension helpers/routing
-      def register_framework_extensions
-        register Padrino::Mailer   if padrino_mailer?
-        register Padrino::Helpers  if padrino_helpers?
-      end
+        # Returns the load_paths for the application (relative to the application root)
+        def load_paths
+          @load_paths ||= ["urls.rb", "config/urls.rb", "models/*.rb", "mailers/*.rb", "controllers/**/*.rb", "helpers/*.rb"]
+        end
 
-      # Requires all files within the application load paths
-      def require_load_paths
-        load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
-      end
+        # Requires all files within the application load paths
+        def require_load_paths
+          load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
+        end
+
+        # Returns the path to the views directory from root by returning the first that is found
+        def find_view_path
+          @view_paths = ["views"].collect { |path| File.join(self.root, path) }
+          @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
+        end
 
-      # Returns the load_paths for the application (relative to the application root)
-      def load_paths
-        @load_paths ||= ["urls.rb", "config/urls.rb", "models/*.rb", "app/models/*.rb",
-                         "mailers/*.rb", "app/mailers/*.rb", "controllers/*.rb", "app/controllers/*.rb",
-                         "helpers/*.rb", "app/helpers/*.rb"]
+        # Registers an initializer with the application
+        # register_initializer('/path/to/initializer')
+        def register_initializer(file_path)
+          Padrino.require_dependencies(file_path)
+          file_class = File.basename(file_path, '.rb').camelize
+          register "#{file_class}Initializer".constantize
+        rescue NameError => e
+          logger.error "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!"
+          logger.error "   Initializer error was '#{e.message}'"
+        end
       end
 
-      # Returns the path to the views directory from root by returning the first that is found
-      def find_view_path
-        @view_paths = ["views", "app/views"].collect { |path| File.join(self.root, path) }
-        @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
+    private
+      # Hijacking the sinatra render for do two thing:
+      # 
+      # * Use layout like rails do
+      # * Use render 'path/to/my/template'
+      # 
+      def render(engine, data=nil, options={}, locals={}, &block)
+        @template_cache.clear if Padrino.env != :production && @template_cache && @template_cache.respond_to?(:clear)
+        # If an engine is a string probably is a path so we try to resolve them
+        if data.nil?
+          data   = engine.to_sym
+          engine = resolve_template_engine(engine)
+        end
+        # Use layout as rails do
+        if (options[:layout].nil? || options[:layout] == true) && !self.class.templates.has_key?(:layout)
+          layout = self.class.instance_variable_defined?(:@_layout) ? self.class.instance_variable_get(:@_layout) : :application
+          if layout
+            options[:layout] = File.join('layouts', layout.to_s).to_sym
+            logger.debug "Rendering layout #{options[:layout]}"
+          end
+        end
+        super
       end
 
-      # Registers an initializer with the application
-      # register_initializer('/path/to/initializer')
-      def register_initializer(file_path)
-        Padrino.require_dependencies(file_path)
-        file_class = File.basename(file_path, '.rb').camelize
-        register "#{file_class}Initializer".constantize
-      rescue NameError => e
-        logger.error "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!"
-        logger.error "   Initializer error was '#{e.message}'"
+      # Returns the template engine (i.e haml) to use for a given template_path
+      # resolve_template_engine('users/new') => :haml
+      def resolve_template_engine(template_path)
+        resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
+        template_file = Dir[resolved_template_path].first
+        raise "Template path '#{template_path}' could not be located in views!" unless template_file
+        template_engine = File.extname(template_file)[1..-1].to_sym
+      end
+      
+      # When we set :auto_locale, true then:
+      # 
+      # * if we pass "/:locale/some/foo" we automatically set teh I18n locale to params[:locale]
+      # * if params[:locale] is empty we use the first HTTP_ACCEPT_LANGUAGE
+      def route_eval(&block)
+        if options.auto_locale
+          if params[:locale]
+            I18n.locale = params[:locale].to_sym rescue options.locale
+          end
+        end
+        super
       end
-    end
   end
-end
+end

data/lib/padrino-core/caller.rb

@@ -1,6 +1,6 @@
 module Padrino
   PADRINO_IGNORE_CALLERS = [
-   %r{lib/padrino-.*$},   # all padrino code
+   %r{lib/padrino-.*$},         # all padrino code
    %r{/padrino-.*/(lib|bin)},   # all padrino code
    %r{/bin/padrino$},           # all padrino code
    %r{/sinatra},                # all sinatra code

data/lib/padrino-core/loader.rb

@@ -28,12 +28,6 @@ module Padrino
       Thread.current[:padrino_loaded]
     end
 
-    # Attempts to require all dependencies with bundler; if this fails, uses system wide gems
-    def load_required_gems
-      load_bundler_manifest
-      require_vendored_gems
-    end
-
     # Attempts to require all dependency libs that we need.
     # If you use this method we can perform correctly a Padrino.reload!
     #
@@ -64,22 +58,19 @@ module Padrino
 
     protected
 
-    # Loads the bundler manifest Gemfile if it exists
-    def load_bundler_manifest
+    # Loads the vendored gems or system wide gems through Gemfile
+    def load_required_gems
+      require root('vendor', 'gems', 'environment')
+      Bundler.require_env(Padrino.env)
+      say! "=> Loaded bundled gems for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
+    rescue LoadError
       require 'bundler'
-      say "=> Locating Gemfile for #{PADRINO_ENV}"
-      Bundler::Dsl.load_gemfile(root("Gemfile")).require_env(PADRINO_ENV)
-      say " ... Loaded!"
-    rescue Bundler::ManifestFileNotFound, Bundler::DefaultManifestNotFound => e
-      say " ... Not Found"
-    end
-
-    # Require bundled gems if they exist
-    def require_vendored_gems
-      require_dependencies(root('/../vendor', 'gems', PADRINO_ENV))
-      say! " (Loading bundled gems)"
-    rescue LoadError => e
-      say! " (Loading system gems)"
+      if File.exist?(root("Gemfile"))
+        Bundler::Dsl.load_gemfile(root("Gemfile")).require_env(Padrino.env)
+        say! "=> Located Gemfile for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
+      else
+        say! "=> Gemfile for #{Padrino.env} not found!"
+      end
     end
 
     # Prints out a message to the stdout if not in test environment

data/lib/padrino-core/locale/en.yml

@@ -0,0 +1,33 @@
+en:
+  date:
+    formats:
+      # Use the strftime parameters for formats.
+      # When no format has been given, it uses default.
+      # You can provide other formats here if you like!
+      default: "%Y-%m-%d"
+      short: "%b %d"
+      long: "%B %d, %Y"
+      
+    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
+    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
+      
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
+    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
+    # Used in date_select and datime_select.
+    order: [ :year, :month, :day ]
+
+  time:
+    formats:
+      default: "%a, %d %b %Y %H:%M:%S %z"
+      short: "%d %b %H:%M"
+      long: "%B %d, %Y %H:%M"
+    am: "am"
+    pm: "pm"
+      
+# Used in array.to_sentence.
+  support:
+    array:
+      words_connector: ", "
+      two_words_connector: " and "
+      last_word_connector: ", and "

data/lib/padrino-core/logger.rb

@@ -102,7 +102,7 @@ module Padrino
       @log.sync          = true
       @mutex             = @@mutex[@log] ||= Mutex.new
       @format_datetime   = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
-      @format_message    = options[:format_message] || "%s - [%s] \"%s\""
+      @format_message    = options[:format_message] || "%-5s - [%s] \"%s\""
     end
 
     # Flush the entire buffer to the log object.

data/lib/padrino-core/mounter.rb

@@ -59,7 +59,7 @@ module Padrino
 
     # Returns the root to the mounted apps base directory
     def mounted_root(*args)
-      File.join(Padrino.root, @mounted_root ||= "apps", *args)
+      Padrino.root(@mounted_root ||= "", *args)
     end
 
     # Returns the mounted padrino applications (MountedApp objects)
@@ -79,7 +79,7 @@ module Padrino
     def mount_core(*args)
       options = args.extract_options!
       app_class = args.size > 0 ? args.first.to_s.camelize : nil
-      options.reverse_merge!(:app_class => app_class, :app_file => Padrino.root('app/app.rb'), :app_root => Padrino.root)
+      options.reverse_merge!(:app_class => app_class, :app_file => Padrino.root("app", "app.rb"))
       mount("core", options).to("/")
     end
 

data/lib/padrino-core/stat.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module Padrino
   # What makes it especially suited for use in a any environment is that
   # any file will only be checked once and there will only be made one system

data/lib/padrino-core/support_lite.rb

@@ -13,14 +13,27 @@ Required for Padrino to run:
   * Object#present?
   * Hash#slice, Hash#slice!
   * Hash#to_params
-  * Hash#symbolize_keys
+  * Hash#symbolize_keys, Hash.symbolize_keys!
   * Hash#reverse_merge, Hash#reverse_merge!
   * SupportLite::OrderedHash
 
 =end
+require 'i18n'
+# Load our locales
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-core/locale/*.yml"]
+
+module Padrino
+  # Return the current support used.
+  # Can be one of: :extlib, :active_support
+  def self.support
+    @_padrino_support
+  end
+end
 
 if defined?(Extlib) # load if already using extlib
+  Padrino.instance_variable_set(:@_padrino_support, :extlib)
   require File.dirname(__FILE__) + '/support_lite/extlib_support'
 else # load active support by default
+  Padrino.instance_variable_set(:@_padrino_support, :active_support)
   require File.dirname(__FILE__) + '/support_lite/as_support'
-end
+end

data/lib/padrino-core/support_lite/as_support.rb

@@ -12,7 +12,9 @@ require 'active_support/core_ext/class/attribute_accessors' unless Class.method_
 require 'active_support/core_ext/hash' unless Hash.method_defined?(:reverse_merge)
 ## Hash#to_params
 require 'active_support/core_ext/object' unless Object.method_defined?(:to_query)
-class Hash; alias to_params to_query; end unless Hash.method_defined?(:to_params)
+class Hash; alias :to_params :to_query; end unless Hash.method_defined?(:to_params)
+## Object#with_options
+require 'active_support/option_merger'
 ## String#inflectors
 require 'active_support/inflector' unless String.method_defined?(:constantize)
 ## Object#blank?, Object#present?

data/lib/padrino-core/support_lite/extlib_support.rb

@@ -21,6 +21,10 @@ unless Hash.method_defined?(:symbolize_keys)
     def symbolize_keys
       Mash.new(self).symbolize_keys
     end
+
+    def symbolize_keys!
+      self.replace(symbolize_keys.to_hash)
+    end
   end
 end
 
@@ -28,12 +32,36 @@ end
 unless Hash.method_defined?(:slice)
   require 'extlib/hash'
   class Hash
+    # Slice a hash to include only the given keys. This is useful for
+    # limiting an options hash to valid keys before passing to a method:
+    #
+    #   def search(criteria = {})
+    #     assert_valid_keys(:mass, :velocity, :time)
+    #   end
+    #
+    #   search(options.slice(:mass, :velocity, :time))
+    #
+    # If you have an array of keys you want to limit to, you should splat them:
+    #
+    #   valid_keys = [:mass, :velocity, :time]
+    #   search(options.slice(*valid_keys))
     def slice(*keys)
       keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
       hash = self.class.new
       keys.each { |k| hash[k] = self[k] if has_key?(k) }
       hash
     end
+
+    # Replaces the hash with only the given keys.
+    # Returns a hash contained the removed key/value pairs
+    #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d =>4}
+    def slice!(*keys)
+      keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+      omit = slice(*self.keys - keys)
+      hash = slice(*keys)
+      replace(hash)
+      omit
+    end
   end
 end
 
@@ -43,7 +71,7 @@ unless Hash.method_defined?(:to_params)
 end
 
 ## Hash#reverse_merge, Hash#reverse_merge!
-unless Hash.method_defined?(:present?)
+unless Hash.method_defined?(:reverse_merge)
   class Hash
     def reverse_merge(other_hash)
       other_hash.merge(self)
@@ -52,6 +80,15 @@ unless Hash.method_defined?(:present?)
     def reverse_merge!(other_hash)
       replace(reverse_merge(other_hash))
     end
+
+    def deep_merge(other_hash)
+      target = dup
+      other_hash.each_pair do |k,v|
+        tv = target[k]
+        target[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+      end
+      target
+    end
   end
 end
 
@@ -68,19 +105,22 @@ end
 unless String.method_defined?(:constantize)
   require 'extlib/inflection'
   class String
-    def classify; Extlib::Inflection.classify(self);       end
-    def underscore; Extlib::Inflection.underscore(self);   end
+    def classify;    Extlib::Inflection.classify(self);    end
+    def underscore;  Extlib::Inflection.underscore(self);  end
     def constantize; Extlib::Inflection.constantize(self); end
+    def camelize;    Extlib::Inflection.camelize(self);    end
+    def humanize;    Extlib::Inflection.humanize(self);    end
+    alias :titleize :humanize
   end
 end
 
 ## Object#blank?
-unless Array.method_defined?(:blank?)
+unless Object.method_defined?(:blank?)
   require 'extlib/blank'
 end
 
 ## Object#present?
-unless Array.method_defined?(:present?)
+unless Object.method_defined?(:present?)
   class Object
     def present?
       !blank?
@@ -88,6 +128,37 @@ unless Array.method_defined?(:present?)
   end
 end
 
+## Object#with_options
+unless Object.method_defined?(:with_options)
+  class SupportLite::OptionMerger #:nodoc:
+    instance_methods.each do |method|
+      undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
+    end
+
+    def initialize(context, options)
+      @context, @options = context, options
+    end
+
+    private
+      def method_missing(method, *arguments, &block)
+        if arguments.last.is_a?(Proc)
+          proc = arguments.pop
+          arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
+        else
+          arguments << (arguments.last.respond_to?(:to_hash) ? @options.deep_merge(arguments.pop) : @options.dup)
+        end
+
+        @context.__send__(method, *arguments, &block)
+      end
+  end
+
+  class Object
+    def with_options(options)
+      yield SupportLite::OptionMerger.new(self, options)
+    end
+  end
+end
+
 ## Module#alias_method_chain
 unless Module.method_defined?(:alias_method_chain)
   def alias_method_chain(target, feature)

data/lib/padrino-core/tasks.rb

@@ -78,6 +78,11 @@ module Padrino
           end
           options.boot
         end
+
+      protected
+        def self.banner(task)
+          "padrino-gen #{task.name}"
+        end
     end
   end
 end

data/padrino-core.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-core}
-  s.version = "0.2.9"
+  s.version = "0.4.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2009-12-22}
+  s.date = %q{2010-01-06}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{nesquena@gmail.com}
@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
      "lib/padrino-core/application.rb",
      "lib/padrino-core/caller.rb",
      "lib/padrino-core/loader.rb",
+     "lib/padrino-core/locale/en.yml",
      "lib/padrino-core/logger.rb",
      "lib/padrino-core/mounter.rb",
      "lib/padrino-core/reloader.rb",
@@ -51,9 +52,9 @@ Gem::Specification.new do |s|
      "test/fixtures/apps/simple.rb",
      "test/helper.rb",
      "test/test_application.rb",
+     "test/test_core.rb",
      "test/test_logger.rb",
-     "test/test_padrino_core.rb",
-     "test/test_padrino_mounter.rb",
+     "test/test_mounter.rb",
      "test/test_reloader_complex.rb",
      "test/test_reloader_simple.rb",
      "test/test_server.rb"
@@ -70,6 +71,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<sinatra>, [">= 0.9.2"])
+      s.add_runtime_dependency(%q<i18n>, [">= 0.3.2"])
       s.add_runtime_dependency(%q<thor>, [">= 0.11.8"])
       s.add_development_dependency(%q<haml>, [">= 2.2.1"])
       s.add_runtime_dependency(%q<bundler>, [">= 0.5.0"])
@@ -79,6 +81,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<webrat>, [">= 0.5.1"])
     else
       s.add_dependency(%q<sinatra>, [">= 0.9.2"])
+      s.add_dependency(%q<i18n>, [">= 0.3.2"])
       s.add_dependency(%q<thor>, [">= 0.11.8"])
       s.add_dependency(%q<haml>, [">= 2.2.1"])
       s.add_dependency(%q<bundler>, [">= 0.5.0"])
@@ -89,6 +92,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<sinatra>, [">= 0.9.2"])
+    s.add_dependency(%q<i18n>, [">= 0.3.2"])
     s.add_dependency(%q<thor>, [">= 0.11.8"])
     s.add_dependency(%q<haml>, [">= 2.2.1"])
     s.add_dependency(%q<bundler>, [">= 0.5.0"])

data/test/fixtures/apps/complex.rb

@@ -1,9 +1,7 @@
 PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
 
 module LibDemo
-  module_function
-  
-  def give_me_a_random
+  def self.give_me_a_random
     @rand ||= rand(100)
   end
 end

data/test/helper.rb

@@ -23,7 +23,7 @@ module Kernel
   alias :silence_stdout :silence_logger
 end
 
-class Padrino::Application
+class Class
   # Allow assertions in request context
   include Test::Unit::Assertions
 end
@@ -31,32 +31,23 @@ end
 class Test::Unit::TestCase
   include Rack::Test::Methods
 
-  # Test App
-  class PadrinoTestApp < Padrino::Application; end
-
   # Sets up a Sinatra::Base subclass defined with the block
   # given. Used in setup or individual spec methods to establish
   # the application.
-  def mock_app(base=PadrinoTestApp, &block)
+  def mock_app(base=Padrino::Application, &block)
     @app = Sinatra.new(base, &block)
   end
-  
+
   def app
     Rack::Lint.new(@app)
   end
 
-  def stop_time_for_test
-    time = Time.now
-    Time.stubs(:now).returns(time)
-    return time
-  end
-
   # Asserts that a file matches the pattern
   def assert_match_in_file(pattern, file)
     assert File.exist?(file), "File '#{file}' does not exist!"
     assert_match pattern, File.read(file)
   end
-  
+
   # Delegate other missing methods to response.
   def method_missing(name, *args, &block)
     if response && response.respond_to?(name)

data/test/test_application.rb

@@ -2,10 +2,36 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestApplication < Test::Unit::TestCase
 
+  def with_layout(name=:application)
+    # Build a temp layout
+    FileUtils.mkdir_p(File.dirname(__FILE__) + "/views/layouts")
+    layout = File.dirname(__FILE__) + "/views/layouts/#{name}.erb"
+    File.open(layout, 'wb') { |io| io.write "this is a <%= yield %>" }
+    yield
+  ensure
+    # Remove temp layout
+    File.unlink(layout) rescue nil
+    FileUtils.rm_rf(File.dirname(__FILE__) + "/views")
+  end
+
+  def with_view(name, content)
+    # Build a temp layout
+    FileUtils.mkdir_p(File.dirname(__FILE__) + "/views")
+    layout = File.dirname(__FILE__) + "/views/#{name}.erb"
+    File.open(layout, 'wb') { |io| io.write content }
+    yield
+  ensure
+    # Remove temp layout
+    File.unlink(layout) rescue nil
+    FileUtils.rm_rf(File.dirname(__FILE__) + "/views")
+  end
+
+  class PadrinoTestApp < Padrino::Application; end
+
   context 'for application functionality' do
 
     should 'check default options' do
-      assert_match %r{test/helper.rb}, PadrinoTestApp.app_file
+      assert_match __FILE__, PadrinoTestApp.app_file
       assert_equal :test, PadrinoTestApp.environment
       assert_equal Padrino.root("views"), PadrinoTestApp.views
       assert PadrinoTestApp.raise_errors
@@ -27,4 +53,129 @@ class TestApplication < Test::Unit::TestCase
       assert !PadrinoTestApp.padrino_helpers
     end
   end
+
+  context 'for application layout functionality' do
+
+    should 'get no layout' do
+      mock_app do
+        get("/"){ "no layout" }
+      end
+
+      get "/"
+      assert_equal "no layout", body
+    end
+
+    should 'be compatible with sinatra layout' do
+      mock_app do
+        layout do
+          "this is a <%= yield %>"
+        end
+        
+        get("/"){ render :erb, "sinatra layout" }
+      end
+
+      get "/"
+      assert_equal "this is a sinatra layout", body
+    end
+
+    should 'use rails way layout' do
+      with_layout do
+        mock_app do
+          get("/"){ render :erb, "rails way layout" }
+        end
+
+        get "/"
+        assert_equal "this is a rails way layout", body
+      end
+    end
+
+    should 'use rails way for a custom layout' do
+      with_layout :custom do
+        mock_app do
+          layout :custom
+          get("/"){ render :erb, "rails way custom layout" }
+        end
+
+        get "/"
+        assert_equal "this is a rails way custom layout", body
+      end
+    end
+  end
+
+  context 'for application render functionality' do
+
+    should 'be compatible with sinatra render' do
+      mock_app do
+        get("/"){ render :erb, "<%= 1+2 %>" }
+      end
+      get "/"
+      assert_equal "3", body
+    end
+
+    should 'be compatible with sinatra views' do
+      with_view :index, "<%= 1+2 %>" do
+        mock_app do
+          get("/foo") { render :erb, :index }
+          get("/bar") { erb :index }
+          get("/dir") { "3" }
+          get("/inj") { erb "<%= 2+1 %>" }
+          get("/rnj") { render :erb, "<%= 2+1 %>" }
+        end
+        get "/foo"
+        assert_equal "3", body
+        get "/bar"
+        assert_equal "3", body
+        get "/dir"
+        assert_equal "3", body
+        get "/inj"
+        assert_equal "3", body
+        get "/rnj"
+        assert_equal "3", body
+      end
+    end
+
+    should 'resolve template engine' do
+      with_view :index, "<%= 1+2 %>" do
+        mock_app do
+          get("/foo") { render :index }
+          get("/bar") { render "/index" }
+        end
+        get "/foo"
+        assert_equal "3", body
+        get "/bar"
+        assert_equal "3", body
+      end
+    end
+  end
+
+  context 'for application i18n functionality' do
+
+    should 'have a default locale en and auto_locale disabled' do
+      mock_app do
+        assert_equal :en, locale
+        assert !auto_locale
+      end
+    end
+
+    should 'change default locale from settings' do
+      mock_app do
+        set :locale, :it
+        enable :auto_locale
+        assert_equal :it, locale
+        assert auto_locale
+      end
+    end
+
+    should 'set locale when auto_locale is enabled' do
+      mock_app do
+        enable :auto_locale
+        get("/:locale"){ I18n.locale.to_s }
+      end
+
+      %w(it de fr).each do |lang|
+        get("/#{lang}")
+        assert_equal lang, body
+      end
+    end
+  end
 end

data/test/{test_padrino_core.rb → test_core.rb}

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-class TestPadrinoCore < Test::Unit::TestCase
+class TestCore < Test::Unit::TestCase
 
   context 'for core functionality' do
 

data/test/{test_padrino_mounter.rb → test_mounter.rb}

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-class TestPadrinoMounter < Test::Unit::TestCase
+class TestMounter < Test::Unit::TestCase
 
   def setup
     Padrino.mounted_apps.clear
@@ -27,7 +27,7 @@ class TestPadrinoMounter < Test::Unit::TestCase
       mounter.to("/test")
       assert_equal "test", mounter.name
       assert_equal "Test", mounter.app_class
-      assert_match %r{test/apps/test/app.rb}, mounter.app_file
+      assert_match %r{test/app.rb}, mounter.app_file
       assert_equal "/test", mounter.uri_root
       assert_nil mounter.app_root
     end
@@ -46,7 +46,7 @@ class TestPadrinoMounter < Test::Unit::TestCase
       assert_equal Test, mounter.app_obj
       assert_equal Padrino.root('app/app.rb'), mounter.app_file
       assert_equal "/", mounter.uri_root
-      assert_equal Padrino.root, mounter.app_root
+      assert_equal nil, mounter.app_root
     end
 
     should 'mount multiple apps' do
@@ -71,7 +71,7 @@ class TestPadrinoMounter < Test::Unit::TestCase
       Padrino.mounted_root = "apps"
       assert_equal Padrino.root("apps", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
       Padrino.mounted_root = nil
-      assert_equal Padrino.root("apps", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
+      assert_equal Padrino.root("test", "app.rb"), Padrino.mounted_root("test", "app.rb")
     end
 
     should 'correctly instantiate a new padrino application' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  version: 0.2.9
+  version: 0.4.5
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 -08:00
+date: 2010-01-06 00:00:00 +01:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,6 +25,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.9.2
     version: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.2
+    version: 
 - !ruby/object:Gem::Dependency 
   name: thor
   type: :runtime
@@ -115,6 +125,7 @@ files:
 - lib/padrino-core/application.rb
 - lib/padrino-core/caller.rb
 - lib/padrino-core/loader.rb
+- lib/padrino-core/locale/en.yml
 - lib/padrino-core/logger.rb
 - lib/padrino-core/mounter.rb
 - lib/padrino-core/reloader.rb
@@ -137,9 +148,9 @@ files:
 - test/fixtures/apps/simple.rb
 - test/helper.rb
 - test/test_application.rb
+- test/test_core.rb
 - test/test_logger.rb
-- test/test_padrino_core.rb
-- test/test_padrino_mounter.rb
+- test/test_mounter.rb
 - test/test_reloader_complex.rb
 - test/test_reloader_simple.rb
 - test/test_server.rb