padrino-core 0.1.2 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/padrino-core.rb

@@ -9,12 +9,18 @@ module Padrino
 
   # Helper method for file references.
   #
-  # @param args [Array] Path components relative to ROOT_DIR.
-  # @example Referencing a file in config called settings.yml:
+  # Example:
+  #   # Referencing a file in config called settings.yml
   #   Padrino.root("config", "settings.yml")
+  #   # returns PADRINO_ROOT + "/config/setting.yml"
   def self.root(*args)
     File.join(PADRINO_ROOT, *args)
   end
+  
+  # Helper method that return PADRINO_ENV
+  def self.env
+    PADRINO_ENV
+  end
 
   # Returns the resulting rack builder mapping each 'mounted' application
   def self.application

data/lib/padrino-core/application.rb

@@ -6,7 +6,7 @@ module Padrino
 
     def logger
       @log_stream ||= self.class.log_to_file? ? Padrino.root("log/#{PADRINO_ENV.downcase}.log") : $stdout
-      @logger   ||= Logger.new(@log_stream)
+      @logger     ||= Logger.new(@log_stream)
     end
 
     class << self
@@ -27,14 +27,7 @@ module Padrino
       # Makes the routes defined in the block and in the Modules given
       # in `extensions` available to the application
       def controllers(*extensions, &block)
-        @routes = Padrino::Application.dupe_routes if reload? # This performs a basic controller reload
-        instance_eval(&block) if block_given?
-        include(*extensions)  if extensions.any?
-      end
-
-      # Makes the urls defined in the block and in the Modules given
-      # in `extensions` available to the application
-      def urls(*extensions, &block)
+        self.reset_routes!    if reload?
         instance_eval(&block) if block_given?
         include(*extensions)  if extensions.any?
       end
@@ -45,9 +38,9 @@ module Padrino
       # Invoked automatically when an application is first instantiated
       def setup_application!
         return if @configured
+        self.register_framework_extensions
         self.calculate_paths
         self.register_initializers
-        self.register_framework_extensions
         self.require_load_paths
         self.setup_logger
         @configured = true
@@ -67,13 +60,15 @@ module Padrino
         set :default_builder, 'StandardFormBuilder'
         enable :flash
         # Plugin specific
+        enable :padrino_routing
+        enable :padrino_mailer
         enable :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 specify 'app_file' configuration option!") unless self.app_file
+        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
@@ -93,9 +88,11 @@ module Padrino
 
       # Registers all desired padrino extension helpers/routing
       def register_framework_extensions
-        register Padrino::Routing
-        register Padrino::Mailer
+        return if @registered
+        register Padrino::Routing  if padrino_routing?
+        register Padrino::Mailer   if padrino_mailer?
         register Padrino::Helpers  if padrino_helpers?
+        @registered = true
       end
 
       # Require all files within the application's load paths
@@ -105,9 +102,9 @@ module Padrino
 
       # Creates the log directory and redirects output to file if needed
       def setup_logger
-        return unless self.log_to_file?
-        FileUtils.mkdir_p 'log' unless File.exists?('log')
-        log = File.new("log/#{PADRINO_ENV.downcase}.log", "a+")
+        return unless log_to_file?
+        FileUtils.mkdir_p("#{Padrino.root}/log") unless File.exists?("#{Padrino.root}/log")
+        log = File.new("#{Padrino.root}/log/#{PADRINO_ENV.downcase}.log", "a+")
         $stdout.reopen(log)
         $stderr.reopen(log)
       end
@@ -115,7 +112,8 @@ module Padrino
       # 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",
-                         "controllers/*.rb", "app/controllers/*.rb","helpers/*.rb", "app/helpers/*.rb"]
+                         "mailers/*.rb", "app/mailers/*.rb", "controllers/*.rb", "app/controllers/*.rb",
+                         "helpers/*.rb", "app/helpers/*.rb"]
       end
 
       # Returns the path to the views directory from root by returning the first that is found
@@ -123,6 +121,12 @@ module Padrino
         @view_paths = ["views", "app/views"].collect { |path| File.join(self.root, path) }
         @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
       end
+
+      # Resets application routes for use in reloading the application
+      # This performs a basic routes reload (compatible with sinatra edge)
+      def reset_routes!
+        @routes = Padrino::Application.dupe_routes; load(self.app_file)
+      end
     end
   end
 end

data/lib/padrino-core/loader.rb

@@ -3,7 +3,7 @@ module Padrino
     # Requires necessary dependencies as well as application files from root lib and models
     def load!
       load_required_gems # load bundler gems
-      load_dependencies("#{root}/config/apps.rb", "#{root}/config/database.rb")
+      load_dependencies("#{root}/config/apps.rb", "#{root}/config/database.rb") # load configuration
       load_dependencies("#{root}/lib/**/*.rb", "#{root}/models/*.rb") # load root app dependencies
       reload! # We need to fill our Stat::CACHE but we do that only for development
     end
@@ -32,6 +32,7 @@ module Padrino
         require 'bundler'
         gemfile_path = root("Gemfile")
         puts "=> Loading GemFile #{gemfile_path} for #{PADRINO_ENV}"
+        # TODO possibly support padrino apps where no Gemfile is specified (skip requires, assume explicit dependencies)
         Bundler::Environment.load(gemfile_path).require_env(PADRINO_ENV)
       rescue Bundler::DefaultManifestNotFound => e
         puts "=> You didn't create Bundler Gemfile manifest or you are not in a Sinatra application."

data/lib/padrino-core/mounter.rb

@@ -5,11 +5,12 @@ module Padrino
   # @example Mounter.new("blog_app", :app_file => "/path/to/root/app.rb").to("/blog")
   # @example Mounter.new("blog_app", :app_class => "Blog").to("/blog")
   class Mounter
-    attr_accessor :name, :uri_root, :app_file, :app_klass
+    attr_accessor :name, :uri_root, :app_file, :app_klass, :app_root
     def initialize(name, options={})
       @name      = name
       @app_klass = options[:app_class] || name.classify
       @app_file  = options[:app_file]  || Padrino.mounted_root(name, 'app.rb')
+      @app_root  = options[:app_root]  if options[:app_root]
     end
 
     # Registers the mounted application onto Padrino
@@ -28,6 +29,7 @@ module Padrino
       builder.map self.uri_root do
         app_klass.set :uri_root, app_data.uri_root
         app_klass.set :app_file, app_data.app_file
+        app_klass.set :root,     app_data.app_root if app_data.app_root
         run app_klass
       end
     end
@@ -36,7 +38,13 @@ module Padrino
   class << self
     # Returns the root to the mounted apps base directory
     def mounted_root(*args)
-      File.join(Padrino.root, "apps", *args)
+      @mounted_root ||= "apps" # Other apps
+      File.join(Padrino.root, @mounted_root, *args)
+    end
+
+    # Set the root directory where padrino search mounted apps
+    def mounted_root=(value)
+      @mounted_root = value
     end
 
     # Returns the mounted padrino applications (MountedApp objects)
@@ -53,7 +61,7 @@ module Padrino
     # Mounts the core application onto Padrino project
     # @example Padrino.mount_core(:app_file => "/path/to/file", :app_class => "Blog")
     def mount_core(options={})
-      options.reverse_merge!(:app_file => Padrino.root('app.rb'))
+      options.reverse_merge!(:app_file => Padrino.root('app/app.rb'), :app_root => Padrino.root)
       Mounter.new("core", options).to("/")
     end
   end

data/lib/padrino-core/tasks.rb

@@ -1,35 +1,59 @@
 require 'thor'
+require File.dirname(__FILE__) + "/tasks/helpers"
 
 module Padrino
   module Tasks 
     class Base < Thor
       include Thor::Actions
-      
-      desc "start", "Starts the Padrino application"
+      include Padrino::Tasks::Helpers
+
+      class_option :chdir, :type => :string, :aliases => "-c"
+
+      desc "start ", "Starts the Padrino application"
+
+      method_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development
+      method_option :adapter,     :type => :string,  :aliases => "-a", :required => true, :default => :thin
+      method_option :host,        :type => :string,  :aliases => "-h", :required => true, :default => "localhost"
+      method_option :port,        :type => :numeric, :aliases => "-p", :required => true, :default => 3000
+      method_option :boot,        :type => :string,  :aliases => "-b", :required => true, :default => "config/boot.rb"
+      method_option :daemonize,   :type => :boolean, :aliases => "-d"
+
+      desc "start", "Start the Padrino application"
       def start
-        say "Starting the Padrino application from root #{destination_root}"
+        require File.dirname(__FILE__) + "/tasks/adapter"
+        chdir(options.chdir)
+        Padrino::Tasks::Adapter.start(options)
       end
-      
+
       desc "stop", "Stops the Padrino application"
       def stop
-        say "Stopping the Padrino application"
+        require File.dirname(__FILE__) + "/tasks/adapter"
+        chdir(options.chdir)
+        Padrino::Tasks::Adapter.stop
       end
-      
+
       desc "test", "Executes all the Padrino test files"
       def test
-        say "Executing Padrino test files"
+        require File.dirname(__FILE__) + "/tasks/test"
+        chdir(options.chdir)
+        Padrino::Tasks::Test.start
       end
-      
+
       desc "console ENVIRONMENT", "Boots up the Padrino application irb console"
+      method_option :boot, :type => :string, :aliases => "-b", :required => true, :default => "config/boot.rb"
       def console(environment="development")
-        require File.dirname(__FILE__) + "/version.rb"
-        raise "Are you in a Padrino Project? We didn't find config/boot.rb !!!" unless File.exist?("config/boot.rb")
+        require File.dirname(__FILE__) + "/version"
+        boot = options.chdir ? File.join(options.chdir, options.boot) : options.boot
+        unless File.exist?(boot)
+          puts "=> We didn't find boot file: #{boot} !!!"
+          exit
+        end
         ENV["PADRINO_ENV"] ||= environment
         puts "=> Loading #{environment} console (Padrino v.#{Padrino.version})"
         irb   = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-        libs  =  " -r irb/completion"
-        libs <<  " -r config/boot"
-        libs <<  " -r #{File.dirname(__FILE__)}/tasks/console"
+        libs  = " -r irb/completion"
+        libs << " -r #{boot}"
+        libs << " -r #{File.dirname(__FILE__)}/tasks/console"
         exec "#{irb} #{libs} --simple-prompt"
       end
     end

data/lib/padrino-core/tasks/adapter.rb

@@ -0,0 +1,93 @@
+module Padrino
+  module Tasks
+    module Adapter
+
+      class << self
+
+        ADAPTERS = %w[thin mongrel webrick]
+
+        # Start for the given options a rackup handler
+        def start(options)
+
+          ENV["PADRINO_ENV"] = options.environment.to_s
+
+          boot = options.chdir ? File.join(options.chdir, options.boot) : options.boot
+          unless File.exist?(boot)
+            puts "=> Could not find boot file: #{boot.inspect} !!!"
+            exit
+          end
+          require boot
+
+          puts "=> Padrino/#{Padrino.version} has taken the stage #{options.environment} on port #{options.port}"
+
+          if options.daemonize?
+            unless fork
+              puts "=> Daemonized mode is not supported on your platform." 
+              exit 
+            end
+
+            stop # Need to stop a process if it exists
+
+            fork do
+              Process.setsid
+              exit if fork
+              File.umask 0000
+              puts "=> Padrino server has been daemonized with pid #{Process.pid}"
+              STDIN.reopen "/dev/null"
+              STDOUT.reopen "/dev/null", "a"
+              STDERR.reopen STDOUT
+
+              FileUtils.mkdir_p("tmp/pids") unless File.exist?("tmp/pids")
+              pid = "tmp/pids/server.pid"
+
+              if pid
+                File.open(pid, 'w'){ |f| f.write("#{Process.pid}") }
+                at_exit { File.delete(pid) if File.exist?(pid) }
+              end
+
+              run_app(options)
+
+            end
+          else
+            run_app(options)
+          end
+        end
+
+        # Method that run the Padrino.application
+        def run_app(options)
+
+          handler_name = options.adapter.to_s.capitalize
+
+          begin
+            handler = Rack::Handler.get(handler_name.downcase)
+          rescue
+            puts "#{handler_name} not supported yet, available adapters are: #{ADAPTERS.inspect}"
+            exit
+          end
+          
+          handler.run Padrino.application, :Host => options.host, :Port => options.port do |server|
+            trap(:INT) do
+              # Use thins' hard #stop! if available, otherwise just #stop
+              server.respond_to?(:stop!) ? server.stop! : server.stop
+              puts "<= Padrino has ended his set (crowd applauds)"
+            end
+          end
+        rescue Errno::EADDRINUSE
+          puts "=> Someone is already performing on port #{options.port}!"
+        end
+
+        # Method that stop (if exist) a running Padrino.application
+        def stop
+          if File.exist?("tmp/pids/server.pid")
+            pid = File.read("tmp/pids/server.pid").to_i
+            print "=> Sending SIGTERM to process with pid #{pid} wait "
+            Process.kill(15, pid) rescue nil
+            1.step(5) { |i| sleep i; print "."; $stdout.flush }
+            puts " done."
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/padrino-core/tasks/helpers.rb

@@ -0,0 +1,20 @@
+module Padrino
+  module Tasks
+    module Helpers
+
+      def chdir(dir)
+        return unless dir
+        begin
+          Dir.chdir(dir.to_s)
+        rescue Errno::ENOENT
+          puts "=> Specified Padrino root '#{dir}' " +
+               "does not appear to exist!"
+        rescue Errno::EACCES
+          puts "=> Specified Padrino root '#{dir}' " +
+               "cannot be accessed by the current user!"
+        end
+      end
+
+    end
+  end
+end

data/lib/padrino-core/tasks/test.rb

@@ -0,0 +1,19 @@
+module Padrino
+  module Tasks
+    module Test
+
+      class << self
+
+        # This metod start testing for the given app.
+        # It look for any test/test_*.rb file in your app root.
+        def start
+          puts "=> Starting Test"
+          tests = Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
+          cmd = "ruby -rubygems -I.:lib -e'%w( #{tests.join(' ')} ).each { |file| require file }'"
+          system cmd
+        end
+
+      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.1.2"
+  s.version = "0.1.3"
 
   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-11-18}
+  s.date = %q{2009-11-20}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{nesquena@gmail.com}
@@ -36,16 +36,21 @@ Gem::Specification.new do |s|
      "lib/padrino-core/stat.rb",
      "lib/padrino-core/support_lite.rb",
      "lib/padrino-core/tasks.rb",
+     "lib/padrino-core/tasks/adapter.rb",
      "lib/padrino-core/tasks/console.rb",
+     "lib/padrino-core/tasks/helpers.rb",
+     "lib/padrino-core/tasks/test.rb",
      "lib/padrino-core/version.rb",
      "padrino-core.gemspec",
      "test/active_support_helpers.rb",
-     "test/fixtures/extended_app/app.rb",
+     "test/fixtures/simple_app/.components",
+     "test/fixtures/simple_app/.gitignore",
+     "test/fixtures/simple_app/Gemfile",
      "test/fixtures/simple_app/app.rb",
      "test/helper.rb",
+     "test/test_padrino_application.rb",
      "test/test_padrino_core.rb",
-     "test/test_padrino_mounting.rb",
-     "test/test_padrino_tasks.rb"
+     "test/test_padrino_mounter.rb"
   ]
   s.homepage = %q{http://github.com/padrino/padrino-core}
   s.rdoc_options = ["--charset=UTF-8"]

data/test/fixtures/simple_app/.components

@@ -0,0 +1,6 @@
+--- 
+:test: bacon
+:mock: mocha
+:orm: datamapper
+:renderer: erb
+:script: jquery

data/test/fixtures/simple_app/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+log/**/*
+tmp/**/*
+vendor/gems/gems
+vendor/gems/specifications
+vendor/gems/doc
+vendor/gems/environment.rb

data/test/fixtures/simple_app/Gemfile

@@ -0,0 +1,9 @@
+clear_sources
+source 'http://gemcutter.org'
+ 
+# Base requirements
+gem 'sinatra', :require_as => 'sinatra/base'
+gem 'rack-flash'
+ 
+# Component requirements
+gem 'haml'

data/test/fixtures/simple_app/app.rb

@@ -1,10 +1,41 @@
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
 require 'sinatra/base'
 require 'haml'
+require 'padrino-core'
 
-# PADRINO_ROOT = File.dirname(__FILE__)
+class Core1Demo < Padrino::Application
+  set :app_file, File.dirname(__FILE__) + "/app.rb"
+  disable :padrino_routing
+  disable :padrino_mailer
+  disable :padrino_helpers
+  
+  get "" do
+    "Im Core1Demo"
+  end
+end
 
-class SimpleCoreDemo < Padrino::Application
-  configure do
-    set :root, File.dirname(__FILE__)
+class Core2Demo < Padrino::Application
+  set :app_file, File.dirname(__FILE__) + "/app.rb"
+  disable :padrino_routing
+  disable :padrino_mailer
+  disable :padrino_helpers
+  
+  get "" do
+    "Im Core2Demo"
   end
-end
+end
+
+class Core3Demo < Padrino::Application
+  enable :padrino_routing
+  
+  # TODO enabling this causes an error (because routing not loaded yet)
+  # get :test, :map => '/test' do
+  #   "This raises a large error"
+  # end
+end
+
+orig_stdout = $stdout
+$stdout = log_buffer = StringIO.new
+Padrino.load!
+$stdout = orig_stdout
+log_buffer.rewind && log_buffer.read

data/test/helper.rb

@@ -7,14 +7,10 @@ require 'webrat'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'active_support_helpers'
-require 'padrino-helpers'
-require 'padrino-core'
 
 class Test::Unit::TestCase
-  include Padrino::Helpers::OutputHelpers
-  include Padrino::Helpers::TagHelpers
-  include Padrino::Helpers::AssetTagHelpers
   include Rack::Test::Methods
   include Webrat::Methods
   include Webrat::Matchers
@@ -29,25 +25,6 @@ class Test::Unit::TestCase
     return time
   end
 
-  # assert_has_tag(:h1, :content => "yellow") { "<h1>yellow</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_tag(name, attributes = {}, &block)
-    html = block && block.call
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
-
-  # assert_has_no_tag, tag(:h1, :content => "yellow") { "<h1>green</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_no_tag(name, attributes = {}, &block)
-    html = block && block.call
-    attributes.merge!(:count => 0)
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
-
   # Silences the output by redirecting to stringIO
   # silence_logger { ...commands... } => "...output..."
   def silence_logger(&block)

data/test/test_padrino_application.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/helper'
+
+PADRINO_ENV = RACK_ENV = 'test' unless defined?(PADRINO_ENV)
+require File.dirname(__FILE__) + '/fixtures/simple_app/app'
+require 'padrino-core'
+
+class TestPadrinoApplication < Test::Unit::TestCase
+
+  def app
+    Padrino.application.tap { }
+  end
+
+  def setup
+    Padrino.mounted_apps.clear
+    Padrino.mount("core_1_demo", :app_file => "#{Padrino.root("app.rb")}").to("/core_1_demo")
+    Padrino.mount("core_2_demo", :app_file => "#{Padrino.root("app.rb")}").to("/core_2_demo")
+  end
+
+  context 'for application functionality' do
+    
+    should 'check methods' do
+      assert_respond_to Padrino::Application, :new
+      assert_respond_to Padrino::Application, :controllers
+      assert_respond_to Padrino::Application, :setup_application!
+      assert_respond_to Padrino::Application, :default_configuration!
+      assert_respond_to Padrino::Application, :calculate_paths
+      assert_respond_to Padrino::Application, :register_initializers
+      assert_respond_to Padrino::Application, :register_framework_extensions
+      assert_respond_to Padrino::Application, :require_load_paths
+      assert_respond_to Padrino::Application, :setup_logger
+      assert_respond_to Padrino::Application, :load_paths
+      assert_respond_to Padrino::Application, :find_view_path
+    end
+
+    should 'have controllers' do
+      Core1Demo.controllers do
+        get("/controller") { "Im a controller" }
+      end
+      visit "/core_1_demo/controller"
+      assert_contain "Im a controller"
+    end
+    
+    
+  end
+end

data/test/test_padrino_core.rb

@@ -1,17 +1,37 @@
 require File.dirname(__FILE__) + '/helper'
-# require File.dirname(__FILE__) + '/fixtures/simple_app/app'
+
+PADRINO_ENV = RACK_ENV = 'test' unless defined?(PADRINO_ENV)
+require File.dirname(__FILE__) + '/fixtures/simple_app/app'
+require 'padrino-core'
 
 class TestPadrinoCore < Test::Unit::TestCase
+
   context 'for core functionality' do
+
+    should 'check global methods' do
+      assert_respond_to Padrino, :env
+      assert_respond_to Padrino, :root
+      assert_respond_to Padrino, :load!
+      assert_respond_to Padrino, :reload!
+      assert_respond_to Padrino, :load_dependencies
+      assert_respond_to Padrino, :load_required_gems
+      assert_respond_to Padrino, :mounted_root
+      assert_respond_to Padrino, :mounted_apps
+      assert_respond_to Padrino, :mount
+      assert_respond_to Padrino, :mount_core
+      assert_respond_to Padrino, :version
+    end
+
+    should 'validate global helpers' do
+      assert_equal "test", Padrino.env
+      assert_match %r{/test/fixtures/simple_app}, Padrino.root
+    end
     
-  end
-  
-  context 'for loader functionality' do
-    
-    
-  end
-  
-  context 'for application functionality' do
-    
+    should 'raise application error if I instantiate a new padrino application without mounted apps' do
+      Padrino.mounted_apps.clear
+      assert_raise Padrino::ApplicationLoadError do
+        Padrino.application.tap { }
+      end
+    end
   end
 end

data/test/test_padrino_mounter.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/helper'
+
+PADRINO_ENV = RACK_ENV = 'test' unless defined?(PADRINO_ENV)
+require File.dirname(__FILE__) + '/fixtures/simple_app/app'
+require 'padrino-core'
+
+class TestPadrinoMounter < Test::Unit::TestCase
+
+  def app
+    Padrino.application.tap { }
+  end
+
+  def setup
+    Padrino.mounted_apps.clear
+    Padrino.mount("core_1_demo", :app_file => "#{Padrino.root("app.rb")}").to("/core_1_demo")
+    Padrino.mount("core_2_demo", :app_file => "#{Padrino.root("app.rb")}").to("/core_2_demo")
+  end
+
+  context 'for mounter functionality' do
+    
+    should 'check methods' do
+      mounter = Padrino::Mounter.new("test", :app_file => "/path/to/test.rb")
+      mounter.to("/test")
+      assert_kind_of Padrino::Mounter, mounter
+      assert_respond_to Padrino::Mounter, :new
+      assert_respond_to mounter, :to
+      assert_respond_to mounter, :map_onto
+      assert_equal "test", mounter.name
+      assert_equal "/path/to/test.rb", mounter.app_file
+      assert_equal "/test", mounter.uri_root
+      assert_nil mounter.app_root
+    end
+
+    should 'mount some apps' do
+      assert_equal ["core_1_demo", "core_2_demo"], Padrino.mounted_apps.collect(&:name)
+    end
+
+    should 'mount only a core' do
+      Padrino.mounted_apps.clear
+      Padrino.mount_core(:app_file => "#{Padrino.root("app.rb")}")
+      assert_equal ["core"], Padrino.mounted_apps.collect(&:name)
+    end
+
+    should 'correctly instantiate a new padrino application' do
+      visit '/core_1_demo'
+      assert_contain "Im Core1Demo"
+      visit '/core_2_demo'
+      assert_contain "Im Core2Demo"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-18 00:00:00 -08:00
+date: 2009-11-20 00:00:00 -08:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,16 +110,21 @@ files:
 - lib/padrino-core/stat.rb
 - lib/padrino-core/support_lite.rb
 - lib/padrino-core/tasks.rb
+- lib/padrino-core/tasks/adapter.rb
 - lib/padrino-core/tasks/console.rb
+- lib/padrino-core/tasks/helpers.rb
+- lib/padrino-core/tasks/test.rb
 - lib/padrino-core/version.rb
 - padrino-core.gemspec
 - test/active_support_helpers.rb
-- test/fixtures/extended_app/app.rb
+- test/fixtures/simple_app/.components
+- test/fixtures/simple_app/.gitignore
+- test/fixtures/simple_app/Gemfile
 - test/fixtures/simple_app/app.rb
 - test/helper.rb
+- test/test_padrino_application.rb
 - test/test_padrino_core.rb
-- test/test_padrino_mounting.rb
-- test/test_padrino_tasks.rb
+- test/test_padrino_mounter.rb
 has_rdoc: true
 homepage: http://github.com/padrino/padrino-core
 licenses: []

data/test/fixtures/extended_app/app.rb

@@ -1,10 +0,0 @@
-require 'sinatra/base'
-require 'haml'
-
-# PADRINO_ROOT = File.dirname(__FILE__)
-
-class ExtendedCoreDemo < Padrino::Application
-  configure do
-    set :root, File.dirname(__FILE__)
-  end
-end

data/test/test_padrino_mounting.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-# require File.dirname(__FILE__) + '/fixtures/simple_app/app'
-
-class TestPadrinoMounting < Test::Unit::TestCase
-  context 'for mounting applications functionality' do
-    
-  end
-end

data/test/test_padrino_tasks.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-# require File.dirname(__FILE__) + '/fixtures/simple_app/app'
-
-class TestPadrinoTasks < Test::Unit::TestCase
-  context 'for padrino command line tasks' do
-    
-  end
-end