Merge branch 'master' of https://github.com/sinatra/sinatra-recipes

Author: Seiichi Yonezawa

README.md

@@ -1,5 +1,4 @@
-Sinatra Recipes 
----------------
+# Sinatra Recipes
 
 Community contributed recipes and techniques for the [Sinatra Web
 Framework][sinatra].
@@ -18,7 +17,7 @@ the first place you should go if you're looking to contribute.
 
 Once you have [forked the project][github-forking] send a [pull
 request][github-pull-requests], just be sure to follow the [styling
-guidelines][style-guidelines]. 
+guidelines][style-guidelines].
 
 You can also get a hold of us on [irc][irc] or the [mailinglist][mailinglist].
 
@@ -86,5 +85,3 @@ wiki][translations].
 [mailinglist]: http://groups.google.com/group/sinatrarb
 [github-forking]: http://help.github.com/forking/
 [github-pull-requests]: http://help.github.com/pull-requests/
-
-

app.rb

@@ -270,6 +270,9 @@ def get_activity_by_author
 
 @import 'public/stylesheets/gridset.scss'
 
+html
+  background-color: white
+
 body
   font-family: 'Lucida Grande', Verdana, sans-serif
   font-size: 14px

asset_management/README.md

@@ -1,9 +1,8 @@
 # Asset Management
 
-There are quite a few reasons why a production app should have proper 
+There are quite a few reasons why a production app should have proper
 asset management (CSS, JS, Image files). To get an overview of what asset-
-management means or why it is required, a section "Why asset management" is 
+management means or why it is required, a section "Why asset management" is
 added to this topic below.
 
 __Ruby-based Assetmangement gems:__
-

asset_management/sinatra_assetpack.md

@@ -1,4 +1,4 @@
-## Sinatra-Assetpack
+# Sinatra-Assetpack
 
 Install the gem using:
 
@@ -22,18 +22,17 @@ class App < Sinatra::Base
 end
 ```
 
-
-### Generic Structure
+## Generic Structure
 
 __Defaults__
 
-If you do not use any CSS dev tools such as Compass or Foundation, and have a 
-simple app structure that you generate on a per-project basis, there are 
-certain defaults added to `Sinatra::Assetpack`. By default, the gem assumes 
-your asset files are located under a folder called "app" in your app's root 
+If you do not use any CSS dev tools such as Compass or Foundation, and have a
+simple app structure that you generate on a per-project basis, there are
+certain defaults added to `Sinatra::Assetpack`. By default, the gem assumes
+your asset files are located under a folder called "app" in your app's root
 directory.
 
-This is the default structure which when used, makes it possible to use the 
+This is the default structure which when used, makes it possible to use the
 gem with almost zero configuration.
 
 ```
@@ -51,12 +50,12 @@ myapp.rb
 
 Some points of note:
 
-* There is no need to stick to this structure. The filepaths can be 
-configured in `sinatra-assetpack` in case you need it. 
-* There is no need for the `public` folder which is the default asset 
+* There is no need to stick to this structure. The filepaths can be
+configured in `sinatra-assetpack` in case you need it.
+* There is no need for the `public` folder which is the default asset
 look-up path for Sinatra.
-* The `.sass` files go into the `css` directory. The conversion will be 
-handled by `sinatra-assetpack` automatically. You just need the `sass` gem 
+* The `.sass` files go into the `css` directory. The conversion will be
+handled by `sinatra-assetpack` automatically. You just need the `sass` gem
 installed and loaded using `require 'sass'`.
 
 Inside the `myapp.rb` file, inside the `assets do .. end` block,
@@ -84,7 +83,7 @@ assets do
 end
 ```
 
-The symbol that is sent to the `js` and `css` methods becomes the access 
+The symbol that is sent to the `js` and `css` methods becomes the access
 helper in your views. You can use those helpers like so:
 
 ```ruby
@@ -100,7 +99,7 @@ Which gets expanded to:
 
 That is it!
 
-### Custom structure
+## Custom structure
 
 __Level 2__
 
@@ -119,7 +118,7 @@ assets
 myapp.rb
 ```
 
-The `serve` method can be specified so that the folder from which the 
+The `serve` method can be specified so that the folder from which the
 assets gets served from may be explained to the gem.
 
 ```ruby
@@ -131,39 +130,39 @@ assets gets served from may be explained to the gem.
       '/js/app.js'
       # You can also do this: 'js/*.js'
     ]
-    
+
     serve '/css', :from => 'assets/stylesheets'
     css :application, [
       '/css/jqueryui.css',
       '/css/reset.css',
       '/css/foundation.sass',
       '/css/app.sass'
      ]
-    
+
     js_compression :jsmin
     css_compression :sass
   end
 ```
 
 And everything else remains the same.
 
-### Foundation framework + Compass
+## Foundation framework + Compass
 
 __Level Awesome__
 
-The previous sections dealt with limited number of assets. What if 
+The previous sections dealt with limited number of assets. What if
 you have vendor assets that need to be served in a particular order?
 
-This section deals with using the foundation framework with 
-`sinatra-assetpack`. The example also uses the `compass` gem to start a 
-project with the `zurb-foundation` framework. 
+This section deals with using the foundation framework with
+`sinatra-assetpack`. The example also uses the `compass` gem to start a
+project with the `zurb-foundation` framework.
 
 ```
 gem install zurb-foundation
 gem install compass
 ```
 
-Complete instructions are not provided here. Follow the Zurb-foundation 
+Complete instructions are not provided here. Follow the Zurb-foundation
 link provided in the links section for detailed instructions
 
 The created project has a structure like this:
@@ -200,16 +199,16 @@ The created project has a structure like this:
 myapp.rb
 ```
 
-In this app, the `.sass` to `.css` conversion is handled by running 
-`compass watch` which compiles the `.scss` files whenever it detects a 
-change. So, we'll ignore the conversion for now. The concentration would 
+In this app, the `.sass` to `.css` conversion is handled by running
+`compass watch` which compiles the `.scss` files whenever it detects a
+change. So, we'll ignore the conversion for now. The concentration would
 be on how to configure the app to get the files in a particular order.
 
 In this case, the order of the JS files that need to be loaded/merged is:
 
 1. Vendor JS files like jQuery, Modernizr and Zepto.
 
-2. The "foundation.js" file which defines the `Foundation` prototype that 
+2. The "foundation.js" file which defines the `Foundation` prototype that
 gets used in the rest of the `foundation.*.js` files.
 
 3. The `foundation.*.js` files.
@@ -229,13 +228,13 @@ assets do
     '/js/vendor/*.js',
     '/js/app.js'
   ]
-  
+
   serve '/css', :from => 'stylesheets'
   css :application, [
     '/css/normalize.css',
     '/css/app.css'
    ]
-  
+
   js_compression :jsmin
   css_compression :sass
 end
@@ -249,27 +248,27 @@ Inside the view:
 <%= js :foundation %>
 ```
 
-Do this, and you'll see that the files are loaded properly and there will be 
+Do this, and you'll see that the files are loaded properly and there will be
 no JS errors in the browser's console.
 
-### Merging
+## Merging
 
-If you have tried the code samples, you might've observed that the files are 
-not getting merged before they are sent to the browser. This is true and 
+If you have tried the code samples, you might've observed that the files are
+not getting merged before they are sent to the browser. This is true and
 happens only in development mode. Change it to production:
 
 ```
 export RACK_ENV="production"
 ```
 
-Voila! Now you should see only three asset files being loaded viz., 
+Voila! Now you should see only three asset files being loaded viz.,
 "application.css", "application.js" and "foundation.js".
 
-### Pre-compilation
+## Pre-compilation
 
-Up until now, the concatenation, compression are done after a request 
-reaches the server for the first time. This step is done only once for the 
-first request. However, if you need to pre-generate the compressed and 
+Up until now, the concatenation, compression are done after a request
+reaches the server for the first time. This step is done only once for the
+first request. However, if you need to pre-generate the compressed and
 concatenated assets, you can use the rake task provided in the gem:
 
 Create a `Rakefile` in your app directory with the following contents:
@@ -281,12 +280,11 @@ APP_CLASS = 'Sinatra::Application'
 require 'sinatra/assetpack/rake'
 ```
 
-And run `rake assetpack:build` to generate the assets which automatically 
-get stored in a `public` directory. 
+And run `rake assetpack:build` to generate the assets which automatically
+get stored in a `public` directory.
 
-### Resources
+## Resources
 
 * [Sinatra-Assetpack](https://github.com/rstacruz/sinatra-assetpack)
 * [Foundation Framework](http://foundation.zurb.com/docs/index.html)
 * [Compass Framework](http://compass-style.org/)
-

asset_management/why-asset-management.md

@@ -1,41 +1,37 @@
-## Why Asset Management
+# Why Asset Management
 
-
-A typical app ends up with many `.css` and `.js` (or `.coffee` for 
-that matter) especially if you use a lot of external plugins such as 
+A typical app ends up with many `.css` and `.js` (or `.coffee` for
+that matter) especially if you use a lot of external plugins such as
 the Compass framework or say, Ember.js
 
-Serving uncompressed/minified assets is not advisable and that is one 
-of the reason why some of the popular libraries like jQuery and Ember 
+Serving uncompressed/minified assets is not advisable and that is one
+of the reason why some of the popular libraries like jQuery and Ember
 provide a minified version of the library out of the box.
 
-Even if you have a minifed version of those vendor plugins, if you opt to 
-follow best practices and write your `.css`|`.sass` and `.js`|`.coffee` 
-code in a modular fashion, you'll end up with a bunch of those files that 
+Even if you have a minifed version of those vendor plugins, if you opt to
+follow best practices and write your `.css`|`.sass` and `.js`|`.coffee`
+code in a modular fashion, you'll end up with a bunch of those files that
 need to be served to the end-user.
 
-To optimize and better manage your workflow involving your app's assets, 
-there are quite a few tools available. Some of the tools are available as 
+To optimize and better manage your workflow involving your app's assets,
+there are quite a few tools available. Some of the tools are available as
 gems and some are available as GUI applications.
 
-
-
 In general, these tools do the following:
 
 * Compile (If they are written in, say, Sass or Coffeescript)
-* Concatenate 
+* Concatenate
 * Compress
 * Cache busting
 
-
-### Compile
+## Compile
 
 As the name suggests, this step coverts the markup scripts to plain old `css`
 or `js` (from `sass`, `coffeescript`)
 
-### Concatenate
+## Concatenate
 
-Multiple files may be concatenated into a single file and so, instead of 
+Multiple files may be concatenated into a single file and so, instead of
 having:
 
 ```html
@@ -54,35 +50,34 @@ you'll end up with:
 <script type="text/javascript" src="application.js"></script>
 ```
 
-### Compress
+## Compress
 
-The compress step involves minifying the Javascript files (and CSS files) 
-by removing extra whitespaces which add to the file size and replacing 
-long variable names with shorter ones inside function bodies. Note that 
-it won't change the API – only internal variables will be changed. This 
+The compress step involves minifying the Javascript files (and CSS files)
+by removing extra whitespaces which add to the file size and replacing
+long variable names with shorter ones inside function bodies. Note that
+it won't change the API – only internal variables will be changed. This
 step reduces the sizes of JS and CSS files by a large extent.
 
-### Cache busting
+## Cache busting
 
-Browser-caching can be used to ensure the files won't be downloaded from 
-the server for every request. Many browsers check for the availability of 
-the static files in the local cache before making a request to the 
-server. 
+Browser-caching can be used to ensure the files won't be downloaded from
+the server for every request. Many browsers check for the availability of
+the static files in the local cache before making a request to the
+server.
 
-Cache busting is a procedure where the assets are numbered with a unique 
-number that lets the browser download the latest version of the assets. 
-For example, assume that the name of the compressed javscript file as 
-"app.js" for a version of your production app that was pushed yesterday. 
-If you enabled caching by sending  a `Cache-Control:public`, the "app.js" 
+Cache busting is a procedure where the assets are numbered with a unique
+number that lets the browser download the latest version of the assets.
+For example, assume that the name of the compressed javscript file as
+"app.js" for a version of your production app that was pushed yesterday.
+If you enabled caching by sending  a `Cache-Control:public`, the "app.js"
 gets stored in the browser cache.
 
-Now, if you've changed the "app.js" file today and pushed the new change 
-to the server, the browser may still load the cached "app.js" and not 
+Now, if you've changed the "app.js" file today and pushed the new change
+to the server, the browser may still load the cached "app.js" and not
 the new one.
 
-This problem may be avoided by having a unique number added to the end 
+This problem may be avoided by having a unique number added to the end
 of the filename which is changed once for every compilation-concatenation-
-compress step. This ensures that the browser knows the version of the file 
-stored in the cache and the version that is in the server. If there is a 
-difference between these two, only then the newer asset will be downloaded. 
-
+compress step. This ensures that the browser knows the version of the file
+stored in the cache and the version that is in the server. If there is a
+difference between these two, only then the newer asset will be downloaded.

databases/README.md

@@ -1,5 +1,4 @@
-Databases
----------
+# Databases
 
 Often times, applications need to talk to some external datasource. This
 section will cover recipes for integrating different types of databases