atd 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4b052a0c402077fa55a5c00e96db96c1963430a
-  data.tar.gz: 487ab2f6ce28280effbf0a1faff0d9b9959cd389
+  metadata.gz: ba460feaa80c9fb85ebab903d9e62e0300e579cd
+  data.tar.gz: 2c917612c41a5642f8115a1fd76e01e4a4471c11
 SHA512:
-  metadata.gz: db837886aa4f434403f51f8f1d6cf796c6cfd0cc1e4ef095c336b967a0c5d22dc15f6d93e20afe7e3f8f897da6f7659d0e13be366a5fb4b73730c886f4996640
-  data.tar.gz: 4075dd51b6e64f6977c13b6d6d684ab66c5abca0c992b5efa0752c07b251835bd78e13984716c1fb7c3b1dbfee7cd90a04b851813da7b291a4b1fb53e222e7be
+  metadata.gz: 762ce1b5272cac9f2f643fc98a69f97b084f19aac2c971a247a09e8dd704d7359ea383a740aa89f7b4d0ee7ad17183cb8c77e4ebffa2cb605cf2063d2e464be1
+  data.tar.gz: d223ee6e845e202f03f04f04a36518ddc184a79fe8fa7b8d92ab476b62ef95c6b81123664e8d80401cee5b87c4675e38b9f6c9429044e70a988359b1b9fbe087

data/.gitignore

@@ -1,14 +1,14 @@
 /.bundle/
 /.yardoc
 /Gemfile.lock
-/_yardoc/
 /doc/
 /pkg/
 /spec/reports/
-/tmp/
+tmp
 .DS_Store
 .idea
 coverage
 /*.gem
 /updated_README.md
-.dev-rubocop.yml
+.dev-rubocop.yml
+.ruby-version

data/.gitlab-ci.yml

@@ -1,12 +1,63 @@
-image: ruby:2.3.1
+image: ruby:2.4.0
 
 before_script:
   - ruby -v
   - which ruby
+  - gem environment
+  - gem install rubygems-update
+  - gem install rubygems-update --version 2.6.3
+  - gem update --system 2.6.10
   - gem install bundler --no-ri --no-rdoc
+  - gem environment
   - bundle install --jobs $(nproc)  "${FLAGS[@]}"
 
-test:
+test-2.4.0:
+  image: ruby:2.4.0
+  script:
+    - bundle exec rake test
+
+test-2.3.3:
+  image: ruby:2.3.3
+  script:
+    - bundle exec rake test
+
+test-2.3.2:
+  image: ruby:2.3.2
+  script:
+    - bundle exec rake test
+
+test-2.3.1:
+  image: ruby:2.3.1
+  script:
+    - bundle exec rake test
+
+test-2.3.0:
+  image: ruby:2.3.0
+  script:
+    - bundle exec rake test
+
+test-2.2.6:
+  image: ruby:2.2.6
+  script:
+    - bundle exec rake test
+
+test-2.2.5:
+  image: ruby:2.2.5
+  script:
+    - bundle exec rake test
+
+test-2.2.4:
+  image: ruby:2.2.4
+  script:
+    - bundle exec rake test
+
+test-2.2.3:
+  image: ruby:2.2.3
+  script:
+    - bundle exec rake test
+
+test-2.2.2:
+  image: ruby:2.2.2
   script:
     - bundle exec rake test
 

data/.rubocop.yml

@@ -14,14 +14,11 @@ Style/ParallelAssignment:
 Style/Documentation:
   Enabled: false
 
-Style/ModuleFunction:
-  Enabled: false
-
 Style/ClassAndModuleChildren:
   Enabled: false
 
 Metrics:
   Enabled: false
 
-Lint/UnifiedInteger:
+Style/FrozenStringLiteralComment:
   Enabled: false

data/CHANGELOG

@@ -1,4 +1,10 @@
 Current Repo Version:
+    - Cleaned up code for some built-in class modifications, replacing them with more limited in scope refinements. (#30)
+    - Allowed greater flexibility in compilation and precomilation by passing those methods the settings hash passed during route creation. (#27)
+    - Upgraded to comply with 2.4.0 by testing for Integer instead of Fixnum. To preserve backwards compatibility, we made different behaviors for older ruby versions. (#24)
+    - Completely rewrote README to be much easier to read and more informative. (#23)
+    - Added sinatra-esque helper methods instead of a ugly @http instance variable. (#18)
+    - Fixed some issues with request in main (DefaultApp). (#31, #32)
 
 v0.4.0
     - Fixed an issue where routes without blocks wouldn't return status codes (#9)

data/Guardfile

@@ -0,0 +1,28 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end

data/README.md

@@ -13,160 +13,123 @@
 [gem version link]: https://rubygems.org/gems/atd
 
 
-[ATD](#atd)
-- [Installation](#installation)
-- [Usage](#usage)
-    - [Setup](#setup)
-- [Routing](#routing)
-    - [Basic Routing](#basic-routing)
-	    - [Options Hash](#options-hash)
-        - [Serving Files](#serving-files)
-    - [Advanced Routing](#advanced-routing)
-        - [DefaultApp](#defaultapp)
-        - [Inheritance](#inheritance)
-        - [Blocks](#blocks)
-            - [@http](#http)
-        - [Controllers](#controllers)
-    - [Apps](#apps)
-        - [App Creation](#app-creation)
-        - [Starting the App](#starting-the-app)
-        - [App Routing](#app-routing)
-    - [Logging](#logging)
-    - [Compilation](#compilation)
-- [Design Paradigms](#design-paradigms)
-- [Documentation](#documentation)
-- [Development](#development)
-- [Contributing](#contributing)
-
-
 # ATD
 
-ATD is a new web development backend framework for Ruby. It is built on top of rack, and is meant to be small easy and light. That is why it provides a very minimalist way of writing your backend. It treats a request as a request, without splitting it based on the HTTP method. 
-
-## Installation
+Hello! I assume if you're reading this you really want to know about this really cool, interesting new framework that I made. Well, in that case you've come to the right place. ATD is a small modular framework meant to combine the benefits from [rails](http://rubyonrails.org/) and [sinatra](http://www.sinatrarb.com/). I originally used sinatra, and ran into issues with scaling, and so hence I did the only logical thing and wrote a new framework. I just found that because of sinatra's "build it from the ground up" philosophy, I couldn't make anything too large without making a mass of spaghetti code. That is why this framework allows you to use rails concepts like MVC and moduarly use different components in development and production. It supports the simple sinatra DSL syntax (for the most part) to make small apps, and allows big controllers and models for separation of concerns in larger apps, which is more of a rails philosophy.
 
-Add this line to your application's Gemfile:
+Anyways, I've worked really hard on this, and I would love for you to try it out and maybe even contribute! Feel free to reach out to me at [atd@developingtechnician.com](mailto:atd@developingtechnician.com) with questions or concerns, or if it's something concrete you want me to change, just open an issue.
 
-```ruby
-gem 'atd', :git => 'https://gitlab.com/izwick-schachter/atd.git'
-```
+## Installation
 
-Or, (not recommended) you can use only the rubygems version, which you can use with:
+Pretty simple, the usual `gem install atd` if you want to use without bundler, or just add it to your Gemfile with bundler. The recommended setup is to use the master branch of the git repo by adding to your Gemfile:
 
 ```ruby
-gem 'atd'
+gem 'atd', git: 'https://gitlab.com/izwick-schachter/atd.git', branch: "master"
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it from the repository with:
+Or if you want to live on the edge, where all the latest and greatest features are, change `branch` to `"development"`. Keep in mind, this may sometimes not work, so use at your own risk. When you do this, it's recommended that you go into the git repo and choose a specific commit  and lock that in by setting `:ref` to the commit hash.
 
-    $ git clone https://gitlab.com/izwick-schachter/atd.git
-    $ cd atd
-    $ bundle exec rake install
+## The Basics
 
-This will also allow you to use the current development version (USE WITH CAUTION), and to use that you can `git checkout development` and then `bundle exec rake install`. 
+`ATD` is structured around a two basic constructs: `App`s and `Route`s.
 
-## Setup
-
-Setup is as easy as `require "atd"` at the top of whatever file you need it in
+### Apps
 
-## Routing
+An `App` is a class which is a functional rack app. It has an instance method `call` as the rack spec requires, and it contains all the things you need to use `ATD`. An `App` is just a class that extends `ATD::App`. That said, for most usages you will never need to know anything about `App`s. Unless you need multiple different `App`s in the same file, you don't need to touch it. That is because `ATD` kindly treats `main` as an `App` called `DefaultApp`. All that means is that anything created in `main` is added to `DefaultApp`. So, whenever you do something that is not in an `App` you have created, you can just know in the back of your head that you are impacting `DefaultApp`.
 
-### Basic Routing
+### Routes
 
-On the lowest level it can be used serve files or any strings when a path is requested (and optionally when a specific HTTP method is used). Here is a basic route that will serve `Hello World` when `/` is sent any HTTP request (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`):
+The second basic construct is a `Route`. These are things which you should understand, because these are how `ATD` processes most of the things you do. Every route belongs to an `App`, typically `DefaultApp` as mentioned [above](#apps). In it's most simple form, a `Route` simply says "When `/whatever` is requested, return this file and/or run this code". The syntax will certainly remind you of sinatra:
 
 ```ruby
-request "/", "Hello World"
+request "/some/path", "my_file.html.erb"
+# Also aliased to:
+req "/some/path", "my_file.html.erb"
+# And
+r "/some/path", "my_file.html.erb"
+# It's easier to type
 ```
 
-The `request` method is also aliased to `req` and `r` for better code readability if you prefer. Here are 3 equivalent routes:
+Why not make the method named for the HTTP verbs? Because we want everything to be customizable. By default, calling `request` will make the route respond to every HTTP verb. If you want it to only respond to some verbs, you have several choices for how you want to do it:
 
 ```ruby
-request "/", "Hello World"
-req "/", "Hello World"
-r "/", "Hello World"
+# If you only wanted to respond to GET, POST, and DELETE:
+request "/some/path", "my_file.html.erb", respond_to: [:get, :post, :delete]
+# Or this other syntax
+get post delete "/some/path", "my_file.html.erb"
+# Or a combination of the two
+get "/some/path", "my_file.html.erb", respond_to: [:post, :delete]
+# Or with dots too
+get.post.delete "/some/path", "my_file.html.erb"
+# Maybe mixed with request:
+request.get.post.delete "/some/path", "my_file.html.erb"
+# Or if you wanted to ignore those verbs and only respond to PUT and PATCH
+request "/some/path", "my_file.html.erb", ignore: [:get, :post, :delete]
 ```
 
-For the purposes of this README, we will only use the `request` syntax, for improved readability, but anywhere in the code these are interchangeable, because they all return an `ATD::Route` object.
+_N.B. See [precompilers](#precompilers) for how the file name you pass is manipulated before it is sent out._
 
-You could use the same basic routing syntax to return `Hello World` for a HTTP `GET` request to `/`:
+You can also pass a block that will be run whenever the `Route` is matched:
 
 ```ruby
-request.get "/", "Hello World"
-```
-
-Or you could use a simpler (but equivalent) syntax:
-
-```ruby
-get "/", "Hello World"
+request "/some/path", "my_file.html.erb" do
+  puts "Found me!"
+end
 ```
 
-For the purposes of this README we will only use `request.get` and not `get` because we believe it adds clarity.
+and if you want to, you can make the blocks return value be the output of the route by omitting `"my_file.html.erb"`. You can also manipulate the output that you passed (see [helpers](#helpers)) by modifying the `view[:raw]` variable.
 
-You can also have route respond to more than one HTTP verb with `get.post.put.patch`:
+## Settings
 
-```ruby
-request.get.post.put.patch "/", "Hello World"
-```
+This doesn't exist yet, but is in progress in issue #29.
 
-This will respond to `GET`, `POST`, `PUT`, and `PATCH` with `Hello World`, but will repond to `DELETE` with a `404` status code.
+## Advanced Routing
 
-The `get.post.put.patch` is not recommended for readability. Instead use the following syntax:
+For simple project, [the basics](#the-basics) of routing will work fine. But if you want to create a full fledged application, then you probably are going to need some of the more advanced features, such as precompilation, compilation, compiler options, and using blocks to manipulate output.
 
-```ruby
-request "/", "Hello World", respond_to: [:get, :post, :put, :patch]
-```
+### Options Hash
 
-Or, a simpler way would be with `:ignore`:
-
-```ruby
-request "/", "Hello World", ignore: :delete
-```
-
-#### Options Hash
-
-You can pass various options through the options hash. The options hash is put as the last arguemtn when creating a route. For example: `request "/", "Hello World", option: value, other-option: value`
-
-Here is a list of the option which are currently valid and default values:
+The options hash is the hash provided at the end of the argument list when creating a route. For example, in `r "/", "some_file", option_A: "Value", option_B: 35` the options hash will be `{option_A: "Value", option_B: 35}`. Here is a list of options that ATD looks at internally and their default values (other keys can be passed in the options hash, they will just be passed to compilation methods):
 
 ```ruby
 status: 200 # Integer > 99 and < 1000. This will be the status code returned unless it is overridden by
 status_code: 200 # Same as status, but overrides. A slightly more verbose syntax.
-respond_to: nil # A list of HTTP methods as lowercase symbols which the route should respond to.
-ignore: nil # A list of HTTP methods as lowercase symbols which the route should not respond to.
+respond_to: nil # A array of HTTP methods as lowercase symbols which the route should respond to.
+ignore: nil # A array of HTTP methods as lowercase symbols which the route should not respond to. This takes highest precedence.
+precompile: true # This determines if a route will be precompiled. Unless it is == false it will be precompiled.
+compile: true # This determines if a route will be compiled. Unless it is == false it will be compiled.
 ```
 
-#### Serving Files
+### Serving Files
 
-All files that you want to serve must be in the `assets` directory if they are, then it is simple to just create a route, and put the filename as the output. For example this will serve `assets/index.html`:
-
-```ruby
-request "/", "index.html"
-```
+If you want to serve files, just place them in an assets directory in the app directory and pass the file name with the file extension as the second argument to your routes. In the future you will be able to access this through the [`App` settings](#settings).
 
-There are certain modifications which can be made to files between the route being requested and the files being served. That information can be found in the [compilation section](#compilation).
+### Helpers
 
-### Advanced Routing
+In the block passed to a `Route` there are helpers available to it. You can add new helper methods by adding them to the `ATD::Helpers` module. By default there are a few defined, and here they are:
 
-#### DefaultApp
-
-`DefaultApp` is just another app which extends `ATD::App`, it is the app which doesn't have to be written to in `class DefaultApp`, any routes that are created in `main` will be added to `DefaultApp`, well... by default! To find out more about Apps, you can go to the [Apps section](#apps).
+```ruby
+http[:request] # The Rack::Request object
+http[:response] # The Rack::Response object
+http[:view] # The same thing as view[:raw]
+http[:method] # The HTTP verb used to access the route
+http[:headers] # The headers which will be sent, by default only "content-type".
+http[:status_code] # The status code which the app will respond with, by default 200
+params # The params hash we all know and love.
+view[:raw] # The precompiled (unless precompile:false) and compiled (unless compile:false) view.
+```
 
-#### Inheritance
+## Apps
 
-Whenever you create a route, it is given to an App Class (which inherits from `ATD::App`). This isn't apparent when you create a route in `main`, but even when you do that the route is added to `DefaultApp`. If you are using Apps, than when you create a route in the App Class, that route is given to that Class. When you start the server, it then creates an instance of the App Class and starts it as a rack app. But that is not what the purpose of Apps are.
+Whenever you create a route, it is given to an `App`. This isn't apparent when you create a route in `main`, but even when you do that the route is added to `DefaultApp`, as you may remember from the [intro](#the-basics). If you are using Apps, then when you create a route in an `App`, that route belongs to the `App`. When you start the server, it then creates an instance of the `App` and starts it because it is a rack app. But that is not what the purpose of `App`s are.
 
-The intention of Apps are to allow you to use one App Class as a template class, from which you can create many different apps. An App Class is not a rack app all by itself. Every instance of an App Class is a rack app. But the rack app doesn't actually start until `start` is called. This means that you can create an instance of an App Class (an App), and then you can modify it before starting it. So for example, you can have an app which is impacted by an instance variable:
+The intention of `Apps` are to allow you to use one `App` as a template, from which you can create many different `App`s. An `App` is not a rack app all by itself. Every instance of an App Class is a rack app. But the rack app doesn't actually start until `start` is called. This means that you can create an instance of an `App`, and then you can modify it before starting it. So for example, you can have an `App` which is impacted by an instance variable:
 
 ```ruby
 class MyApp < ATD::App
   attr_accessor :my_name
   request "/", "Hi! This is my_name's App!" do
-    @http[:output] = @http[:output].gsub("my_name", @my_name)
+    view[:raw] = view[:raw].gsub("my_name", @my_name)
   end
 end
 ```
@@ -181,51 +144,47 @@ app.start
 
 Then when you try to access the website, it will respond to `/` with `Hi! This is Fredrick's App!`.
 
-#### Blocks
+### App Creation
 
-You can also add blocks to the basic routing methods to execute code when they are reached, and customize the response to the incoming request. Here is an example that will return the HTTP method used to request `/`:
+To create an app you can use `ATD.new("AppName")`. It is important to note that **ATD.new is not a constructor, although I will refer to it as one**. It simply behaves like one because you can use it to "construct" a new app. The app creation process creates a new class which you can open anywhere in your app file, with the name you pass. The name must `respond_to?(:to_sym)`, and must be a valid class name. You must call the constructor before you begin adding routes to the class, or open the class at all.
+
+You can also use the more intuitive way to create an app, which would be by declaring a class which extends `ATD::App`, like so:
 
 ```ruby
-request "/" do
-  @http[:output] = @http[:method]
+class MyAppClass < ATD::App
+  # All of my routes, settings, etc.
 end
 ```
 
-This example uses the `@http` variable which is provided to the route when called. `@http[:method]` is the http verb used by the request, and `@http[:output]` is what the route will return. If you have already defined a return value, `@http[:output]` will already be set to it. For example:
+### Starting the App
+
+There are two basic ways to start the app. You can start it by calling `AppName.new.start` or more simply `AppName.start` which will create an instance and call start on it, or you can use the more common syntax. For `DefaultApp` that would be:
 
 ```ruby
-request "/", "The HTTP Verb is: " do
-  @http[:output] += @http[:method]
-end
+request "/", "Hello World!"
+start
 ```
 
-Will return `The HTTP Verb is: get/post/put/patch/delete`, depending on the http verb used in the request. It will also pre-parse a file. So if you have added an HTML file with `request "/", "file.html"`, `@http[:output]` will be set to the contents of that file.
-
-You could also run some complex method created outside the route. This route is called in the same scope as any block you were to declare. Here is an example:
+And for `MyApp` that would be:
 
 ```ruby
-request "/", "I'm computing a complex function" do
-  complex_function
+class MyApp < ATD::App
+  request "/", "Hello World!"
+  start
 end
 ```
 
-##### @http
+## Controllers
 
-The `@http` instance variable can be used to work with the http request the the route is parsing. Here are some ways you can use the `@http` variable:
+> **Caution:**
+> 
+> This entire section is experimental right now and as partial or no support. Don't trust this section and tread carefully.
 
-```ruby
-@http[:status_code] = 200 # By default the status code is 200. You can manipulate this.
-@http[:headers] = {} # By defualt there are no headers. You can add whatever you want.
-@http[:method] = env["REQUEST_METHOD"] # Writing to this does nothing. Just a way for you to see the request method.
-@http[:output] # This is set to the output you give in the args for request
-@http[:request] # The associated Rack::Request for the request.
-```
-
-While you can use `@http[:status_code]` to change the status code, you can also set a status code with `r "/", status_code: 200`. That status code must be >= 100, as per the Rack Specification.
+Because we understand how important it is to have flexibility in how you work, we provide support of a number of different configurations, and one of the ways we do that is with controllers. A controller is simply a module full of methods which can be referenced from a `Route` by passing `controller_name#action` instead of the file name or by putting it in the options hash with `to: controller_name#action` or `to: :action, controller: "controller_name"`.
 
-#### Controllers
+If you want to add all the methods from one controller to an `App` you can do that by calling the `controller` method in the `App` with the name of the controller as a parameter.
 
-ATD also had the capabilities to use controllers. A controller is an object which responds to controller methods, usually a module with `extend self`. Here is an example of an app using controllers:
+Here is an example of an `App` using controllers:
 
 ```ruby
 module MyController
@@ -237,96 +196,41 @@ end
 request "/", "MyController#test_route" #=> "You've reached test_route"
 ```
 
-### Apps
-
-ATD also allows you to use different "apps". Each app is independent of the others and lives is a class with the same name as the app. A file can have any number of apps, each of which can have it's own settings, files, and routes. By default, adding routes to `main` will make them a part of the app `DefaultApp`, which will work fine if you only need one app.
+## Compilation
 
-#### App Creation
+_N.B. At some point in the indefinite future there might (but probably will) be a [tilt](https://github.com/rtomayko/tilt) integration_
 
-To create an app you can use `ATD.new("AppName")`. It is important to note that *ATD.new is not a constructor, although I will refer to it as one*. It simply behaves like one because you can use it to "construct" a new app. The app creation process creates a new class which you can open anywhere in your app file, with the name you pass. The name must `#respond_to?(:to_sym)`, and must be a valid class name. You must call the constructor before you begin adding routes to the class, or open the class at all.
+### The Basics
 
-You can also use the more intuitive way to create an app, which would be by declaring a class which extends `ATD::App`, like so:
+Because `ATD` attempts to practice separation of concerns, there is a special module, `ATD::Compilation` which is responsible for dealing with compilation. In `ATD` there are two types of compilers: First, there are precompilers, which run during the apps startup process and do things like minify assets and compile things which do not need to by dynamic. Second, there are compilers, which deal with dynamic assets and run whenever a `Route` is reached. To create them you can use the following syntax (the example is for compiling ERB files):
 
 ```ruby
-class MyAppClass < ATD::App
-  # All of my routes, code, etc.
+to_compile "erb" do |file = "", *opts|
+  ERB.new(file).result
 end
 ```
 
-#### Starting the App
-
-There are two basic ways to start the app. You can start it by calling `AppName.new.start` or more simply `AppName.start` which will create an instance and call start on it, or you can use the more common syntax. For `DefaultApp` that would be:
+Or if you wanted to define a precompiler to remove all the newlines from a JS file:
 
 ```ruby
-request "/", "Hello World!"
-start
-```
-
-And for `MyApp` that would be:
-
-```ruby
-class MyApp
-  request "/", "Hello World!"
-  start
+to_precompile "js" do |file = "", *opts|
+  file.gsub("\n", "")
 end
 ```
 
-#### App Routing
+If you notices, the precompilers and compilers take the contents of the file as the first argument (`file`) and they take the compiler options as the second argument (`opts`). The options are just whatever was passed with the route, for example in `r "/", "my_file.erb", hi: true` `opts == {hi: true}`.
 
-To add routes to an app, you simply must call the standard routing method inside the app class. For example, to create and add routes to an app called `Name` I would use the following code:
+> **Under the Hood**
+> 
+> The compilation works by going through the file extensions from last to first and running the compilations for each extension in that order. For example `file.html.erb` will first be compiled by the "erb" compiler, then the output of the "erb" compiler will be compiled by the "html" compiler.
 
-```ruby
-class Name < ATD::App
-  request "/", "Hello World"
-end
-```
+### Precompilation
 
-### Logging
-
-Currently there is no specified logging interface. Just use `puts` or `p` to log to `STDOUT`.
+> Precompilers are not sufficiently advanced to get their own special section yet, but will be soon.
 
 ### Compilation
 
-`ATD` will take your views and compress them for you so that your information can be transmitted more quickly. There are two different types of compilation, precompilation which occurs when the server is started, and compilation, which will live compile your code. While there are a few compilers and precompilers which will come with `ATD` most are user defined. To define compiler and precompiler methods simply add them like so:
-
-```ruby
-module ATD::Compilation::Precomiler
-  def extension(file, *opts) # This will work with any file that has .extension
-    # File is the contents of the file being compiled
-    # Whatever you return is what the file will be compiled to
-    file
-  end
-end
-
-module ATD::Compilation::Compiler
-  # Same thing here
-  def extension(file, *opts) # This will work with any file that has .extension
-    file
-  end
-end
-```
-
-The compilation works by going through the file extensions from last to first and running the compilations for each extension in that order. For example `file.html.erb` will first be compiled by the ERB compiler, then the output of the ERB compiler will be compiled by the HTML compiler.
-
-When you include a file with then `request "/route", "file.ext` it will be precompiled, but not compiled. If you want live compilation there are a few options. If you want live compilation and precompilation you will have to use the following syntax:
-
-```ruby
-request "/", "file.ext" do
- live_compilation_method @http[:output]
-end
-```
-
-If you don't need precompilation and just want live compilation (the ususal use case) then you can just use the following format:
-
-```ruby
-request "/" do
-  live_compilation_method File.read("/assets/file.ext")
-end
-```
-
-## Design Paradigms
-
-ATD is designed to fit into many different design paradigms, and to allow each person to adopt their own styles while leaving code readable to everyone. Do do this, the code was left fairly unstructured, but [here are a few examples from well known frameworks](https://gitlab.com/izwick-schachter/atd-examples.git).
+> Compilers are not sufficiently advanced to get their own special section yet, but will be soon.
 
 ## Documentation
 
@@ -336,12 +240,16 @@ You can find the YARD docs at http://izwick-schachter.gitlab.io/atd/YARD/.
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to the gem page on [rubygems.org](https://rubygems.org/gems/atd).
+
+### Some notes about Semantic Versioning
+
+[Semantic versioning]() is pretty nice. I like it. But, I really only want to hit a major version when it's production ready, so for now will we will follow semver in that bugfix releases (x.x.*) will be backwards compatible, but minor versions will not be. As soon as this is production ready we will hit 1.0.0 and start using semver.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitLab at https://gitlab.com/izwick-schachter/atd/issues. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+[Bug reports](https://gitlab.com/izwick-schachter/atd/issues) and [merge requests](https://gitlab.com/izwick-schachter/atd/merge_requests) are welcome on GitLab. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
 
-### Contribution Policies
+## Contribution Policies
 
-Every constribution should correspond to a relevent issue which you keep up to date with notes on what you are working on. Each issues gets branched off of development and is named issue/<issue number>. When you are ready to merege it back in, make sure it passes both rubocop and all the tests. Each issue should get additional test if necessary.
+Every contribution should correspond to a relevant issue which you keep up to date with notes on what you are working on. Each issues gets branched off of development and is named `issue/#{issue_number}`. When you are ready to merge it back in, make sure it passes both rubocop and all the tests. Each issue should get additional tests if necessary.

data/atd.gemspec

@@ -22,9 +22,12 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.2.2'
+  spec.required_rubygems_version = '>= 2.6.4'
 
   spec.add_runtime_dependency "rack", "~> 2.0"
   spec.add_runtime_dependency "webrick", "~> 1.3"
+  spec.add_runtime_dependency "mime-types", "~> 3.0"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
@@ -34,4 +37,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "yard", "~> 0.9"
   spec.add_development_dependency "rack-test", "~> 0.6"
   spec.add_development_dependency "simplecov", "~> 0.12"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-minitest", "~> 2.4"
 end

data/lib/atd.rb

@@ -1,13 +1,17 @@
 require_relative "atd/version"
 require "rack"
 require "webrick"
+require "mime-types"
+require_relative "atd/internal_helpers"
 require_relative "atd/builtin_class_modifications"
+require_relative "atd/internal_helpers"
 require_relative "atd/routes"
 # Extension packs
 # require_relative "extensions/precompilers"
 
 # The assistant technical director of your website. It does the dirty work so you can see the big picture.
 module ATD
+  using Refinements
   # Creates a new ATD App based on the template of {ATD::App}.
   # @return [ATD::App]
   # @param [Symbol] name The name of the new app and new class generated.
@@ -20,11 +24,16 @@ module ATD
   # So called because each instance stores a route, and will be called if that route is reached.
   # A route for the purposes of {ATD} is a parser that will be fed env in {ATD::App#call the rack app}.
   class Route
-    attr_accessor :args, :method, :block, :path, :output, :app, :actions, :status_code
+    include InternalHelpers
+
+    attr_reader :app
+    attr_accessor :args, :method, :block, :path, :output, :actions, :status_code, :filename, :headers
 
     # The first two arguments must me the path and the output.
     def initialize(*args, &block)
+      @args, @block, @path, @output, @actions, @status_code, @filename = nil
       @status_code = 200
+      @headers = {}
       @method = [:get, :post, :put, :patch, :delete]
       @method = [] if args.last.is_a?(Hash) && !(args.last[:respond_to].nil? || args.last[:ignore].nil?)
       @app = :DefaultApp
@@ -71,6 +80,7 @@ module ATD
         # the variables up through the different method calls.
         if args.first.is_a?(ATD::Route)
           @method = args.first.method
+          @filename = args.first.filename
           @output = args.first.output
           @path = args.first.path
           @args = args.first.args
@@ -85,67 +95,65 @@ module ATD
       end
     end
 
-    # Converts an instance of {ATD::Route} into it's Hash representation.
-    # The format for the Hash is listed {ATD::App#initialize here}
-    # @api private
-    def to_h
-      routes = {}
-      routes[@path] = {}
-      routes[@path][@method] = {}
-      routes[@path][@method] = {
-        status_code: @status_code,
-        output: @output,
-        block: @block,
-        args: @args,
-        route: self
-      }
-      routes
-    end
-
     private
 
     # This should also manage @method at some point
-    def parse_args(*args, &block)
-      args.compact!
-      args.flatten!
-      args.reject! { |arg| arg.is_a?(File) || arg.is_a?(Proc) || arg ? false : arg.empty? } # File doesn't respond to empty
-      @block = block
-      # This requires the format ATD::Route.new(path, route, args)
-      @path ||= args.shift
-      @output ||= args.shift
-      @args = Array(@args).concat(args) unless args.nil?
+    def parse_args(path = "", output = "", *args, &block)
+      args = Hash(args[0]) if args.is_a? Array
+      if output.is_a? Hash
+        args.merge(output)
+        output = ""
+      end
+      @args = Hash(@args).merge(args)
+      # rubocop:disable Style/EmptyElse
+      if !path.is_a? ATD::Route
+        @block = block
+        @path = path
+        @output = output
+      else
+        # Maybe here it would make sense to assign path and output into args
+      end
+      # rubocop:enable Style/EmptyElse
       # @output should be whatever the input is unless the input is a controller/action or the input is_file_string?
       if @output =~ /^\w*#\w*$/ # Check if @path is a controller#action combo
         controller, action = @output.split("#")
         @action = Object.const_get(controller.to_sym).method(action.to_sym)
         @output = @action.call
       end
-      # TODO: Choose one! They all work... I think...
-      # Method 1:
-      target_location = []
-      caller_locations.each do |caller_location|
-        target_dir = File.dirname(caller_location.absolute_path.to_s)
-        target_location.push(target_dir) unless target_dir.include?(__dir__)
-      end
-      # Method 2:
-      target_location = caller_locations.reject do |caller_location|
-        File.dirname(caller_location.absolute_path.to_s).include? __dir__
-      end
-      output_full_path = "#{File.dirname(target_location[0].absolute_path)}/assets/#{@output}"
+      # These next few lines are working on the assumption that if the file exists we want it, and the precompiler is
+      # counting on that.
+      output_full_path = asset @output
       @output = File.new(output_full_path) if File.exist?(output_full_path) && !Dir.exist?(output_full_path)
-      if args.is_a?(Hash) || args.last.is_a?(Hash)
-        @method += Array(args.last[:respond_to]) unless args.last[:respond_to].nil?
-        @method -= Array(args.last[:ignore]) unless args.last[:ignore].nil?
-        @status_code = args.last[:status] unless args.last[:status].nil?
-        @status_code = args.last[:status_code] unless args.last[:status_code].nil?
-      end
+      @method += Array(args[:respond_to]) unless args[:respond_to].nil?
+      @method -= Array(args[:ignore]) unless args[:ignore].nil?
+      @status_code = args[:status] unless args[:status].nil?
+      @status_code = args[:status_code] unless args[:status_code].nil?
+      Compilation.precompile(self)
+      @headers["content-type"] = MIME::Types.of(@filename)[0].to_s unless @filename.nil?
+      @block = @actions unless @actions.nil?
       self
     end
   end
 
+  module Helpers
+    def http
+      { request: @request, response: @response, view: @view, method: @method, headers: @headers, status_code: @status_code }
+    end
+
+    def params
+      @request.params
+    end
+
+    def view
+      @view
+    end
+  end
+
   # A template {App} that all Apps extend. When a new App is created with {ATD.new ATD.new} it extends this class.
   class App
-    attr_accessor :http
+    include Helpers
+    include Compilation
+
     class << self
       attr_accessor :routes # An array of instances of {ATD::Route} that belong to this {App}.
 
@@ -192,30 +200,15 @@ module ATD
     #   }
     # @param [Array] routes An array of instances of {ATD::Route}.
     def initialize(routes = [])
-      @routes = {}
-      Array(routes + self.class.routes).each do |route|
-        route = route.clone
-        filename = ATD::Compilation.precompile(route, (route.args.last.is_a?(Hash) ? route.args.last[:precompile] : nil))
-        route_hash = route.to_h
-        current_route = route_hash[route.path][route.method]
-        current_route[:filename] = filename
-        block = current_route[:block]
-        # An instance method must be defined from the block make it the same as the controller actions. We don't want to
-        # convert the controller actions to blocks because if we did that, we would have to take them out of scope to allow
-        # them to use the @http variables.
-        current_route[:block] = define_singleton_method(block.object_id.to_s.tr("0-9", "a-j").to_sym, &block) unless block.nil?
-        current_route[:block] = route.actions unless route.actions.nil?
-        @routes = @routes.to_h.deep_merge(route_hash)
+      @routes = (routes + Array(self.class.routes)).each do |route|
+        Compilation.precompile(route) unless route.output.is_a? Hash
       end
     end
 
     # Allows instance method route creation. Just another way of creating routes.
     def request(*args, &block)
       route = ATD::Route.new(*args, &block)
-      filename = ATD::Compilation.precompile(route, (route.args.last.is_a?(Hash) ? route.args.last[:precompile] : nil))
-      route_hash = route.to_h
-      route_hash[route.path][route.method][:filename] = filename
-      @routes = @routes.to_h.deep_merge(route_hash)
+      @routes += Array(route)
       route
     end
     alias req request
@@ -232,27 +225,29 @@ module ATD
     # It will return status code 200 and whatever output corresponds the that route if it exists, and if it doesn't
     # it will return status code 404 and the message "Error 404"
     def call(env)
-      @http = nil
-      route = route(env)
-      return error(404) if route.nil?
-      route[:output] = Compilation.compile(route[:filename], route[:output]) unless !route[:args].nil? && !route[:args].empty? && route[:args][0].is_a?(Hash) && route[:args][0][:compile] == false
-      return [route[:status_code].to_i, Hash(route[:headers]), Array(route[:output])] if route[:block].nil?
-      http output: route[:output], request: Rack::Request.new(env), method: env["REQUEST_METHOD"], response: Rack::Response.new(env)
-      return_val = method(route[:block]).call
-      @http[:output] = return_val if @http[:output].nil?
-      [@http[:status_code].to_i, Hash(@http[:headers]), Array(@http[:output])]
+      routes = @routes.where(path: env["PATH_INFO"], method: env["REQUEST_METHOD"].downcase.to_sym)
+      warn "WARNING: Multiple routes matched the request" if routes.length > 1
+      route = routes.first
+      return error 404 if route.nil?
+      output = route.output
+      output = Compilation.compile(route)[:content] unless route.args[:compile] == false
+      return [route.status_code.to_i, Hash(route.headers), Array(output)] if route.block.nil?
+      generate_variables(env, route)
+      return_val = instance_eval(&route.block) if route.block.is_a? Proc
+      return_val = method(route.block).call if route.block.is_a? Method
+      @view[:raw] = return_val if @view[:raw].nil? || @view[:raw].empty?
+      [@status_code.to_i, Hash(@headers), Array(@view[:raw])]
     end
 
     private
 
-    def route(env)
-      return nil if @routes[env["PATH_INFO"]].nil?
-      # return @routes[env["PATH_INFO"]][[]] unless @routes[env["PATH_INFO"]][[]].nil?
-      @routes[env["PATH_INFO"]].include_in_key?(env["REQUEST_METHOD"].downcase.to_sym)
-    end
-
-    def http(additional_params)
-      @http = { status_code: 200, headers: {} }.merge(additional_params)
+    def generate_variables(env, route)
+      @status_code = 200
+      @headers = {}
+      @view = { raw: route.output }
+      @request = Rack::Request.new(env)
+      @method = env["REQUEST_METHOD"]
+      @response = Rack::Response.new(env)
     end
 
     def error(number)
@@ -264,7 +259,7 @@ end
 
 # @return [ATD::Route]
 def request(*args, &block)
-  ATD::App.request(args, block)
+  ATD::App.request(*args, &block)
 end
 alias req request
 alias r request

data/lib/atd/builtin_class_modifications.rb

@@ -1,38 +1,45 @@
-# @!visibility private
-class Hash
-  # Not only merges two hashes, but also merges the hashes that may be nested in.
-  #
-  # For example:
-  #   {a: {b: "c"}}
-  # Is a nested hash
-  def deep_merge(second)
-    merger = proc do |_, v1, v2|
-      if v1.is_a?(Hash) && v2.is_a?(Hash) then v1.merge(v2, &merger)
-      elsif v1.is_a?(Array) && v2.is_a?(Array) then v1 | v2
-      elsif [:undefined, nil, :nil].include?(v2) then v1
-      else v2
+module ATD::Refinements
+  # @!visibility private
+  refine Hash do
+    # Not only merges two hashes, but also merges the hashes that may be nested in.
+    #
+    # For example:
+    #   {a: {b: "c"}}
+    # Is a nested hash
+    def deep_merge(second)
+      merger = proc do |_, v1, v2|
+        if v1.is_a?(Hash) && v2.is_a?(Hash) then v1.merge(v2, &merger)
+        elsif v1.is_a?(Array) && v2.is_a?(Array) then v1 | v2
+        elsif [:undefined, nil, :nil].include?(v2) then v1
+        else v2
+        end
       end
+      merge(second.to_h, &merger)
     end
-    merge(second.to_h, &merger)
-  end
 
-  def include_in_key?(search)
-    each do |key, val|
-      return val if key.is_a?(Array) && key.include?(search)
+    def include_in_key?(search)
+      each do |key, val|
+        return val if key.is_a?(Array) && key.include?(search)
+      end
     end
   end
-end
 
-# This method only exists for the test suite, specifically {ATDTest#test_route_creation}.
-# @!visibility private
-class Object
-  # Checks if two objects are instances of the same class and that they have the same instance variables
-  def same_properties_as?(other_class)
-    other_class.class == self.class && class_instance_variables == other_class.class_instance_variables
+  # This method only exists for the test suite, specifically {ATDTest#test_route_creation}.
+  # @!visibility private
+  refine Object do
+    # Returns the instance variables of a class
+    def class_instance_variables
+      instance_variables.map { |var| [var, instance_variable_get(var)] }.to_h
+    end
   end
 
-  # Returns the instance variables of a class
-  def class_instance_variables
-    instance_variables.map { |var| [var, instance_variable_get(var)] }.to_h
+  refine Array do
+    def where(criteria)
+      select do |element|
+        criteria.all? do |criterion, expected_value|
+          Array(element.public_send(criterion)).include?(expected_value)
+        end
+      end
+    end
   end
 end

data/lib/atd/internal_helpers.rb

@@ -0,0 +1,9 @@
+module InternalHelpers
+  def asset(name)
+    return "" if name.to_s.empty?
+    target_location = caller_locations.reject do |caller_location|
+      File.dirname(caller_location.absolute_path.to_s).include? File.expand_path("..", __dir__)
+    end
+    "#{File.dirname(target_location[0].absolute_path)}/assets/#{name}"
+  end
+end

data/lib/atd/routes.rb

@@ -1,60 +1,59 @@
-
 module ATD
   # This module holds everything related to the compilation of routes.
   module Compilation
-    # A module designed to hold all the precompilation methods
-    module Precompiler
-      extend self
+    include InternalHelpers
 
-      # Lists all filestypes that have defined precompiler methods
-      def filetypes
-        instance_methods(true) - [:filetypes]
-      end
+    def respond_to_missing?(method, include_private = false)
+      ATD::Compilation.compilers.key?(method.to_sym) || super
     end
 
-    # A module designed to hold all the compilation methods
-    module Compiler
-      extend self
-
-      # Lists all file extentions which have defined compiler methods
-      def filetypes
-        instance_methods(true) - [:filetypes]
-      end
+    def method_missing(method, *args, &block)
+      return super unless ATD::Compilation.compilers.key?(method.to_sym)
+      filename = args.pop
+      ATD::Compilation.compilers[method].call(ATD::Compilation.parse(ATD::Compilation.compilers, filename, File.read(asset(filename)), Hash(args).merge(run: false)), *args)
     end
 
-    # This method is responsible for live compilation. It takes an ATD::Route as input, and returns either
-    # the filename if Route.output is a file or the Route.output string if Route.output is a string.
-    # It will also take the file and call the corresponding compilation method on it.
-    def self.compile(name, contents)
-      return contents if name.nil?
-      contents = File.read(contents) if contents.is_a? File
-      parse(Compiler, name, contents)
-    end
+    class << self
+      attr_accessor :compilers, :precompilers
 
-    # This method is responsible for precompilation. It takes an ATD::Route as input, and returns either
-    # the filename if Route.output is a file or the Route.output string if Route.output is a string.
-    # It will also take the file and call the corresponding precompilation method on it.
-    # route.output is either a full, expanded file path, a file, or a string
-    def self.precompile(route, *opts)
-      return nil if route.output.nil?
-      if route.output.is_a?(File)
-        name = route.output.is_a?(File) ? File.basename(route.output) : route.output.dup
-        file = route.output.is_a?(File) ? route.output.dup : File.new(route.output)
-        route.output = parse(Precompiler, name, File.read(file)) if opts[0].nil? || opts[0]
-        return name
+      # This method is responsible for live compilation. It takes an ATD::Route as input, and returns either
+      # the filename if Route.output is a file or the Route.output string if Route.output is a string.
+      # It will also take the file and call the corresponding compilation method on it.
+      def compile(route, *opts)
+        { content: parse(@compilers, route.filename, route.output, opts), name: route.filename }
       end
-      route.output
-    end
 
-    class << self
-      private
+      # This method is responsible for precompilation. It takes an ATD::Route as input and compilation options. It
+      # sets the routes filename and output properties to be the filename and the contents of that file or, if route.output
+      # doesn't correspond to a valid file, it sets both to be route.output. It returns the precompiled version of the file
+      # regardless, and sets route.ouput to be the precompiled version unless the opt precompile: false is passed.
+      def precompile(route, *opts)
+        opts = Hash(opts[0]) unless opts.is_a? Hash
+        opts = opts.merge(route.args)
+        # route.output should always be a String, File, or NilClass
+        name = route.output.to_s
+        name = File.basename(route.output) if route.output.is_a?(File)
+        # name should always be a String
+        content = if route.output.is_a?(File) || (route.output.is_a?(String) && !route.output.empty? && File.exist?(route.output) && !Dir.exist?(route.output))
+                    File.read(route.output)
+                  elsif !route.output.nil?
+                    route.output
+                  else
+                    ""
+                  end
+        # content should always be a String
+        route.output = parse(@precompilers, name, content, opts) unless opts[:precompile] == false
+        route.filename = name
+        { content: parse(@precompilers, name, content, opts), name: route.filename }
+      end
 
-      def parse(type, name, contents)
-        name = name.split(".")
-        extensions = name - [name.first]
+      def parse(type, name, contents, *opts)
+        return contents if name.include?("\n")
+        extensions = name.to_s.split(".")
+        extensions.shift
         extensions.each do |extension|
-          if type.filetypes.include? extension.to_sym
-            contents = type.send(extension, contents)
+          if type.key? extension.to_sym
+            contents = type[extension.to_sym].call(contents, *opts) if Hash(opts.last)[:run] != false
             extensions -= [extension]
           end
         end
@@ -64,6 +63,19 @@ module ATD
   end
 end
 
+ATD::Compilation.compilers = {}
+ATD::Compilation.precompilers = {}
+
+def to_compile(name, &block)
+  warn "You have overriden the #{name.to_sym} compiler" if ATD::Compilation.compilers.key? name.to_sym
+  ATD::Compilation.compilers[name.to_sym] = block
+end
+
+def to_precompile(name, &block)
+  warn "You have overriden the #{name.to_sym} precompiler" if ATD::Compilation.compilers.key? name.to_sym
+  ATD::Compilation.precompilers[name.to_sym] = block
+end
+
 class Object
-  include ATD::Compilation::Compiler
+  include ATD::Compilation
 end

data/lib/atd/version.rb

@@ -1,3 +1,3 @@
 module ATD
-  VERSION = "0.4.0".freeze # The current version number of {ATD}.
+  VERSION = "0.5.0".freeze # The current version number of {ATD}.
 end

data/lib/extensions/precompilers.rb

@@ -4,6 +4,6 @@ module ATD::Compilation::Precompiler
   end
 
   def css(file)
-    file.gsub(/[\s\n]/, "")
+    file
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atd
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ACecretMaster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-06 00:00:00.000000000 Z
+date: 2017-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: 
 email:
 - izwick.schachter@gmail.com
@@ -164,6 +206,7 @@ files:
 - CHANGELOG
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
@@ -172,6 +215,7 @@ files:
 - bin/setup
 - lib/atd.rb
 - lib/atd/builtin_class_modifications.rb
+- lib/atd/internal_helpers.rb
 - lib/atd/routes.rb
 - lib/atd/version.rb
 - lib/extensions/precompilers.rb
@@ -188,15 +232,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.4
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: The assistant technical director of your website. It does the dirty work