sinatra-chassis 1.0.5 → 1.1.0

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -1,14 +1,473 @@
-## Chassis
+# Chassis
 
-Chassis is a mutable framework extension for Sinatra that's designed not just to help you write less code, but to help you focus on less code.
+Chassis is a mutable framework extension for Sinatra that's designed to help you focus on less code by writing less code.
 
-    gem install sinatra-chassis
+It starts by generating a basic Sinatra application, bootstrapped to run on Rack. As your application grows, Chassis will adapt itself to your changes. You choose the gems, design patterns, scope, and size of your application.
 
-### Instructions
+Focus only on what you use, and forget the rest.
 
-http://jarrodtaylor.github.com/sinatra-chassis/
 
-### License
+[jarrodtaylor.github.io/sinatra-chassis](http://jarrodtaylor.github.io/sinatra-chassis/)
+
+## Getting Started
+
+### Prerequisites
+
+- A working Ruby installation: [ruby-lang.org](http://www.ruby-lang.org/)
+- Experience with Sinatra: [sinatrarb.com](http://www.sinatrarb.com)
+
+### Installation
+
+Install Chassis as a RubyGem:
+
+```bash
+~: gem install sinatra-chassis
+```
+
+### Generating an Application
+
+The Chassis gem comes with a cli for generating ready-to-run applications:
+
+```
+~: chassis
+The chassis command creates a new chassis app. 
+
+Usage:
+  chassis [options] app_path 
+
+Example:
+  chassis -g -h ~/Projects/my_app 
+
+Options:
+  -g, --git            Init a git repo, add the first commit
+  -h, --heroku         Create a Heroku app
+      --skip-bundle    Don't run bundle install
+  -e, --extension      Create a Chassis extension
+```
+
+The ```chassis``` command will generate a boilerplate application and bundle it's gems. Adding ```-g``` will initialize a git repo and add the first commit. Adding ```-h``` will create and link to an app on Heroku. Adding ```--skip-bundle``` will skip over the gem bundling step. And ```-e``` will generate a Chassis extension template.
+
+> The -g and -h switches assume git and the heroku toolbelt to already be installed.
+
+Create a new application and take a look around:
+
+```bash
+~: chassis SampleApp
+~: cd SampleApp
+```
+
+--
+
+### What's Included
+
+##### app.rb
+> Hooks together all the pieces of the application:
+> - Requires the gems in Gemfile.lock
+> - Requires the Chassis helpers
+> - Requires sinatra/reloader in development
+> - Enables sessions and sets a session_secret
+> - Requires the default load path
+> - Adds a sample route
+
+##### config.ru
+> Loads app.rb on a Rack server.
+
+##### /tmp/restart.txt
+> Used to restart the application on a Rack server.
+
+##### /public
+> For storing publicly accessible files, such as JavaScripts and Stylesheets, as well as:
+> - /public/robots.txt for handling web crawlers
+> - /public/favicon.ico for adding a favicon to browser bookmarks and address bars
+
+##### Gemfile and Gemfile.lock
+> For managing gems.
+
+##### /views/layout.erb
+> A stock HTML5 template with alert and yield methods already in the body.
+
+##### Rakefile
+> Loads app.rb, the Chassis rake tasks, rake tasks from the loaded extensions, and all your own .rake scripts from /tasks.
+
+##### .gitignore
+> For keeping unnecessary files out of your git repository.
+
+##### README.md
+> A place to put instructions for using your application.
+
+### Running on Localhost
+
+Chassis is based on a standard Sinatra application, and runs the same way:
+
+```bash
+~/SampleApp: ruby app.rb
+```
+
+Your application is now running at [localhost:4567](http://localhost:4567/).
+
+> Use ```Ctrl-C``` to stop the local server.
+
+## The Basics
+
+### Loading Your Application
+
+Your application structure is defined in app.rb with the ```require_directory``` method, allowing you to organize your application code into multiple files and load them in the proper order.
+
+```ruby
+require_directory([
+  'config',
+  'settings',
+  'modules',
+  'helpers',
+  'libraries',
+  'models',
+  'controllers',
+  'routes'
+])
+```
+
+```require_directory``` will require all the Ruby scripts from each directory it's passed, and you can add your own directory structure to the Array.
+
+### Adding Route Handlers
+
+Namespaced routes and tests can be generated with the rake task ```sinatra:add:routes[namespace]```. The ```[namespace]``` argument is required.
+
+```bash
+~/SampleApp: rake sinatra:add:routes[users]
+# => add ./routes/users.rb
+# => add ./tests/routes/users_tests.rb
+```
+
+### CoffeeScript and Sass
+
+CoffeeScript and Sass files in the /public directory will be automatically compiled when requested. Just link to them as if linking to a .js or .css file:
+
+```html
+<head>
+  <!-- Compile and load /public/js/global.coffee -->
+  <script type="text/javascript" src="/js/global.js"></script>
+
+  <!-- Compile and load /public/css/theme.scss -->
+  <link rel="stylesheet" type="text/css" href="/css/theme.css">
+</head>
+```
+
+> Notice the .js and .css extensions. If a .js or .css file exists in the same directory and with the same name as a .coffee or .scss file, the .js or .css file will be loaded. This allows assets to be precompiled without changing the script and link tags.
+
+#### Precompiling
+
+Compiling CoffeeScript and Sass is generally too slow to be good practice on a production server. The solution is to work with .coffee and .scss during development, then precompile them into .js and .css for deployment.
+
+The task ```rake assets:precompile``` will compile all .coffee and .scss files in /public into .js and .css files of the same name.
+
+```bash
+~/SampleApp: rake assets:precompile
+```
+
+Web servers will see the .js and .css files first, bypassing the .coffee and .scss files completely.
+
+> Precompiled assets are automatically minified.
+
+If you need to use "bare" CoffeeScript, just set ```Tilt::CoffeeScriptTemplate.default_bare``` to true. On-the-fly and precompiled .coffee files will the compiled as bare JavaScript.
+
+Adding assets:precompile to your deploy scripts will automate this process, as well as keep compiled files out of source control.
+
+> Heroku already does this by default, it works with their read-only filesystem.
+
+The task ```rake assets:decompile``` will remove the compiled .js and .css files.
+
+```bash
+~/SampleApp: rake assets:decompile
+```
+
+#### Assets Path
+
+By default, Chassis uses /public for .coffee and .scss files. To use other directories, add them to the ```assets_path``` setting:
+
+```ruby
+set :assets_path, ['public', 'scripts']
+```
+
+```html
+<head>
+  <!-- Compile and load /scripts/global.coffee -->
+  <script type="text/javascript" src="/scripts/global.js"></script>
+</head>
+```
+
+> All .coffee and .scss files will be moved to /public when precompiled.
+
+### Mobile Templates
+
+In cases where responsive design just won't work, Chassis can find mobile view templates and layouts. Prefix your view template extension with ```.mobile``` and it will be sent to mobile devices only.
+
+For example: ```hello_world.erb``` would have the mobile counterpart ```hello_world.mobile.erb```, and ```layout.haml``` would have the mobile counterpart ```layout.mobile.haml```.
+
+To enable mobile templates, use the ```mobile_views``` setting:
+
+```ruby
+enable :mobile_views
+```
+
+Mobile devices are determined by their user agents, which are listed as an Array of regular expressions in the ```mobile_user_agents``` setting. The default setting applies to iPhone and Android devices, but you're free to override it:
+
+```ruby
+set :mobile_user_agents, [/iPhone/, /Android.*AppleWebKit/]
+```
+
+### Catch-all Route Handling
+
+Sinatra evaluates all the routes in your application and returns a 404 Not Found error if it doesn't find a match. Chassis intercepts this error and looks in the /views directory for a directory/template combination that matches the request path before passing the request to an error page.
+
+For example: A request for ```/hello/world``` will first look for the route handler ```get('/hello/world')```. If the route handler doesn't exist, it will then look for the template ```/views/hello/world.erb```. If the template doesn't exits, it will raise a 404 Not Found error.
+
+The template extension/rendering engine doesn't matter: ```/views/hello/world.erb``` will work just as well as ```/views/hello/world.haml```.
+
+To disable catch-all route handling:
+
+```ruby
+disable :catch_all_route
+```
+
+### Production Error Pages
+
+No production application should be without well styled error pages. Chassis adds a basic error page, only shown when running in production.
+
+To use a your own custom error page, create the view template ```/views/error.erb```. Chassis makes the error available to the template with the variables code and message:
+
+```erb
+<h1>Error <%= code %></h1>
+<hr />
+<h2><%= message %></h2>
+```
+
+> Note that when your application is running in development mode, you'll still see the usual Sinatra error pages.
+
+### Running Tests
+
+Any test scripts in /tests can be run with the rake task ```chassis:test[file]```:
+
+```bash
+~/SampleApp: rake chassis:test[routes/users_tests]
+```
+
+Leaving out the ```[file]``` argument will run everything in /tests:
+
+```bash
+~/SampleApp: rake chassis:test
+```
+
+### Adding Rake Tasks
+
+In addition to the Chassis rake tasks, any ```.rake``` files you add to the /tasks directory will automatically be available.
+
+### Interactive Ruby Shell
+
+To load your application in an IRB session:
+
+```bash
+~/SampleApp: rake chassis:irb
+irb(main):001:0> settings.catch_all_route
+=> true
+irb(main):002:0> exit
+```
+
+## Helpers
+
+Chassis comes with a few Sinatra helpers to speed up coding of commonly reused elements.
+
+### Active Links
+
+To compare links with the current URL, use the active helper:
+
+```erb
+<a href="/hello/world" class="<%= active('hello') %>">Hi</a>
+# => <a href="/hello/world" class="active">Hi</a>
+<a href="/goodbye/world" class="<%= active('goodbye') %>">Bye</a>
+# => <a href="/goodbye/world" class="">Bye</a>
+```
+
+> Style a.active links in your CSS for "sticky" links.
+
+### Alerting Users
+
+The alert helper uses rack-flash to send one-time messages to users:
+
+```ruby
+get '/send/message/?'
+  flash[:alert] = 'This is a public service announcement.'
+  redirect '/hello/world'
+end
+```
+
+```erb
+<%= alert %>
+# => <div id='alert'>This is a public service announcement.</div>
+```
+
+> Flash empties itself after each request, so your message will only display once.
+
+### Date Selects
+
+The ```date_select``` helper, when combined with the Sinatra ```time_for``` helper, makes converting dates to and from DateTime objects for a database simple:
+
+```erb
+<form>
+  <%= date_select(DateTime.now,
+        select_class: 'updated_at',
+           select_id: 'updated_at',
+         select_name: 'updated_at',
+          start_year: 1999,
+            end_year: 2021,
+           day_first: true,
+          month_name: false) %>
+</form>
+```
+
+A valid DateTime object is the only required argument. The others are recommended:
+
+**select_name**: name attribute for fields, appended with _day, _month, or _year
+
+**select_id**: id attribute for fields, appended with _day, _month, or _year
+
+**select_class**: class attribute for fields
+
+**start_year**: first year to use in year select (default: 3 years ago)
+
+**end_year**: last year to use in year select (default: 3 years from now)
+
+**day_first**: true/false to show the day before the month (default: false)
+
+**month_name**: true/false to display month names (default: false)
+
+> For easy site-wide styling, generated select fields always have the classes ```month_select```, ```day_select```, and ```year_select```.
+
+To convert back to a DateTime object, use the ```time_for``` Sinatra helper on the submitted form fields:
+
+```ruby
+time_for("#{params[:dob_month]}-#{params[:dob_day]}-#{params[:dob_year]}")
+```
+
+### Hiding Elements
+
+When it's necessary to hide elements based on Ruby conditionals:
+
+```erb
+<div style="<%= hidden unless @user.recent? %>">Hello, world!</div>
+# => <div style="display: none;">Hello, world!</div>
+```
+
+### Numerability
+
+Ruby uses duck typing, but incompatible types are still incompatible. To find out if a String can be used as a Number:
+
+```ruby
+numeric?('1')
+# => true
+numeric?('hello')
+# => false
+```
+
+### Titles
+
+Titleizing a String will uppercase the first letter of each word:
+
+```ruby
+titleize('hello world')
+# => 'Hello World'
+```
+
+### Truncation
+
+The truncate helper will truncate both Strings and Numbers:
+
+```ruby
+truncate('Lorem ipsum dolor sit amet.', word_count: 3, end_string: '...')
+# => 'Lorem ipsum dolor...'
+truncate(1.234000, decimal: 1)
+# => 1.2
+truncate(1.234000, decimal: 5)
+# => 1.234
+truncate(1.234000, decimal: 5, trailing_zeros: true)
+# => '1.23400'
+```
+
+> ```truncate()``` will try to round numbers by default. For simple truncation, pass ```round: false```.
+
+## Extensions
+
+Chassis can be easily extended to work with other gems, databases, APIs, design patterns, etc. Extensions are packaged as gems, and included in your Gemfile. Example:
+
+```ruby
+gem 'chassis-datamapper'
+```
+
+Running ```bundle install``` after adding an extension gem will make that it available to your app.
+
+> Some gems will include a setup rake task to help get things started. Be sure to check out your newly available tasks for each extension with ```rake -T```.
+
+### Commonly Used Extensions
+
+- **DataMapper** for working with databases: [chassis-datamapper](https://github.com/jarrodtaylor/chassis-datamapper)
+- **Pony** for sending emails: [chassis-pony](https://github.com/jarrodtaylor/chassis-pony)
+
+### Writing Your Own
+
+If you're familiar with writing RubyGems, you can create your own extensions:
+
+```bash
+chassis -e my_extension
+```
+
+The generated extension includes placeholders to fill in your own code, tasks, and templates.
+
+## Release Notes
+
+##### v1.1.0 (June 17, 2013)
+
+- Added support for extensions.
+- Removed DataMapper and Pony (they're now extensions).
+- Updated the Gemfile to use the RubyGems url string.
+- Updated Sinatra version to 1.4.3.
+- Required ./app.rb from Chassis instead of the app.
+- Added an extension template generator.
+- Added a ton of documentation to the readme.
+
+##### v1.0.5 (June 8, 2013)
+
+- Added the option to generate "bare" CoffeeScript if Tilt::CoffeeScriptTemplate.default\_bare is set to true.
+
+##### v1.0.4 (June 7, 2013)
+
+- Updated the truncate helper to round numbers when truncating.
+- Updated the required gems to newer versions.
+- Cleaned up the default readme, no longer requiring Kramdown.
+- Added asset minifying.
+
+
+##### v1.0.3 (May 7, 2013)
+
+- Added /modules to the default load path.
+- Fixed the truncate helper to work with the numberic? helper.
+
+##### v1.0.2 (April 6, 2013)
+
+- Moved require_directory below session setup in app.rb.
+- Deprecated settings.load_path in favor of a default Array of directories.
+- Disabled settings.mobile\_views by default.
+- Fixed mobile view routing.
+
+##### v1.0.1 (March 25, 2013)
+
+- Updated the gem license ownership.
+- Replaced the :rubygems symbol in the Gemfile with the string 'https://rubygems.org'.
+- Locked in Sinatra v.1.3.4 (until sinatra-contrib supports Sinatra v1.4).
+
+##### v1.0.0 (February 5, 2013)
+
+- First!
+
+## License
 
 Copyright (C) 2013 Jarrod Taylor.
 

data/bin/chassis

@@ -5,9 +5,10 @@ require 'sinatra/chassis/file_manager'
 
 # Sets the default switches
 switches = {
-  git:     false,
-  heroku:  false,
-  bundler: true
+  extension: false,
+  git:       false,
+  heroku:    false,
+  bundler:   true
 }
 
 # Internal: Parses command options and runs associated methods.
@@ -25,10 +26,12 @@ options = OptionParser.new do |opt|
   
   opt.on('--skip-bundle', 'Don\'t run bundle install') { switches[:bundler] = false }
   
+  opt.on('-e', '--extension', 'Create a Chassis extension') { switches[:extension] = true }
+  
   opt.parse!
 end
 
-# If app name is given, create application.
+# If app name is given, create application or extension.
 if ARGV[0]
   app = ARGV[0]
   
@@ -41,17 +44,33 @@ if ARGV[0]
     exit
   end
   
-  copy_directory "#{TEMPLATES}/chassis", app
-  
-  if switches[:bundler]
-    puts LABELS[:run] + 'bundle'
-    system "cd #{app} && bundle install"
+  if switches[:extension]
+    copy_directory "#{TEMPLATES}/extension", app
+    
+    File.delete "#{app}/chassis-extension.gemspec"
+    File.delete "#{app}/lib/chassis-extension.rb"
+    File.delete "#{app}/lib/chassis/tasks/chassis-extension.rake"
+    
+    copy_template "#{TEMPLATES}/extension/chassis-extension.gemspec",
+                  "#{app}/#{app}.gemspec",
+                  locals = { name: app }
+    copy_template "#{TEMPLATES}/extension/lib/chassis-extension.rb",
+                  "#{app}/lib/#{app}.rb"
+    copy_template "#{TEMPLATES}/extension/lib/chassis/tasks/chassis-extension.rake",
+                  "#{app}/lib/chassis/tasks/#{app}.rake"
+  else
+    copy_directory "#{TEMPLATES}/chassis", app
+    
+    if switches[:bundler]
+      puts LABELS[:run] + 'bundle'
+      system "cd #{app} && bundle install"
+    end
   end
-  
+    
   puts LABELS[:run] + 'chmod -r 0755'
   FileUtils.chmod_R 0755, app
   
-  if switches[:git]
+  if switches[:git] || switches[:extension]
     puts LABELS[:run] + 'git'
     system "cd #{app} && git init && git add . && git commit -m 'First!'"
   end
@@ -61,7 +80,7 @@ if ARGV[0]
     system "cd #{app} && heroku create && git push heroku master"
   end
   
-  puts "\n  Next steps:\n    cd #{app}\n    ruby app.rb\n\n"
+  puts "\n  Next steps:\n    cd #{app}\n    ruby app.rb\n\n" unless switches[:extension]
   exit
 end
 

data/lib/sinatra/chassis/tasks.rb

@@ -1,11 +1,21 @@
-# Require this script in app Rakefiles to import the Chassis file_manager,
-# the Chassis app rake tasks, and the tasks in the app /tasks directory.
+# Require the application
+require './app'
 
+# Make the file manager library available to Rake tasks
 require "#{File.dirname(__FILE__)}/file_manager"
 
+# Fix for Rake v10+ not using the top level DSL
 class Sinatra::Application
   extend Rake::DSL if defined? Rake::DSL
 end
 
+# Import the Chassis tasks
 Dir[File.join(File.dirname(__FILE__) + "/../tasks/**/*.rake")].each { |file| import file }
+
+# Import Chassis extension gem tasks
+Gem.loaded_specs.values.each do |v|
+  Dir["#{v.full_gem_path}/lib/chassis/tasks/**/*.rake"].each { |file| import file }
+end
+
+# Import tasks from the app
 Dir["./tasks/**/*.rake"].each { |file| import file }

data/lib/sinatra/tasks/chassis.rake

@@ -7,17 +7,13 @@ namespace :chassis do
     IRB.start
   end
   
-  namespace :run do
-    
-    desc 'Run one or all /tests scripts'
-    task :test, :file do |t, args|
-      if args.file == nil
-        Dir["./tests/**/*.rb"].each { |file| require file }
-      else
-        require "./tests/#{args.file}"
-      end
+  desc 'Run one or all /tests scripts'
+  task :test, :file do |t, args|
+    if args.file == nil
+      Dir["./tests/**/*.rb"].each { |file| require file }
+    else
+      require "./tests/#{args.file}"
     end
-    
   end
-  
+      
 end

data/lib/sinatra/templates/chassis/Gemfile

@@ -3,6 +3,9 @@ source 'https://rubygems.org'
 gem 'coffee-script', '>= 2.2.0'
 gem 'jsmin', '>= 1.0.1'
 gem 'sass', '>= 3.2.9'
-gem 'sinatra', '>= 1.4.2'
-gem 'sinatra-chassis', '>= 1.0.5', require: 'sinatra/chassis'
+gem 'sinatra', '>= 1.4.3'
+gem 'sinatra-chassis', '>= 1.1.0', require: 'sinatra/chassis'
 gem 'sinatra-contrib', '>= 1.4.0', require: 'sinatra/contrib'
+
+# gem 'chassis-datamapper'
+# gem 'chassis-pony'

data/lib/sinatra/templates/chassis/Rakefile

@@ -1,2 +1 @@
-require './app'
 require 'sinatra/chassis/tasks'

data/lib/sinatra/templates/extension/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/lib/sinatra/templates/extension/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/lib/sinatra/templates/extension/README.md

@@ -0,0 +1 @@
+Instructions for using your extension go here...

data/lib/sinatra/templates/extension/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/sinatra/templates/extension/chassis-extension.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |s|
+
+  s.name        = '<%= locals[:name] %>'
+  s.version     = '0.0.1'
+  s.author      = ''
+  s.email       = ''
+  s.homepage    = ''
+  s.summary     = ''
+  s.description = ''
+  s.license     = ''
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.add_dependency 'sinatra-chassis', '>= 1.1.0'
+
+end

data/lib/sinatra/templates/extension/lib/chassis-extension.rb

@@ -0,0 +1 @@
+# Code here will be available to apps using your extension.

data/lib/sinatra/templates/extension/lib/chassis/tasks/chassis-extension.rake

@@ -0,0 +1 @@
+# Rake tasks in this directory will be available to apps using your extension.

data/lib/sinatra/templates/extension/lib/chassis/templates/template.rb

@@ -0,0 +1 @@
+# Templates like this one can be copied from your extension to the app.

data/sinatra-chassis.gemspec

@@ -4,12 +4,12 @@ $:.push File.expand_path('../lib', __FILE__)
 Gem::Specification.new do |s|
   
   s.name        = 'sinatra-chassis'
-  s.version     = '1.0.5'
+  s.version     = '1.1.0'
   s.author      = 'Jarrod Taylor'
   s.email       = 'jarrodtaylor@icloud.com'
   s.homepage    = 'http://jarrodtaylor.github.io/sinatra-chassis'
   s.summary     = 'Chassis is a mutable framework extension for Sinatra.'
-  s.description = "Chassis is a mutable framework extension for Sinatra that's designed not just to help you write less code, but to help you focus on less code."
+  s.description = "Chassis is a mutable framework extension for Sinatra that's designed to help you focus on less code by writing less code."
   s.license     = 'MIT'
   
   s.files         = `git ls-files`.split("\n")
@@ -23,6 +23,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'rack-flash3', '>= 1.0.3'
   s.add_dependency 'rack-test', '>= 0.6.2'
   s.add_dependency 'sass', '>= 3.2.9'
-  s.add_dependency 'sinatra', '>= 1.4.2'
+  s.add_dependency 'sinatra', '>= 1.4.3'
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-chassis
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-08 00:00:00.000000000 Z
+date: 2013-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coffee-script
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 1.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,9 +106,9 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 1.4.3
 description: Chassis is a mutable framework extension for Sinatra that's designed
-  not just to help you write less code, but to help you focus on less code.
+  to help you focus on less code by writing less code.
 email: jarrodtaylor@icloud.com
 executables:
 - chassis
@@ -127,8 +127,6 @@ files:
 - lib/sinatra/chassis/tasks.rb
 - lib/sinatra/tasks/assets.rake
 - lib/sinatra/tasks/chassis.rake
-- lib/sinatra/tasks/datamapper.rake
-- lib/sinatra/tasks/pony.rake
 - lib/sinatra/tasks/sinatra.rake
 - lib/sinatra/templates/chassis/.gitignore
 - lib/sinatra/templates/chassis/Gemfile
@@ -140,12 +138,14 @@ files:
 - lib/sinatra/templates/chassis/public/robots.txt
 - lib/sinatra/templates/chassis/tmp/restart.txt
 - lib/sinatra/templates/chassis/views/layout.erb
-- lib/sinatra/templates/datamapper/data/migrations/datamapper_migration.rb
-- lib/sinatra/templates/datamapper/data/seeds/seed.rb
-- lib/sinatra/templates/datamapper/models/datamapper.rb
-- lib/sinatra/templates/datamapper/settings/datamapper.rb
-- lib/sinatra/templates/datamapper/tests/models/datamapper_tests.rb
-- lib/sinatra/templates/pony/settings/pony.rb
+- lib/sinatra/templates/extension/.gitignore
+- lib/sinatra/templates/extension/Gemfile
+- lib/sinatra/templates/extension/README.md
+- lib/sinatra/templates/extension/Rakefile
+- lib/sinatra/templates/extension/chassis-extension.gemspec
+- lib/sinatra/templates/extension/lib/chassis-extension.rb
+- lib/sinatra/templates/extension/lib/chassis/tasks/chassis-extension.rake
+- lib/sinatra/templates/extension/lib/chassis/templates/template.rb
 - lib/sinatra/templates/sinatra/routes/routes.rb
 - lib/sinatra/templates/sinatra/tests/routes/routes_tests.rb
 - lib/sinatra/views/error.erb

data/lib/sinatra/tasks/datamapper.rake

@@ -1,117 +0,0 @@
-namespace :setup do
-  
-  desc 'Set up DataMapper'
-  task :datamapper do
-    create_directory './settings'
-    append_to_file './Gemfile', "\ngem 'data_mapper', '~> 1.2.0'"
-    append_to_file './Gemfile', "\ngem 'dm-sqlite-adapter', '~> 1.2.0'"
-    append_to_file './Gemfile', "\n# gem 'dm-mysql-adapter', '~> 1.2.0'"
-    append_to_file './Gemfile', "\n# gem 'dm-postgres-adapter', '~> 1.2.0'\n"
-    append_to_file './app.rb', "\nDataMapper.finalize\n"
-    copy_file "#{TEMPLATES}/datamapper/settings/datamapper.rb",
-              "./settings/datamapper.rb"
-  end
-  
-end
-
-namespace :dm do
-  
-  def create_dm_path
-    if DataMapper.repository.adapter.options[:path].include? 'sqlite'
-      db = DataMapper.repository.adapter.options[:path].split('/').last
-      create_directory DataMapper.repository.adapter.options[:path].gsub(db, '')
-    end
-  end
-  
-  namespace :add do
-    
-    desc 'Add a data migration' if defined? DataMapper
-    task :migration, :name do |t, args|
-      if args.name == nil
-        puts 'You must define a migration name.'
-        puts 'Example: rake add:migration[my_migration]'
-        exit
-      end
-      create_directory './data', './data/migrations'
-      t = Time.now.strftime("%Y%m%d%H%M%S")
-      copy_template "#{TEMPLATES}/datamapper/data/migrations/datamapper_migration.rb",
-                    "./data/migrations/#{t}_#{args.name}.rb",
-                    { t: t, migration: args.name }
-    end
-    
-    desc 'Add a model' if defined? DataMapper
-    task :model, :name do |t, args|
-      if args.name == nil
-        puts 'You must define a model name.'
-        puts 'Example: rake add:model[my_model]'
-        exit
-      end
-      create_directory './models', './tests', './tests/models'
-      copy_template "#{TEMPLATES}/datamapper/models/datamapper.rb",
-                    "./models/#{args.name}.rb",
-                    { model: args.name }
-      copy_template "#{TEMPLATES}/datamapper/tests/models/datamapper_tests.rb",
-                    "./tests/models/#{args.name}_tests.rb",
-                    { model: args.name }
-    end
-    
-    desc 'Add a seed data script' if defined? DataMapper
-    task :seed, :name do |t, args|
-      if args.name == nil
-        puts 'You must define a seed file name.'
-        puts 'Example: rake add:seed[my_seed_script]'
-        exit
-      end
-      create_directory './data', './data/seeds'
-      copy_template "#{TEMPLATES}/datamapper/data/seeds/seed.rb",
-                    "./data/seeds/#{args.name}.rb"
-    end
-    
-  end
-  
-  desc 'Auto upgrade one or all models' if defined? DataMapper
-  task :upgrade, :model do |t, args|
-    create_dm_path
-    args.model == nil ? DataMapper.auto_upgrade! : args.model.constantize.auto_upgrade!
-  end
-  
-  desc 'Auto migrate one or all models' if defined? DataMapper
-  task :migrate, :model do |t, args|
-    create_dm_path
-    args.model == nil ? DataMapper.auto_migrate! : args.model.constantize.auto_migrate!
-  end
-  
-  namespace :migrate do
-    
-    desc 'Migrate up to a specific migration number' if defined? DataMapper
-    task :up, :number do |t, args|
-      create_dm_path
-      require 'dm-migrations/migration_runner'
-      Dir['./data/migrations/*.rb'].each { |m| require m }
-      args.number == nil ? migrate_up! : migrate_up!(args.number)
-    end
-    
-    desc 'Migrate down to a specific migration number' if defined? DataMapper
-    task :down, :number do |t, args|
-      create_dm_path
-      require 'dm-migrations/migration_runner'
-      Dir['./data/migrations/*.rb'].each { |m| require m }
-      args.number == nil ? migrate_down! : migrate_down!(args.number)
-    end
-    
-  end
-  
-  namespace :run do
-    
-    desc 'Run one or all /data/seeds scripts' if defined? DataMapper
-    task :seed, :file do |t, args|
-      if args.file == nil
-        Dir["./data/seeds/**/*.rb"].each { |file| require file }
-      else
-        require "./data/seeds/#{args.file}"
-      end
-    end
-    
-  end
-  
-end

data/lib/sinatra/tasks/pony.rake

@@ -1,11 +0,0 @@
-namespace :setup do
-  
-  desc 'Set up Pony'
-  task :pony do
-    create_directory './settings'
-    append_to_file './Gemfile', "\ngem 'pony', '~> 1.4'\n"
-    copy_file "#{TEMPLATES}/pony/settings/pony.rb",
-              "./settings/pony.rb"
-  end
-  
-end

data/lib/sinatra/templates/datamapper/data/migrations/datamapper_migration.rb

@@ -1,13 +0,0 @@
-migration <%= locals[:t] %>, :<%= locals[:migration] %> do
-  
-  up do
-    # create_table :widgets do
-    #   column :id, Integer, serial: true
-    # end
-  end
-  
-  down do
-    # drop_table :widgets
-  end
-  
-end

data/lib/sinatra/templates/datamapper/data/seeds/seed.rb

@@ -1 +0,0 @@
-# User.first_or_create(email: 'johndoe@example.com')

data/lib/sinatra/templates/datamapper/models/datamapper.rb

@@ -1,8 +0,0 @@
-class <%= locals[:model].capitalize %>
-  include DataMapper::Resource
-  
-  timestamps :at, :on
-  property   :deleted_at, ParanoidDateTime
-  property 	 :id,         Serial
-  
-end

data/lib/sinatra/templates/datamapper/settings/datamapper.rb

@@ -1,16 +0,0 @@
-configure :development do
-  DataMapper::Logger.new $stdout, :debug
-  # DataMapper.setup :default, 'sqlite::memory:'
-  DataMapper.setup :default, "sqlite://#{Dir.pwd}/data/development.sqlite3"
-  # DataMapper.setup :default, 'mysql://username:password@host_url:3306/database_name'
-  # DataMapper.setup :default, 'postgres://username:password@host_url:5432/database_name'
-end
-
-configure :production do
-  # DataMapper::Logger.new $stdout, :debug
-  # DataMapper.setup :default, 'sqlite::memory:'
-  # DataMapper.setup :default, "sqlite://#{Dir.pwd}/data/production.sqlite3"
-  # DataMapper.setup :default, 'mysql://username:password@host_url:3306/database_name'
-  # DataMapper.setup :default, 'postgres://username:password@host_url:5432/database_name'
-  # DataMapper.setup(:default, ENV['DATABASE_URL'] || 'postgres://localhost/mydb')
-end

data/lib/sinatra/templates/datamapper/tests/models/datamapper_tests.rb

@@ -1,16 +0,0 @@
-require 'minitest/autorun'
-require 'rack/test'
-require './app'
-
-class <%= locals[:model].capitalize %>Tests < MiniTest::Unit::TestCase
-  include Rack::Test::Methods
-  
-  def app
-    Sinatra::Application
-  end
-  
-  # def test_made_by
-  #   <%= locals[:model] %> = <%= locals[:model].capitalize %>.new
-  #   assert_equal <%= locals[:model] %>.made_by, 'Acme Corp.'
-  # end
-end

data/lib/sinatra/templates/pony/settings/pony.rb

@@ -1,27 +0,0 @@
-Pony.options = {
-  via: :smtp,
-  via_options: {
-    address: '',
-    port: '',
-    domain: '',
-    user_name: '',
-    password: '',
-    authentication: :plain,
-    enable_starttls_auto: true
-  }
-}
-
-# Heroku example:
-
-# Pony.options = {
-#   via: :smtp,
-#   via_options: {
-#     address: 'smtp.sendgrid.net',
-#     port: '587',
-#     domain: 'heroku.com',
-#     user_name: ENV['SENDGRID_USERNAME'],
-#     password: ENV['SENDGRID_PASSWORD'],
-#     authentication: :plain,
-#     enable_starttls_auto: true
-#   }
-# }