pretzel 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e05d6a69c72f4ba45c60b408450e799144a9e56e
-  data.tar.gz: ec51b8960b12bd6c0e4b8dc2d20057551089ef09
+  metadata.gz: eda1d2b5c8b88a860d1881278ca7782a5a739cb6
+  data.tar.gz: 1f23c29e34fbae8f463a528e4a311dcfadd8f0cb
 SHA512:
-  metadata.gz: a5efb05569eaa7bb78ac28685768106aa5e88280c8ad017ea49a06ea756c36119eed674390c096056abdf4a16ef9d1344be52c696ea4b005ffc5941cf29b0637
-  data.tar.gz: 533058ca02af687c4ddbe22e4464cec7a16ccb0d226e2730cc03e8a856a5929fbc7ccffc6c17ab0022944ba71fb4cdeca394cf5ca5d3c58195017eea147afa96
+  metadata.gz: db7f4114905d34429e9a41efb623963a71b915293baef73a3e866f6e4d5eb441e2bb8f5f4b7d1f2409ccde6fed9695d1fdc88e09d476fd10a0e05a7620ab15a2
+  data.tar.gz: 45fd5052b6c18e97ba811823afe2dbb9f086996fb01a6975786993a14ebf437dd87bd43b72167f1c409c87f93fe8b6a24c9d9165d05863eb1b3a1f24aaefb7db

data/README.md

@@ -1,7 +1,33 @@
+## The Pretzel suite
 
-# pretzel
-![TravisCI badge](https://travis-ci.org/pretzelhands/pretzel.svg?branch=master)
-![Version badge](https://badge.fury.io/rb/pretzel.svg)
+[![TravisCI badge](https://travis-ci.org/pretzelhands/pretzel.svg?branch=master)](https://travis-ci.org/pretzelhands/pretzel)
+[![Version badge](https://badge.fury.io/rb/pretzel.svg)](https://badge.fury.io/rb/pretzel)
 [![Code Climate](https://codeclimate.com/github/pretzelhands/pretzel/badges/gpa.svg)](https://codeclimate.com/github/pretzelhands/pretzel)
 
-ReadMe coming soon.
+---
+
+Welcome to the canonical repo of the Pretzel suite, a tiny web framework inspired by the ideas of Sinatra and Nancy. This framework has some strong opinions on how to structure an application and thus may not be suited for everyone. 
+
+If you like convention-over-configuration and building web applications from small building blocks along the lines of the UNIX philosophy, you have come to the right place. 
+
+### Philosophy
+
+The Pretzel suite is built upon the UNIX philosopy. A piece of software should do one thing and do it well. The Pretzel core itself is a tiny 144 lines in 3 modules. It basically only provides routing, filters and it exposes some Rack middleware.
+
+After that everything is an extension. Even the templating and the status/redirect/session methods. The goal is to create a framework which you can take and stick together the way you need it.
+
+### Documentation
+
+The documentation is available in the `docs` folder. It is sorted by a xx-yy-name pattern, where xx is a major and yy a minor chapter. The documentation takes the approach to teach by example, thus you will get lots of code snippets to visualize how things work.
+
+### Bug reports
+
+If you found a bug, feel free to send it in via the issue tracker on the right side. Or, if you know some code, maybe write a patch for it yourself! I usually lint my code with `ruby -wc`, and I'd ask you to do the same. Also don't forget to *write and run* tests. Otherwise I may go on neverending rants and we both don't want that.
+
+### Who's responsible for this and why?
+
+The dude behind all of this is me, [Richard Blechinger.](http://twitter.com/F0lis) On the internet I'm more commonly known by nicknames "Folis" and "Pretzelhands" (See where the framework name comes from?). I'm a web developer who tries to learn as many things as humanly possible. This is why the Pretzel suite exists, too. It started as endeavour to look at Rack and how it works.
+
+### Licensing
+
+MIT everytime all the time. Go ahead and do what you want.

data/docs/01-00-application.md

@@ -0,0 +1,106 @@
+# Basic Pretzel Application
+
+The Pretzel suite comes with a very small core consisting of about 144 lines split
+into 3 modules: Core, Routing::Evaluation and Routing::Methods. Every Pretzel application
+also automatically includes the Extension::Convenience module which provides some
+neat wrappers around common functionality.
+
+## Directory structure
+
+Before we get down and dirty with the code, let's talk management. The Pretzel suite
+has strong opinions on where things should go. The basic folder structure for a Pretzel
+application looks like this:
+
+```
+  my_app
+  |
+  |- config.ru
+  |- application.rb
+  |- assets
+  |- views
+      |- includes
+
+```
+
+`config.ru` is your rackup file. You can read more about that down below. The `application.rb`
+file can be named whatever you want, and it should contain the class declaration
+your application.
+
+The `assets` directory is a folder for your static content. CSS/JS, images, etc.
+Everything is mapped 1-to-1 in the URL scheme, so if you put a file under `/assets/css/style.css`
+you will find it under `/assets/css/style.css` when the application is running.
+
+The `views` folder is where your `liquid` templates go. (See 03-00-templating for more
+information). The `includes` folder inside contains the `liquid` partials. 
+
+**NOTE:** These settings are fixed and may not be changed at runtime. Convention over
+configuration takes effect here.
+
+## Creating an application
+
+A basic Pretzel application consists of a class inheriting from the Pretzel::Core
+class. It looks like this:
+
+```ruby
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+  end
+```
+
+This gives you the following functionality:
+
+  * Routing with 6 methods (`GET, POST, PUT, DELETE, OPTIONS, HEAD`)
+  * Before and after filters
+  * Access to a `Rack::Response` and `Rack::Request` module
+  * Ability to include Rack middleware with the `use` function
+  * A fully setup session hash, which can be accessed with `session`
+  * Wrapper functions for setting the response status and redirecting
+
+## Running your application
+
+For running your application you have two options: Run it from the file directly
+or run it with `rackup`. The Pretzel suite comes with Thin as web server, so you're
+good to go.
+
+### Running the application directly
+
+To run your application directly, you need to call one of the Rack handlers like this:
+
+```ruby
+  require "rack"
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+  end
+
+  Rack::Handler::Thin.run Application.new
+```
+
+Then you can just run the following command from the terminal: `$ ruby application.rb`
+and your application should be up and running!
+
+### Running the application via rackup
+
+Running your application via `rackup` is a lot more flexible and is the recommended
+way to get your things online. First setup your application in a file `application.rb`.
+
+```ruby
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+  end
+```
+
+Then create a new file called `config.ru`, require your application and call the
+`run` function. It looks like this:
+
+```ruby
+  require_relative "application"
+  run Application.new
+```
+
+Finally execute this command in the directory of your `config.ru`: `$ rackup -o "0.0.0.0" -p PORT`
+
+The port is freely configurable, but don't forget the `-o "0.0.0.0"` part as to listen
+on all available interfaces.

data/docs/01-01-routing.md

@@ -0,0 +1,67 @@
+## Routing
+
+Routing with the Pretzel suite is very close to Sinatra, with one exception:
+The recommendation is not to do your routing in the class declaration, but outside of it.
+
+It looks like this:
+
+```ruby
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+  end
+
+  Application.get "/" do
+    "Hello, World"
+  end
+```
+
+This has the advantage, that you can split your routes into seperate files to keep
+your application maintainable.
+
+All routes are matched in order from first-declared to last-declared
+
+### Routing methods and blocks
+
+There are 6 routing methods available to every Pretzel applications. They are as
+follows: `get, post, put, delete, options, head`. Usually, if you're not deep down
+into the HTTP spec, you will probably only need the first four.
+
+Each routing method takes a route and a block as arguments. Routes can be declared
+and visited with or without a trailing slash. The suite makes no differentiation
+here for simplicity purposes.[1]
+
+```ruby
+  Application.get "/test" do
+    # Do stuff
+  end
+```
+
+### Block variables
+
+Within blocks you have access to various variables that allow you
+to easily modify and manipulate the data flowing around. The following objects
+are available:
+
+  * request - A Rack::Request
+  * response - A Rack::Response
+  * parameters - A Hash containing the GET, POST and URL parameters of this route.
+
+This follows the approach of not hiding anything from you and giving you full access
+
+### Named parameters
+
+Each route can have named parameters in the URL, by prefixing the part with a
+colon like this: `/hello/:name`. These parameters will be added to your parameters
+hash in the route block
+
+```ruby
+  # Assume we access /hello/world in our browser
+  Application.get "/hello/:name" do
+    "Hello, #{parameters['name']}!" # => "Hello, world!"
+  end
+```
+
+----
+
+[1] This actually made the route parsing regex more complicated, but whatever.

data/docs/01-02-filters.md

@@ -0,0 +1,25 @@
+## Filters
+
+Filters are functions that can handle things for you whenever a route is called
+The Pretzel suite has two seperate filters: `before` and `after`.
+
+They are declared very similar to routes:
+
+```ruby
+  Application.before do
+    # Do this before every route
+  end
+
+  Application.after do
+    # Do this after every route
+  end
+```
+
+Those filters are executed before and after each call to a route. In the
+function blocks you have access to two objects:
+
+  * response - A Rack::Response
+  * request - A Rack::Request
+
+Thus these filters can be used to modify headers, request data and such as you
+see fit. Quite handy!

data/docs/01-04-mapping.md

@@ -0,0 +1,36 @@
+## Mapping
+
+Mapping is one of the most awesome features of Rack applications.
+It allows you to put together a bunch of seperate applications into a single one,
+thus allowing you to create service architectures.
+
+Let's see how it works:
+
+```ruby
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+  end
+
+  class SubApplication < Pretzel::Core
+  end
+
+  SubApplication.get "/test" do
+    "Hello, SubApplication"
+  end
+
+  Application.get "/" do
+    "Hello, MainApplication"
+  end
+
+  Application.map "/sub" do
+    run SubApplication.new
+  end
+```
+
+Now in this setup whenever you access a route that's on the `/sub` route, you will
+get forwarded to the routes of the `SupApplication`. 
+
+Thus when you access `/sub/test` you will get the response `Hello, SubApplication`
+If you use this efficiently you can build an application on the so-called service
+architecture, which is pretty neat!

data/docs/02-00-conveniece-methods.md

@@ -0,0 +1,45 @@
+## Convenience methods
+
+The Pretzel suite comes with a set of three convenience methods. These are not part of
+the Core framework, but are still included with every Pretzel project via the ways
+of Pretzel::Core.
+
+The convenience methods are defined in `Pretzel::Extension::Convenience` and the following
+are available:
+
+* redirect
+* session
+* status
+
+**NOTE:** All convenience functions are only available in the *route blocks.*
+
+### redirect(url)
+
+The `redirect` function allows you to easily execute a HTTP redirect to another URL
+of your application. It only takes a single argument and is called like this:
+
+```ruby
+	redirect "/redirect-page"
+```
+
+### session
+
+The `session` method is probably the most useful of the convenience functions. It
+does what it says on the tin: Handle a session. It's already all setup with signed
+cookies by the Pretzel::Core, so you can use it right away. It can be interacted
+with as a regular Hash. It's just a thin wrapper around `request.session`.
+
+```ruby
+	session[:my_var] = "Hello, World" # Set a session variable
+	session[:my_var] 									# => "Hello, World"
+```
+
+### status(status)
+
+`status` is a simple wrapper around response.status that allows you to set the HTTP
+status of your response. This is usually done with APIs to indicate various success
+and error states. `status` takes a single argument
+
+```ruby
+	status 201 # Set the status to "Resource created"
+```

data/docs/02-01-json.md

@@ -0,0 +1,35 @@
+## JSON
+
+The Pretzel suite comes with a predelivered JSON extension (`Pretzel::Extension::JSON`)
+that helps you easily send JSON responses for an API or something similar. It is a non-core
+extension and you have to manually add it to your application.
+
+You can include it like this:
+
+```ruby
+	require "pretzel/core"
+	require "pretzel/ext/json"
+
+	class Application < Pretzel::Core
+		extends Pretzel::Extension::JSON
+	end
+```
+
+And you're ready to go! The JSON module only provides a single method: `json`.
+You can call this method with two parameters: A Hash and a `status`.
+
+Only the hash is required. If you do not set a status, the response will just return
+the status `200 OK`.
+
+Calling it looks like this:
+
+```ruby
+	Application.get "/json" do
+		json({
+			:hello => "world"
+		}, 201)
+	end
+```
+
+This sets the response status to 201, the content type to "application/json" and
+converts the Hash to JSON according to the specification.

data/docs/03-00-templating.md

@@ -0,0 +1,123 @@
+## Templating
+
+Another pre-delivered feature of the Pretzel suite is templating. This is done
+with the excellent [Liquid templating language.](https://github.com/shopify/liquid)
+
+The purpose of this document is to show how to use the Pretzel suite with Liquid,
+not to explain the templating language itself. For that, visit the link above and
+look through the wiki to get a basic grasp.
+
+Pretzel projects once again take a convention-over-configuration approach to templating.
+All your templates must be stored in a `views` that resides next to your application file.
+
+Inside the view folder you have free reign as to how to structure your templates with
+one notable exceptions: *Liquid partials go in the `views/includes` folder*. As a fair
+hint: Remember that all partials need to be named with an underscore in front. This
+has caused me some headaches before.
+
+Now for the folder structure:
+
+```
+  app
+   |
+   |- application.rb
+   |- config.ru
+   |- views
+        |- includes
+          |- _partial.liquid
+        |- your_template.liquid
+```
+
+### Preparing your application
+
+The code side of things is even simpler. The templating functionality is provided
+in an extension: `Pretzel::Extension::Templating`. As with other extensions you have
+to include it before using it, like so:
+
+```ruby
+  require "pretzel/core"
+  require "pretzel/ext/templating"
+
+  class Application < Pretzel::Core
+    extends Pretzel::Extension::Templating
+  end
+```
+
+### Using basic templates
+
+The extension exposes a single function: `render`, which is used like this:
+
+```ruby
+  Application.get "/" do
+    render :index
+  end
+```
+
+The template name is passed as first argument. It can be either a symbol or a string.
+It *must* not contain the file extension and is always rooted in the views folder.
+
+Here are some more examples
+
+```ruby
+  render :index # => views/index.liquid
+  render "subfolder/my_template" # => views/subfolder/my_template.liquid
+  render :"subfolder/other_template" # => views/subfolder/other_template.liquid
+```
+
+### Templates and locals
+
+Most templates aren't satisfied with simple rendering, and usually you want to pass
+a bunch of variables (so called `locals`) in. The render function has that covered:
+
+```ruby
+  Application.get "/" do
+    render :index, {
+      "name" => "Richard"
+    }
+  end
+```
+
+The locals are always passed in as a simple Ruby Hash. For more information on locals,
+see the Liquid documentation!
+
+### Layouts
+
+Many applications have some sort of HTML structure that they want to persist across
+various views. This is usually called a layout or a theme. The Pretzel suite has
+this integrated too. 
+
+Whenever you call `render` on a template, the framework will look for a file in your
+`views` folder called `layout.liquid`. This template exposes a special variable 
+called `template`. An example layout may look like this:
+
+```html
+  <!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <title>Document</title>
+    </head>
+    <body>
+      {{ template }}    
+    </body>
+  </html>
+```
+
+The part where you output template is, shockingly, the place where your template will
+appear. Cool, huh?
+
+#### Deactivating the layout
+
+If there is no `layout.liquid` file, the Pretzel suite will just not apply a layout.
+In case you have created a layout but you want to deactivate it for a certain route,
+you just need to pass `"layout" => false` into the locals like so:
+
+```ruby
+  Application.get "/no-layout" do
+    render :some_template, {
+      "layout" => false
+    }
+  end
+```
+
+This will supress the layout rendering for this template.

data/docs/04-01-middleware.md

@@ -0,0 +1,17 @@
+## Rack middleware
+
+Since Pretzel applications are just Rack applications under the hood you
+can extend them with any type of Rack middleware. It's really easy, too.
+
+Here's how it is done:
+
+```ruby
+  require "pretzel/core"
+  require "rack/lobster" # The middleware
+
+  class Application < Pretzel::Core
+    use Rack::Lobster
+  end
+```
+
+And done.

data/docs/04-02-extensions.md

@@ -0,0 +1,117 @@
+## Pretzel extensions
+
+While Rack middleware is great for low-level extensions, sometimes you 
+may want to extend the Pretzel suite on a somewhat higher level.
+
+Maybe your extension requires some custom routes or you want to include
+some Liquid extensions? This is the reason for the `extends` method.
+
+It is used like this:
+
+```ruby
+  require "pretzel/core"
+
+  class Application < Pretzel::Core
+    extends Pretzel::Extension::Test
+  end
+```
+
+And you're good to go. 
+
+## Structure
+
+Each extension consists of two parts: `App` and `Route`.
+Both are submodules of your extension. The structure looks like this.
+
+```ruby
+  module Pretzel::Extension
+
+      module Test
+        module App
+          # Code-y awesomeness
+        end
+
+        module Route
+          # Code-y awesomeness
+        end
+      end
+
+  end
+```
+
+## Where to declare things
+
+The `App` and `Route` modules are rather aptly named. Any methods declared in
+the `App` module will be available in the class declaration like this:
+
+```ruby
+  class Application < Pretzel::Core
+    extends Your::Extension
+    your_method
+  end
+```
+
+On the other side, any methods declared in the `Route` module are available in
+the route controllers like this:
+
+```ruby
+  class Application < Pretzel::Core
+    extends Your::Extension
+  end
+
+  Application.get "/" do
+    your_extension
+  end
+```
+
+### Custom extension routes
+
+The `Route` module is also where you want to declare your custom routes.
+This can be done by using Ruby's `self.included` method to your advantage:
+
+```ruby
+  module Pretzel::Extension
+
+      module Test
+        module Route
+          
+          def self.included(application)
+            application.get "/ext/index" do
+              "Extensions!"
+            end
+          end
+
+        end
+      end
+
+  end
+```
+
+### Extending Liquid
+
+If you want to keep your application clean and modular, you can also use the
+`Route` module to extend Liquid. You can read all about [the subject matter here.](https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#extending-liquid)
+
+An example Liquid extension may look like this:
+
+```ruby
+  
+  module Pretzel::Extension
+
+      module Test
+        module Route
+          module TestFilter
+            def reverse(string)
+              string.reverse!
+            end
+          end
+          
+          Liquid::Template.register_filter(TestFilter)
+        end
+      end
+
+  end
+```
+
+It can then be included in your application with `extends` and you're ready
+to use the filter in your templates. (Of course you can also create blocks and tags.)

data/lib/pretzel/core.rb

@@ -3,17 +3,21 @@ require "forwardable"
 require "securerandom"
 
 require_relative "version"
+require_relative "extends"
+
 require_relative "ext/convenience"
 
 require_relative "routing/eval"
 require_relative "routing/methods"
 
+
 module Pretzel
   class Core
+    extend Pretzel::Extension
     include Pretzel::Routing::Evaluation
     extend Pretzel::Routing::Methods
 
-    include Pretzel::Extension::Convenience
+    extends Pretzel::Extension::Convenience
 
     attr_reader :request, :response, :parameters
 

data/lib/pretzel/ext/convenience.rb

@@ -2,16 +2,18 @@ module Pretzel
   module Extension
     module Convenience
 
-      def status(status)
-        response.status = status
-      end
+      module Route
+        def status(status)
+          response.status = status
+        end
 
-      def session
-        request.session || raise("Rack::Session not set.")
-      end
+        def session
+          request.session || raise("Rack::Session not set.")
+        end
 
-      def redirect(url)
-        response.redirect url
+        def redirect(url)
+          response.redirect url
+        end
       end
 
     end

data/lib/pretzel/ext/json.rb

@@ -4,11 +4,13 @@ module Pretzel
   module Extension
     module JSON
 
-      def json(hash, status=200)
-        response["Content-Type"] = "application/json"
-        response.status = status
+      module Route
+        def json(hash, status=200)
+          response["Content-Type"] = "application/json"
+          response.status = status
 
-        hash.to_json
+          hash.to_json
+        end
       end
 
     end

data/lib/pretzel/ext/templating.rb

@@ -3,29 +3,33 @@ require "liquid"
 module Pretzel
   module Extension
     module Templating
-      def self.included(_class)
-        Liquid::Template.file_system = Liquid::LocalFileSystem.new("#{Dir.pwd}/views/includes") 
-      end
 
-      def render(path, locals = {})
-        response["Content-Type"] = "text/html"
-        layout_file = File.expand_path("#{Dir.pwd}/views/layout.liquid")
-        raw_file = File.expand_path("#{Dir.pwd}/views/#{path.to_s}.liquid")
-        
-        template = Liquid::Template.parse(File.read(raw_file))
+      module Route
+        def self.included(_class)
+          Liquid::Template.file_system = Liquid::LocalFileSystem.new("#{Dir.pwd}/views/includes") 
+        end
+
+        def render(path, locals = {})
+          response["Content-Type"] = "text/html"
+          layout_file = File.expand_path("#{Dir.pwd}/views/layout.liquid")
+          raw_file = File.expand_path("#{Dir.pwd}/views/#{path.to_s}.liquid")
+          
+          template = Liquid::Template.parse(File.read(raw_file))
 
-        if File.exist?(layout_file)
-          # Always render the layout, unless explicitly told otherwise.
-          unless locals["layout"] == false
-            layout = Liquid::Template.parse(File.read(layout_file))
-            layout.render({ "template" => template.render(locals) })
+          if File.exist?(layout_file)
+            # Always render the layout, unless explicitly told otherwise.
+            unless locals["layout"] == false
+              layout = Liquid::Template.parse(File.read(layout_file))
+              layout.render({ "template" => template.render(locals) })
+            else
+              template.render(locals)
+            end
           else
             template.render(locals)
           end
-        else
-          template.render(locals)
         end
       end
+
     end # end module
   end # end module
 end # end module

data/lib/pretzel/extends.rb

@@ -0,0 +1,15 @@
+module Pretzel
+  module Extension
+
+    def extends(extension)
+      if extension.const_defined? :Route
+        include extension::Route
+      end
+
+      if extension.const_defined? :App
+        extend extension::App
+      end
+    end
+
+  end
+end

data/lib/pretzel/version.rb

@@ -1,3 +1,3 @@
 module Pretzel
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/test/scrap.rb

@@ -2,14 +2,16 @@
 # implemented. The code here is not intended to be sensible.
 
 require_relative "setup_environment"
+require_relative "scrap_extension"
 
 class ScrapApplication < Pretzel::Core
-  include Pretzel::Extension::Templating
-  include Pretzel::Extension::JSON
+  extends Pretzel::Extension::Templating
+  extends Pretzel::Extension::Scrap
 end
 
 ScrapApplication.get "/" do
-  json({ :hello => "world" }, 201)
+  some_class_stuff "classy test"
+  some_instance_stuff "Test!"
 end
 
 ScrapApplication.get "/yolo/" do

data/test/scrap_extension.rb

@@ -0,0 +1,39 @@
+
+
+module Pretzel
+  module Extension
+
+    class Scrap
+      module Instance
+        def some_instance_stuff(text)
+          p text
+        end
+      end
+
+      module App
+        def some_class_stuff(text)
+          p "CLASS: #{text}"
+        end
+      end
+
+      module Routes
+        def self.included(app)
+          app.get "/ext/test" do
+            render :index
+          end
+        end
+      end
+
+      module Templates
+        module TestFilter
+          def tester(input)
+            input.reverse!
+          end
+        end
+
+        Liquid::Template.register_filter(TestFilter)
+      end
+    end
+
+  end
+end

data/test/test_extension.rb

@@ -0,0 +1,61 @@
+require_relative "setup_environment"
+
+module Pretzel
+  module Extension
+    class Test
+      module Instance
+
+      end
+
+      module App
+        def class_method
+          "Class method"
+        end
+      end
+
+      module Route
+        def instance_method
+          "Instance method"
+        end        
+
+        def self.included(app)
+          app.get "/ext/index" do
+            render :index
+          end
+
+          app.get "/ext/instance" do
+            instance_method
+          end
+        end
+      end
+
+    end
+  end
+end
+
+class ExtensionApplication < Pretzel::Core
+  extends Pretzel::Extension::Templating
+  extends Pretzel::Extension::Test
+end
+
+class TestExtension < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    ExtensionApplication.new
+  end
+
+  def test_extension_route
+    get "/ext/index"
+    assert last_response.body.include? "Hello, World!"
+  end
+
+  def test_extension_classmethod  
+    assert_equal ExtensionApplication.class_method, "Class method"
+  end
+
+  def test_extension_instancemethod  
+    get "/ext/instance"
+    assert_equal last_response.body, "Instance method"
+  end  
+end

data/test/test_json.rb

@@ -2,7 +2,7 @@ require_relative "setup_environment"
 require "rack"
 
 class JSONApplication < Pretzel::Core 
-  include Pretzel::Extension::JSON
+  extends Pretzel::Extension::JSON
 end
 
 JSONApplication.get "/" do

data/test/test_templating.rb

@@ -2,7 +2,7 @@ require_relative "setup_environment"
 require "rack"
 
 class TemplatingApplication < Pretzel::Core 
-  include Pretzel::Extension::Templating
+  extends Pretzel::Extension::Templating
 end
 
 TemplatingApplication.get "/" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pretzel
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Richard Blechinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-01 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -94,18 +94,30 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/01-00-application.md
+- docs/01-01-routing.md
+- docs/01-02-filters.md
+- docs/01-04-mapping.md
+- docs/02-00-conveniece-methods.md
+- docs/02-01-json.md
+- docs/03-00-templating.md
+- docs/04-01-middleware.md
+- docs/04-02-extensions.md
 - lib/pretzel/core.rb
 - lib/pretzel/ext/convenience.rb
 - lib/pretzel/ext/json.rb
 - lib/pretzel/ext/templating.rb
+- lib/pretzel/extends.rb
 - lib/pretzel/routing/eval.rb
 - lib/pretzel/routing/methods.rb
 - lib/pretzel/version.rb
 - pretzel.gemspec
 - test/assets/test.css
 - test/scrap.rb
+- test/scrap_extension.rb
 - test/setup_environment.rb
 - test/test_convenience.rb
+- test/test_extension.rb
 - test/test_filters.rb
 - test/test_json.rb
 - test/test_map.rb
@@ -145,8 +157,10 @@ summary: The Pretzel web application core
 test_files:
 - test/assets/test.css
 - test/scrap.rb
+- test/scrap_extension.rb
 - test/setup_environment.rb
 - test/test_convenience.rb
+- test/test_extension.rb
 - test/test_filters.rb
 - test/test_json.rb
 - test/test_map.rb