padrino-core 0.9.1 → 0.9.2

data/README.rdoc

@@ -4,53 +4,39 @@ Padrino is the godfather of Sinatra.
 
 == Preface
 
-Padrino is a ruby framework build upon the {Sinatra Microframework}[http://www.sinatrarb.com].
-
-Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort.
-  
-The extreme simplicity of this framework is quite refreshing. We have been using Sinatra a great deal
-for recent projects. First for small and simple json and xml web services and then even
-for more complex full-featured applications. 
-
-This gem represents an attempt to make it as fun and easy as possible to code increasingly advanced web applications in Sinatra.
+Padrino is a ruby framework built upon the excellent {Sinatra Microframework}[http://www.sinatrarb.com]. 
+Sinatra is a DSL for creating simple web applications in Ruby with speed and minimal effort. 
+This framework tries hard to make it as fun and easy as possible to code much more advanced web applications by 
+building upon the Sinatra philosophies and foundation.
 
 == Introduction
 
 Many people love Sinatra's simplicity and lightweight but often quickly come to miss a great deal
 of functionality provided by other web frameworks such as Rails when building non-trivial applications.
 
-The obvious question in these cases might be "Why not just use rails then?". This can often be a viable option
-but still Rails is quite a large framework with a 'take it or leave it' attitude.
-
-Personally, we have come to love the philosophy of Sinatra which acts as a thin layer on top of rack 
-often allowing middleware to do most of the work and pulling in additional complexity only when required. 
-
 Our goal with this framework is to match the essence of Sinatra and at the same time create a standard library
 of tools, helpers and components that will make Sinatra suitable for more complex applications.
 
-Here is a small list of what Padrino provides:
-
-Generators:: for creating new padrino applications i.e.: <tt>padrino-gen app</tt> or <tt>padrino start</tt> on command line
-MultiApp:: unlike other ruby frameworks Padrino is principally designed for mounting multiple apps at the same time.
-Routing:: Full url named route, named params, respond_to suppor
-Tag Helpers:: helpers such as: <tt>tag</tt>, <tt>content_tag</tt>, <tt>input_tag</tt>, ...
-Asset Helpers:: helpers such as: <tt>link_to</tt>, <tt>image_tag</tt>, <tt>javascript_include_tag</tt>, ...
-Form Helpers:: with builder support such as: <tt>form_tag</tt>, <tt>form_for</tt>, <tt>field_set_tag</tt>, <tt>text_field</tt>, ...
-Text Helpers:: useful formatting extensions like: <tt>relative_time_ago</tt>, <tt>js_escape_html</tt>, <tt>sanitize_html</tt>
-Mailer:: fast, tiny, delivery support for send templating emails (like ActionMailer do)
-Admin:: an ajax admin that displays your records in sortable grids, tree, windows ... as a desktop app can do.
-Logging:: Padrino provide a logger that can interact with your orm or any other library
-Reloading:: With padrino is not necessary like other framework start and restart your server for see changes.
-I18n:: Padrino has a full support of I18n and can autoset locale.
-
-Keep in mind, the user will be able to pull in these components seperately and leave out those that are not required
+Here is a brief overview of functionality provided by the Padrino framework:
+
+Agnostic:: Full support for many popular testing, templating, mocking, and data storage choices.
+Generators:: Create Padrino applications, models, controllers i.e: padrino-gen project.
+Mountable:: Unlike other ruby frameworks, principally designed for mounting multiple apps.
+Routing:: Full url named routes, named params, respond_to support, before/after filter support.
+Tag Helpers:: View helpers such as: tag, content_tag, input_tag.
+Asset Helpers:: View helpers such as: link_to, image_tag, javascript_include_tag.
+Form Helpers:: Builder support such as: form_tag, form_for, field_set_tag, text_field.
+Text Helpers:: Useful formatting like: relative_time_ago, js_escape_html, sanitize_html.
+Mailer:: Fast and simple delivery support for sending emails (akin to ActionMailer).
+Admin:: Builtin Admin interface (like Django)
+Logging:: Provide a unified logger that can interact with your ORM or any library.
+Reloading::	Automatically reloads server code during development.
+Localization:: Full support of I18n language localization and can auto-set user’s locale. 
+
+Keep in mind, the user will be able to pull in these components 
+{seperately into existing Sinatra applications}[http://wiki.github.com/padrino/padrino-framework/standalone-usage-in-sinatra]
 or use them altogether for a comprehensive upgrade to Sinatra (a full-stack Padrino application).
 
-Note that all work has been created to be compatible with haml, erb, and erubis and that this gem is intended to be 
-template-agnostic in providing helpers wherever possible.
-
-Please help me brainstorm and fork the project if you have any ideas to contribute.
-
 == Installation
 
 To install the padrino framework, simply grab the latest version from gemcutter:
@@ -60,20 +46,31 @@ To install the padrino framework, simply grab the latest version from gemcutter:
 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.
 
+For a more detailed look at Padrino installation, 
+check out the {Installation Guide}[http://wiki.github.com/padrino/padrino-framework/installation].
+
 == Usage
 
 Padrino is a framework which builds on the existing functionality and Sinatra and provides a variety of 
-additional tools and helpers to extend the foundation. This README and Padrino documentation in general will focus
+additional tools and helpers to build upon that foundation. This README and Padrino documentation in general will focus
 on the enhancements to the core Sinatra functionality. To use Padrino, one should be familiar with the basic 
-usage of Sinatra itself. Resources for Sinatra are listed below:
+usage of Sinatra itself. 
+
+Please check out the 
+{Understanding Sinatra}[http://wiki.github.com/padrino/padrino-framework/underlying-sinatra-overview] guide
+to learn more about these fundamentals.
 
-* {Sinatra Introduction}[http://www.sinatrarb.com/intro.html]
-* {Sinatra Book}[http://www.sinatrarb.com/book.html]
-* {Sinatra Github Repo}[http://github.com/sinatra/sinatra]
+For information on how to use a specific gem in isolation within an existing Sinatra project, checkout the guide for
+{Using Padrino in Sinatra}[http://wiki.github.com/padrino/padrino-framework/standalone-usage-in-sinatra].
 
-Below is a guide to how this gem enhances the Sinatra framework as part of a 'full-stack' padrino application.
-For information on how to use a specific gem in isolation within an existing Sinatra project, checkout the README for that 
-individual gem or gems.
+== Getting Started
+
+Once a developer understands Sinatra, Padrino is quite easy to get comfortable with since Padrino is simply a superset
+of existing Sinatra Functionality! Best way to get started with building Padrino applications is to read following resources:
+
+* {Blog Tutorial}[http://wiki.github.com/padrino/padrino-framework/blog-tutorial] - Step-by-step guide to building a blog application with Padrino.
+* {Quick Overview}[http://wiki.github.com/padrino/padrino-framework/basic-projects] - Outlines basic generation commands.
+* {Padrino Examples}[http://wiki.github.com/padrino/padrino-framework/examples] - List of known Padrino applications which can serve as examples.
 
 == Enhanced Base Application (padrino-core)
 
@@ -85,9 +82,6 @@ Padrino has support for an enhanced base application class <tt>Padrino::Applicat
 expands the capabilities of Sinatra::Application and automatically provides the resulting application access to all of
 the padrino framework's functionalities. 
 
-Similar in spirit to Sinatra itself, Padrino application layout is extremely flexible and can be as small as a single file.
-However, Padrino provides many extensions which improve upon the ability to construct more complex applications.
-
 === Simple Application Definition
 
 Let us first take a look at the simplest possible Padrino application:
@@ -105,12 +99,15 @@ Let us first take a look at the simplest possible Padrino application:
     # and for read better we can divide with controllers
     controller '/admin' do
       get '/foo' do
-        'Im /admin/foo
+        'Url is /admin/foo'
       end
     end
   end
 
-=== Controllers
+=== Enhanced Route Definitions and Controllers
+
+For a complete overview of the Padrino routing and controller system, 
+check out the {Routing and Controller guide}[http://wiki.github.com/padrino/padrino-framework/controllers].
 
 Suppose we wanted to add additional routes to our Padrino application, and we want to organize the routes
 within a more structured layout. Simply add a <tt>controllers</tt> or <tt>app/controllers</tt> folder and create a file as such:
@@ -121,40 +118,23 @@ within a more structured layout. Simply add a <tt>controllers</tt> or <tt>app/co
       "Text to return"
     end
   end
-
-== Advanced Routing Support
-
-Padrino provides support for advanced routing functionality not available within Sinatra. This routing
-supports named route aliases and easy access to url paths. The benefits of this is that instead of having to 
-hard-code route urls into every area of your application, now we can just define the urls in a 
-single spot and then attach an alias which can be used to refer to the url throughout the application.
-
-=== Padrino Routing
-
-Urls mapped here can then be defined within a controller:
+  
+You can also do more complex route alias definitions:
 
   # app/controllers/example.rb
-  SimpleApp.controllers do
+  SimpleApp.controllers :posts do
     get :index do
       ...
     end
 
-    get :account do
-      # access params[:name] and params[:index]
+    get :show, :with => :id do
+      # url generated is '/posts/show/:id'
+      # access params[:id]
     end
   end
 
-and finally referenced anywhere in the application:
-
-  # app/views/example.haml
-  = link_to "Index", url_for(:index)
-  = link_to "Account", url_for(:account, :id => 1, :name => 'first')
-
-=== Inline Route Alias Definitions
-
-The routing plugin also supports inline route definitions in which the url and the named alias
-are defined together within the controller:
-
+as well as mapping the route aliases to an explicit url:
+  
   # app/controllers/example.rb
   SimpleApp.controllers do
     get :index, :map => '/index' do
@@ -165,70 +145,13 @@ are defined together within the controller:
       # access params[:name] and params[:index]
     end
   end
-
-Routes defined inline this way can be accessed and treated the same way as traditional named aliases.
-
-=== Namespaced Route Aliases
-
-There is also support for namespaced routes which are organized into a larger grouping:
-
-  # app/controllers/example.rb
-  SimpleApp.controllers :admin do
-    get :show do
-      "Im /admin/show"
-    end
-
-    get :index, :map => "/admin/:id" do
-      "Im /admin/#{params[:id]}"
-    end
-  end
-
-You can then reference the urls using the same url_for method: 
-
-  <%= link_to 'admin show page', url_for(:admin_show, :id => 25) %>
-  <%= link_to 'admin index page', url_for(:admin_index, :id => 25) %>
-
-If you don't want named routes you can
-
-  # app/controllers/example.rb
-  SimpleApp.controllers "/admin" do
-    get "/show" do
-      "Im /admin/show"
-    end
-
-    get "other/:id" do
-      "Im /admin/#{params[:id]}"
-    end
-  end
-
-=== Named Params
-
-With Padrino you can use named params!! See these examples
-
-  # app/controllers/example.rb
-  SimpleApp.controllers :admin do
-    get :show, :with => :id do
-      "Im /admin/show/#{params[:id]}"
-    end
-
-    get :other, with => [:id, :name]  do
-      "Im /admin/#{params[:id]}/#{params[:name]}"
-    end
-  end
-
-You can then reference the urls using the same url_for method: 
-
-  <%= link_to 'admin show page', url_for(:admin_show, :id => 25) %>
-  <%= link_to 'admin other page', url_for(:admin_index, :id => 25, :name => :foo) %>
-
-=== Respond To
-
-With Padrino you can simply respond to a given format see example:
-
+  
+and even configure the respond_to for each route:
+  
   # app/controllers/example.rb
   SimpleApp.controllers :admin do
     get :show, :with => :id, :respond_to => :js do
-      "Im /admin/show/#{params[:id]}.#{params[:format]}"
+      "Url is /admin/show/#{params[:id]}.#{params[:format]}"
     end
 
     get :other, with => [:id, :name], respond_to => [:html, :json] do
@@ -238,17 +161,25 @@ With Padrino you can simply respond to a given format see example:
       end
     end
   end
-
-  <%= link_to 'admin show page', url_for(:admin_show, :id => 25, :format => :js) %>
-  <%= link_to 'admin other page', url_for(:admin_index, :id => 25, :name => :foo) %>
-  <%= link_to 'admin other json page', url_for(:admin_index, :id => 25, :name => :foo, :format => :json) %>
-
+  
+For a complete overview of the routing and controller system, check out the 
+{Routing and Controller guide}[http://wiki.github.com/padrino/padrino-framework/controllers].
+  
 === Rendering
 
-Unlike Sinatra Padrino support template auto lookup so:
+Unlike Sinatra, Padrino supports automatic template lookups such as:
 
-  # look for 'account/index.{erb,haml,...}
+  # searches for 'account/index.{erb,haml,...}
   render 'account/index'
+  
+This render does not require any template engine to be specified and will choose the first one that is discovered. 
+The existing render function works as well if an engine type should be specified:
+
+# example.haml
+render :haml, 'account/index'
+
+For a complete overview of the Padrino rendering system, check out the 
+{Routing and Controller guide}[http://wiki.github.com/padrino/padrino-framework/controllers].
 
 === Layout
 
@@ -261,26 +192,24 @@ With Padrino you can (like rails do) use for your custom layout, disable it
     
     # Use the layout located in views/layouts/custom.haml
     layout :custom
+    
+For a complete overview of the layout functionality, 
+check out the {Routing and Controller guide}[http://wiki.github.com/padrino/padrino-framework/controllers].
 
-=== Gemfile Dependency Resolution
-  
-While this is a fully operational Padrino application in itself, let us take a look at Padrino's expanded capabilites. First, 
-we can create Gemfile within the application root. This will contain a list of all the dependencies for our application.
-
-  # /Gemfile
-  clear_sources
-  source 'http://gemcutter.org'
-  gem 'sinatra',     :require => 'sinatra/base'
-  gem 'rack-flash'
-  
-This manifest file uses the standard <tt>bundler</tt> gem syntax of which details can be found in the
-{Bundler README}[http://github.com/wycats/bundler]
-This gem allows us to place all our dependencies into a single file. Padrino will then automatically require
-all necessary files (if they exist on the system). 
+=== Mounting Applications
+
+Padrino applications are all automatically mountable into other Padrino projects. This means that a given Padrino
+project directory can easily mount multiple applications. This allows for better organization of complex applications,
+re-usable applications that can be applied (i.e admin, auth, blog) and even more flexibility. 
+
+You can think of mountable applications as a 'full-featured' merb slice or rails engine. Instead of a separate construct, 
+any application can simply be packaged and mounted into another project.
 
-If the dependencies are not on the system, you can automatically vendor all necessary gems 
-using the <tt>gem bundle</tt> command within the application root. Note that this is all possible without
-any further effort than adding the Gemfile (or having this generated automatically with generators explained later).
+Padrino stores application mounting information by default within <tt>config/apps.rb</tt>. This file is intended
+to keep all information regarding what applications are mounted to which uri's. 
+
+For a complete look at mounting applications within a Padrino project, 
+check out the guide on {Mounting Applications}[http://wiki.github.com/padrino/padrino-framework/mounting-applications].
 
 === Auto Load Paths
 
@@ -289,34 +218,14 @@ functionality for easily splitting up your application into separate files. Padr
 as a convention for establishing database connection. Also, any files within the <tt>lib</tt> folder will be required 
 automatically by Padrino.
 
-This is powered by the fact that Padrino will automatically load (and reload) any directory patterns within the 'load path'. 
-Additional directory patterns can be added to the load path as needed by simply appending to the <tt>load_paths</tt> 
-within your application:
-
-  # app.rb
-  class SimpleApp < Padrino::Application
-    load_paths << ["app/special/*.rb", "some_file.rb"]
-  end
-  
-This will instruct Padrino to autoload these files (and reload them when changes are detected). By default, the load path 
-contains certain paths known to contain important files such as controllers, mailers, models, urls, and helpers. 
-
-Initializers are automatically required and 'registered' during the application startup process. Note that
-the name of the module must be the name of the file appended with 'Initializer' (i.e sample.rb => SampleInitializer)
+For a complete overview of auto-loaded paths within Padrino, 
+check out the {Padrino Development Guide}[http://wiki.github.com/padrino/padrino-framework/development-and-terminal-commands].
 
 === Application Logging
 
 Padrino also supports robust logging capabilities. By default, logging information will
 go to the STDOUT in development (for use in a console) and in an environment-specific log file <tt>log/development.log</tt>
 in test and production environments.
-
-You can modify the logging behavior or disable logging altogether:
-
-  # app.rb
-  class SimpleApp < Padrino::Application
-    disable :logging     # Turns off logging
-    enable  :log_to_file # Forces logging to be written to a file
-  end
   
 To use the logger within a Padrino application, simply refer to the <tt>logger</tt> method accessible
 within your app and any controller or views:
@@ -326,34 +235,8 @@ within your app and any controller or views:
     get("/test") { logger.info "This is a test" }
   end
   
-The logger automatically supports severity through the use of <tt>logger.info</tt>, <tt>logger.warn</tt>, <tt>logger.error</tt>, et al.
-For more information about the logger, check out the {Logger RDOC}[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/]
-
-=== Mounting Applications
-
-Padrino applications are all automatically mountable into other Padrino projects. This means that a given Padrino
-project directory can easily mount multiple applications. This allows for better organization of complex applications,
-re-usable applications that can be applied (i.e admin, auth, blog) and even more flexibility. 
-
-You can think of mountable applications as a 'full-featured' merb slice or rails engine. Instead of a separate construct, 
-any application can simply be packaged and mounted into another project.
-
-Padrino stores application mounting information by default within <tt>config/apps.rb</tt>. This file is intended
-to keep all information regarding what applications are mounted to which uri's. An <tt>apps.rb</tt> file has
-the following structure:
-
-  Padrino.mount("blog").to("/blog")
-  Padrino.mount("website").to("/website")
-  
-This would mount two applications onto the Padrino project, one served from the '/blog' uri namespace and the other
-served from the '/website' uri namespace. Often a Padrino project directory requires a single 'core' application
-which is served from the uri root. This can be easily configured using:
-
-  Padrino.mount_core("app_name") # mounts app with class AppName, in file <tt>app/app.rb</tt>
-  Padrino.mount_core("app_name", :app_file => Padrino.root('app.rb')) # now with file in <tt>app.rb</tt>
-  
-This will mount a 'core' application with class AppName from the file 'app.rb' to the uri root which will
-act as a primary application.
+For a complete overview of Padrino logger functionality, check out the 
+{Padrino Development Guide}[http://wiki.github.com/padrino/padrino-framework/development-and-terminal-commands].
 
 === Development Reloader
 
@@ -362,43 +245,10 @@ the need to restart the server. Through the use of a customized Rack middleware,
 are monitored and reloaded whenever changes are applied. 
 
 This makes rapid development much easier and provides a better alternative to 'shotgun' or 'rerun' 
-which require the application server to be restarted which makes requests take much longer to complete.
-
-An application can explicitly enable / disable reloading through the use of options:
-
-  # app.rb
-  class SimpleApp < Padrino::Application
-    disable :reload # reload is disabled in all environments
-    enable  :reload # enabled in all environments
-  end
-  
-By default, reloading is enabled in development and disabled in the test and production environments.
-
-If you want to build a standalone app you need to take some precautions see example:
-
-  # simple_demo.rb
-  PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
-  require 'padrino-core'
-
-  class SimpleDemo < Padrino::Application
-    set :reload, true
-
-    get "/" do
-      "This is a simple Demo!!!"
-    end
-  end
+which requires the application server to be restarted which makes requests take much longer to complete.
 
-  Padrino.mount_core("SimpleDemo")
-
-  Padrino.run! unless Padrino.loaded? # If you enable reloader prevent to re-run the app 
-
-  Padrino.load!
-
-Now you can run simple_demo.rb with:
-
-  $ ruby simple_demo.rb
-
-Browse http://localhost:3000 edit your file and refresh your page for see changes!
+For a complete overview of code reloading in development, 
+check out the {Padrino Development Guide}[http://wiki.github.com/padrino/padrino-framework/development-and-terminal-commands].
 
 === Terminal Commands
 
@@ -408,7 +258,7 @@ common tasks such as starting / stopping the application, executing the unit tes
 The following commands are available:
 
   # starts the app server (non-daemonized)
-  $ padrino start 
+  $ padrino start
   # starts the app server (daemonized) with given port, environment and adapter
   $ padrino start -d -p 3000 -e development -a thin 
   
@@ -421,39 +271,11 @@ The following commands are available:
   # Run/List tasks
   $ padrino rake
 
-The last command "padrino rake" look for rake files in:
-
-  lib/tasks/**/*.rake
-  tasks/**/*.rake
-  test/test.rake
-  spec/spec.rake
-
-In this way you can customize project tasks.
-
-Using these commands can simplify common tasks making development that much smoother.
-
-=== Special Folders
-
-Padrino load these paths:
-
-  project/lib
-  project/models
-  project/shared/lib
-  project/shared/models
-  project/each_app/models
-
-This mean that you are free to store for example +models+ where you prefer, if you have two or more apps with same
-models you can use +project+/+shared+/+models+ or +root+/+models+.
-
-If you have only one app you still use +project+/+app+/+models+ (this is the default padrino-gen choice)
-
-Remember that if you need to load other paths you can use:
-
-  Padrino.set_load_paths("path/one")
-
-and if you need to load dependencies use:
+You can also create custom rake tasks as well. Using these commands can simplify common tasks 
+making development that much smoother.
 
-  Padrino.require_dependencies("path/one/**/*.rb")
+For a complete overview of Padrino terminal commands, check out the 
+{Padrino Commands Guide}[http://wiki.github.com/padrino/padrino-framework/development-and-terminal-commands].
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.2

data/lib/padrino-core/application/routing.rb

@@ -216,7 +216,7 @@ module Padrino
             end
 
             # Build our controller
-            controller = Array(@_controller).collect(&:to_s)
+            controller = Array(@_controller).collect { |c| c.to_s }
 
             unless controller.empty?
               # Now we need to add our controller path only if not mapped directly

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

@@ -13,7 +13,7 @@ module Padrino
 
             fork do
               Process.setsid
-              return if fork
+              exit if fork
               File.umask 0000
               puts "=> Padrino server has been daemonized with pid #{Process.pid}"
               STDIN.reopen "/dev/null"
@@ -25,11 +25,10 @@ module Padrino
 
               if pid
                 File.open(pid, 'w'){ |f| f.write("#{Process.pid}") }
-                at_return { File.delete(pid) if File.exist?(pid) }
               end
 
               Padrino.run!(options.host, options.port, options.adapter)
-
+              exit
             end
           else
             Padrino.run!(options.host, options.port, options.adapter)
@@ -43,6 +42,7 @@ module Padrino
             print "=> Sending SIGTERM to process with pid #{pid} wait "
             Process.kill(15, pid) rescue nil
             1.step(5) { |i| sleep i; print "."; $stdout.flush }
+            File.delete("tmp/pids/server.pid")
             puts " done."
           end
         end

data/padrino-core.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-core}
-  s.version = "0.9.1"
+  s.version = "0.9.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{2010-02-23}
+  s.date = %q{2010-03-01}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{padrinorb@gmail.com}
@@ -70,7 +70,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{padrino-core}
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{The required Padrino core gem}
 
   if s.respond_to? :specification_version then

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 9
-  - 1
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors: 
 - Padrino Team
@@ -17,149 +12,109 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-23 00:00:00 -08:00
+date: 2010-03-01 00:00:00 +01:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        - 4
         version: 0.9.4
-  type: :runtime
-  version_requirements: *id001
+    version: 
 - !ruby/object:Gem::Dependency 
   name: i18n
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 3
-        - 2
         version: 0.3.2
-  type: :runtime
-  version_requirements: *id002
+    version: 
 - !ruby/object:Gem::Dependency 
   name: usher
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 6
-        - 2
         version: 0.6.2
-  type: :runtime
-  version_requirements: *id003
+    version: 
 - !ruby/object:Gem::Dependency 
   name: thor
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 13
-        - 0
         version: 0.13.0
-  type: :runtime
-  version_requirements: *id004
+    version: 
 - !ruby/object:Gem::Dependency 
   name: bundler
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        - 7
         version: 0.9.7
-  type: :runtime
-  version_requirements: *id005
+    version: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        - 5
         version: 2.3.5
-  type: :runtime
-  version_requirements: *id006
+    version: 
 - !ruby/object:Gem::Dependency 
   name: shoulda
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 10
-        - 3
         version: 2.10.3
-  type: :development
-  version_requirements: *id007
+    version: 
 - !ruby/object:Gem::Dependency 
   name: mocha
-  prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        - 7
         version: 0.9.7
-  type: :development
-  version_requirements: *id008
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rack-test
-  prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 0
         version: 0.5.0
-  type: :development
-  version_requirements: *id009
+    version: 
 - !ruby/object:Gem::Dependency 
   name: webrat
-  prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 1
         version: 0.5.1
-  type: :development
-  version_requirements: *id010
+    version: 
 description: The Padrino core gem required for use of this framework
 email: padrinorb@gmail.com
 executables: 
@@ -229,20 +184,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: padrino-core
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: The required Padrino core gem