padrino-core 0.1.1 → 0.1.2

data/README.rdoc

@@ -1,6 +1,17 @@
 = padrino-core
 
-Description goes here.
+== Installation
+
+To install the 'full-stack' padrino framework, simply grab the latest version from gemcutter:
+
+  $ sudo gem install padrino --source http://gemcutter.org
+  
+This will install the necessary padrino gems to get you started.
+Now you are ready to use this gem to enhance your sinatra projects or to create new Padrino applications.
+
+== Usage
+
+Include padrino-core overview here
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/padrino-core.rb

@@ -1,10 +1,11 @@
 require 'sinatra/base'
-Dir[File.dirname(__FILE__) + '/padrino-core/**/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
 
 # Defines our PADRINO_ENV
 PADRINO_ENV = ENV["PADRINO_ENV"] ||= ENV["RACK_ENV"] ||= "development" unless defined?(PADRINO_ENV)
 
 module Padrino
+  class ApplicationLoadError < RuntimeError; end
 
   # Helper method for file references.
   #
@@ -14,20 +15,12 @@ module Padrino
   def self.root(*args)
     File.join(PADRINO_ROOT, *args)
   end
-  
-  # Returns the prepared rack application mapping each 'mounted' application
+
+  # Returns the resulting rack builder mapping each 'mounted' application
   def self.application
-    Rack::Builder.new do
-      Padrino.mounted_apps.each do |app|
-        require(app.app_file)
-        app_klass = app.klass.constantize
-        map app.uri_root do
-          app_klass.set :uri_root, app.uri_root
-          app_klass.set :app_file, app.app_file
-          run app_klass
-        end
-      end
-    end
+    raise ApplicationLoadError.new("At least one application must be mounted onto Padrino!") if self.mounted_apps.none?
+    builder = Rack::Builder.new
+    self.mounted_apps.each { |app| app.map_onto(builder) }
+    builder
   end
-
 end

data/lib/padrino-core/application.rb

@@ -1,4 +1,5 @@
 module Padrino
+  class ApplicationSetupError < RuntimeError; end
   # Subclasses of this become independent Padrino applications (stemming from Sinatra::Application)
   # These subclassed applications can be easily mounted into other Padrino applications as well.
   class Application < Sinatra::Application
@@ -26,7 +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 = {} if reload? # This perform a basic reload controller
+        @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
@@ -41,9 +42,10 @@ module Padrino
       protected
 
       # Setup the application by registering initializers, load paths and logger
-      # Invoked automatically when an application instance is created
+      # Invoked automatically when an application is first instantiated
       def setup_application!
         return if @configured
+        self.calculate_paths
         self.register_initializers
         self.register_framework_extensions
         self.require_load_paths
@@ -61,20 +63,27 @@ module Padrino
         set :reload, development?
         # Padrino specific
         set :app_name, self.to_s.underscore.to_sym
-        set :app_file, Padrino.mounted_root(self.app_name.to_s, "/app.rb")
         set :environment, PADRINO_ENV.to_sym
-        set :images_path, self.public + "/images"
         set :default_builder, 'StandardFormBuilder'
         enable :flash
         # Plugin specific
         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
+        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 Rack::Session::Cookie
         use Rack::Flash if flash?
         use Padrino::Reloader if reload?
+        register DatabaseSetup if defined?(DatabaseSetup)
         Dir[Padrino.root + '/config/initializers/*.rb'].each do |file|
           Padrino.load_dependencies(file)
           file_class = File.basename(file, '.rb').classify
@@ -91,7 +100,7 @@ module Padrino
 
       # Require all files within the application's load paths
       def require_load_paths
-        load_paths.each { |path|  Padrino.load_dependencies(File.join(self.root, path)) }
+        load_paths.each { |path| Padrino.load_dependencies(File.join(self.root, path)) }
       end
 
       # Creates the log directory and redirects output to file if needed
@@ -103,9 +112,16 @@ module Padrino
         $stderr.reopen(log)
       end
 
-      # Returns the load_paths for the application relative to the application root
+      # Returns the load_paths for the application (relative to the application root)
       def load_paths
-        @load_paths ||= ["models/*.rb", "urls.rb", "controllers/*.rb", "helpers/*.rb"]
+        @load_paths ||= ["urls.rb", "config/urls.rb", "models/*.rb", "app/models/*.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
+      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? }
       end
     end
   end

data/lib/padrino-core/loader.rb

@@ -3,7 +3,8 @@ 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}/lib/**/*.rb", "#{root}/models/*.rb") # load root app dependencies
+      load_dependencies("#{root}/config/apps.rb", "#{root}/config/database.rb")
+      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
 

data/lib/padrino-core/mounter.rb

@@ -5,18 +5,32 @@ 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, :klass
+    attr_accessor :name, :uri_root, :app_file, :app_klass
     def initialize(name, options={})
-      @name     = name
-      @klass    = options[:app_class] || name.classify
-      @app_file = options[:app_file]  || Padrino.mounted_root(name, 'app.rb')
+      @name      = name
+      @app_klass = options[:app_class] || name.classify
+      @app_file  = options[:app_file]  || Padrino.mounted_root(name, 'app.rb')
     end
 
-    # registers the mounted application to Padrino
+    # Registers the mounted application onto Padrino
+    # @example Mounter.new("blog_app").to("/blog")
     def to(mount_url)
       @uri_root = mount_url
       Padrino.mounted_apps << self
     end
+
+    # Maps Padrino application onto a Rack::Builder
+    # For use in constructing a Rack application
+    # @example @app.map_onto(@builder)
+    def map_onto(builder)
+      require(self.app_file)
+      app_data, app_klass = self, self.app_klass.constantize
+      builder.map self.uri_root do
+        app_klass.set :uri_root, app_data.uri_root
+        app_klass.set :app_file, app_data.app_file
+        run app_klass
+      end
+    end
   end
 
   class << self
@@ -30,11 +44,17 @@ module Padrino
       @mounted_apps ||= []
     end
 
-    # Mounts a new sub-application onto Padrino
+    # Mounts a new sub-application onto Padrino project
     # @example Padrino.mount("blog_app").to("/blog")
-    # @example Padrino.mount("blog_app", :app_file => "/path/to/root/app.rb").to("/blog")
     def mount(name, options={})
       Mounter.new(name, options)
     end
+    
+    # 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'))
+      Mounter.new("core", options).to("/")
+    end
   end
-end
+end

data/lib/padrino-core/support_lite.rb

@@ -5,4 +5,5 @@ unless String.method_defined?(:titleize) && Hash.method_defined?(:slice)
   require 'active_support/core_ext/class/attribute_accessors'
   require 'active_support/core_ext/hash'
   require 'active_support/core_ext/array'
+  require 'active_support/core_ext/module'
 end

data/padrino-core.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-core}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   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-17}
+  s.date = %q{2009-11-18}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{nesquena@gmail.com}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 -08:00
+date: 2009-11-18 00:00:00 -08:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency