atd 0.0.0.TEST.GITLAB1 → 0.1.0.TEST.GITLAB1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55fd5c613ac662fb3807855676374824a6518643
-  data.tar.gz: c22fb02f2ae650c95e05443ec818584bb6aba054
+  metadata.gz: 7632cff0dea940480d94ff9edf270c40cb867d84
+  data.tar.gz: 51bb58c9651e635c8ed24d15a5f1ae1f7af3915f
 SHA512:
-  metadata.gz: 20ada93c439759ab6bb4b15b4bb0702d082299930afb869fe4cb1fe13bc902640beb78ccd5e5ddc5edc873196b213016623ada0d3b5d284ef04925342b814548
-  data.tar.gz: 480cec1cef0db4daf1475ea1ed7ee7eb17ae38fab0199d91924a954c675fb42682b87d7498ccc2162e8ed34505eda724ebc1c61bfd459b2e81015d9334a2f3ea
+  metadata.gz: b47eb2b7b87ba4fa7b62f73a32da06c2e239b0aed06f63812fed6d3c94596a093a483be6b8594f236ef1d33059bcbf22916cf20e095d747b6a73f0b16feb3b82
+  data.tar.gz: 42c78f99c567e0b102b0b2138696a9de72291ac15295fd400ef49533535a73c7c1ceb69dffe332ae3dafc482235eb21695da1929ac90a84c960d2e641346a4bc

data/.gitlab-ci.yml

@@ -13,6 +13,7 @@ test:
 pages:
   only:
     - master
+    - gitlab-pages-yard-coverage
   script:
     - gem install yard
     - bundle exec yard
@@ -20,6 +21,10 @@ pages:
     - mkdir public
     - mv /builds/izwick-schachter/atd/coverage public/coverage
     - mv /builds/izwick-schachter/atd/doc public/YARD
+    - mkdir public/YARD/coverage
+    - touch public/YARD/coverage/index.html
+    - yard stats --list-undoc >> public/YARD/coverage/index.html
+    - ruby -ne 'puts "<span>#{$_}</span><br>#{"<br>" if $_.delete("\n")[-1, 1] == ":"}"' -i public/YARD/coverage/index.html
     - ls -R -a --ignore .git
   artifacts:
     paths:

data/CHANGELOG

@@ -0,0 +1,8 @@
+Repository Version:
+    - Nothing different
+
+v0.1.0:
+    - Created CHANGELOG!
+    - Added MIT License
+    - Improved general syntax n' stuff
+    - Everything works!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Isaiah Zwick-Schachter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,3 +1,17 @@
+[![build status][build status badge]][build status link] [![coverage report][coverage report badge]][coverage report link] [![gem version][gem version badge]][gem version link] [![documentation coverage][documentation coverage badge]][documentation coverage link]
+
+[documentation coverage badge]: https://img.shields.io/badge/YARD%20coverage-77.50%-yellow.svg?style=flat-square
+[documentation coverage link]: http://izwick-schachter.gitlab.io/atd/YARD/coverage
+
+[build status badge]: https://gitlab.com/izwick-schachter/atd/badges/master/build.svg?style=flat-square
+[build status link]: https://gitlab.com/izwick-schachter/atd/commits/master
+
+[coverage report badge]: http://gitlab.com/izwick-schachter/atd/badges/master/coverage.svg?style=flat-square
+[coverage report link]: http://izwick-schachter.gitlab.io/atd/coverage
+
+[gem version badge]: https://img.shields.io/gem/v/atd.svg?style=flat-square
+[gem version link]: https://rubygems.org/gems/atd
+
 # 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. 
@@ -7,7 +21,13 @@ ATD is a new web development backend framework for Ruby. It is built on top of r
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'atd', , :git => 'git://gitlab.com/izwick-schachter/atd.git'
+gem 'atd', :git => 'https://gitlab.com/izwick-schachter/atd.git'
+```
+
+Or, (not recommended) you can use only the rubygems version, which you can use with:
+
+```ruby
+gem 'atd'
 ```
 
 And then execute:
@@ -30,34 +50,80 @@ Setup is as easy as `require "atd"` at the top of whatever file you need it in
 
 #### Basic Routing
 
-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 a HTTP request:
+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`):
+
+```ruby
+request "/", "Hello World"
+```
+
+The `request` method is also aliased to `req` and `r` for better code readability if you prefer. Here are 3 equivalent routes:
 
 ```ruby
 request "/", "Hello World"
+req "/", "Hello World"
+r "/", "Hello World"
+```
+
+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.
+
+You could use the same basic routing syntax to return `Hello World` for a HTTP `GET` request to `/`:
+
+```ruby
+request.get "/", "Hello World"
+```
+
+Or you could use a simpler (but equivalent) syntax:
+
+```ruby
+get "/", "Hello World"
+```
+
+For the purposes of this README we will only use `request.get` and not `get` because we believe it adds clarity.
+
+You can also have route respond to more than one HTTP verb with `get.post.put.patch`:
+
+```ruby
+request.get.post.put.patch "/", "Hello World"
 ```
 
-The `request` method is also alias to `req` and `r` for better code readability if you prefer. Here is how you could use the same basic routing syntax to return `Hello World` for a basic HTTP GET request to `/`:
+This will respond to `GET`, `POST`, `PUT`, and `PATCH` with `Hello World`, but will repond to `DELETE` with a `404` status code.
+
+The `get.post.put.patch` is not recommended for readability. Instead use the following syntax:
 
 ```ruby
-req.get "/", "Hello World"
+request "/", "Hello World", respond_to: [:get, :post, :put, :patch]
 ```
 
-This will only respond to HTTP GET requests, whereas the first example will respond to any HTTP request.
+Or, a simpler way would be with `:ignore`:
+
+```ruby
+request "/", "Hello World", ignore: :delete
+```
 
 #### Advanced Routing
 
 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 `/`:
 
 ```ruby
-r "/" do
+request "/" do
   @http[:output] = @http[:method]
 end
 ```
 
-This example uses the `@http` variable which is provided to the route when called. 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:
+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:
 
 ```ruby
-r "/", "I'm computing a complex function" do
+request "/", "The HTTP Verb is: " do
+  @http[:output] += @http[:method]
+end
+```
+
+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:
+
+```ruby
+request "/", "I'm computing a complex function" do
   complex_function
 end
 ```
@@ -74,21 +140,48 @@ The `@http` instance variable can be used to work with the http request the the
 @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.
+
 ### 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.
 
 #### App Creation
 
-To create a route you can use `ATD.new("AppName")`. It is important to note that *ATD.new is not a construtor*. 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 be a string or symbol, 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.
+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
+class MyAppClass < ATD::App
+  # All of my routes, code, etc.
+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:
+
+```ruby
+request "/", "Hello World!"
+start
+```
+
+And for `MyApp` that would be:
+
+```ruby
+class MyApp
+  request "/", "Hello World!"
+  start
+end
+```
 
 #### App Routing
 
 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:
 
 ```ruby
-ATD.new(:Name)
-class Name
+class Name < ATD::App
   request "/", "Hello World"
 end
 ```
@@ -97,9 +190,32 @@ end
 
 Currently there is no specified logging interface. Just use `puts` or `p` to log to `STDOUT`.
 
-### Middleware
+### 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.
+
+## Documentation
 
-Middleware is currently used inside the app with the `ATD::Middleware` module. Currently use this with caution, backwards compatibility may be broken. It is for use only internally for now. For documentation, look to the comments.
+You can find the YARD docs at http://izwick-schachter.gitlab.io/atd/YARD/.
 
 ## Development
 

data/atd.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "rack", "~> 2.0"
+  spec.add_runtime_dependency "webrick", "~> 1.3"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/atd/builtin_class_modifications.rb

@@ -15,6 +15,12 @@ class Hash
     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)
+    end
+  end
 end
 
 # This method only exists for the test suite, specifically {ATDTest#test_route_creation}.

data/lib/atd/routes.rb

@@ -1,41 +1,62 @@
 
 module ATD
   module Compilation
-    def compile
+    module Precompiler
+      extend self
+      def filetypes
+        instance_methods(true) - [:filetypes]
+      end
+    end
+    module Compiler
+      extend self
+      def filetypes
+        instance_methods(true) - [:filetypes]
+      end
     end
 
-    def self.precompile(route)
+    def self.compile(name, contents)
+      return contents if name.nil?
+      name = name.split(".")
+      extensions = name - [name.first]
+      extensions.each do |extension|
+        contents = Compiler.send(extension, contents) if Compiler.filetypes.include? extension.to_sym
+      end
+      contents
+    end
+
+    def self.pre_parse(route)
       output = route.output
       name = output
       return nil if output.nil?
       if output.include?(".") || output.is_a?(File)
-        file = File.read(File.join("./assets/#{output}")) if output.class.is_a? String
-        file = File.read(output) if output.is_a? File
+        file = read_file(output)
         return nil if file.nil?
-        unless output.is_a? File
-          output = output.split(".")
-          name = output.shift
-          output.each do |extension|
-            file = Precompiler.send(extension, file)
-          end
-        end
+        name = (output.is_a?(File) ? File.basename(output) : output)
+        file = precompile(name, file)
         route.output = file
       end
       name
     end
 
-    module Precompiler
-      module_function
+    class << self
+      private
 
-      def html(file)
-        file
+      def read_file(output)
+        return File.read(File.join("assets/#{output}")) if output.is_a?(String) && File.exist?("assets/#{output}")
+        return File.read(output) if output.is_a? File
       end
-    end
 
-    def self.setup
-      ATD::Middleware.create(ATD::Compilation.method(:precompile), ATD::Route)
+      def precompile(name, contents)
+        name = name.split(".")
+        extensions = name - [name.first]
+        extensions.each do |extension|
+          if Precompiler.filetypes.include? extension.to_sym
+            contents = Precompiler.send(extension, contents)
+            extensions -= [extension]
+          end
+        end
+        contents
+      end
     end
   end
 end
-
-ATD::Middleware.register(ATD::Compilation)

data/lib/atd/version.rb

@@ -1,3 +1,3 @@
 module ATD
-  VERSION = "0.0.0.TEST.GITLAB1".freeze # The current version number of {ATD}.
+  VERSION = "0.1.0.TEST.GITLAB1".freeze # The current version number of {ATD}.
 end

data/lib/atd.rb

@@ -1,8 +1,10 @@
 require_relative "atd/version"
 require "rack"
+require "webrick"
 require_relative "atd/builtin_class_modifications"
-require_relative "atd/middleware"
 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
@@ -16,19 +18,17 @@ module ATD
   end
 
   # 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}***.
+  # 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
 
-    # The first two arguments must me the path and the output. ***Until this code is updated it is impossible to specify output in a block***
+    # The first two arguments must me the path and the output.
     def initialize(*args, &block)
       args -= [nil]
-      args.reject!(&:empty?)
-      @block = block
-      @path = args.shift
-      @output = args.shift
-      @args = args
+      args.reject! { |arg| arg.is_a?(File) ? false : arg.empty? } # File doesn't respond to empty
+      @method = (args.last.is_a?(Hash) && !args.last[:methods].nil? ? args.last[:methods] : [:get, :post, :put, :patch, :delete])
       @app = :DefaultApp
+      parse_args(*args, &block)
     end
 
     # This works differently from a standard setter because is makes sure that a {Route} can belong to only one {App}.
@@ -66,13 +66,12 @@ module ATD
     # Sets route to receive a delete request to path and execute the block provided (if one is provided)
 
     [:get, :post, :put, :delete, :patch].each do |method|
-      define_method(method) do |path = nil, *args, &block|
-        @block = block
-        @method = method
-        @output = args.shift if @output.nil?
-        @path = path if @path.nil?
-        @args = @args.concat(args) - [nil] unless args.nil?
-        self
+      define_method(method) do |*args, &block|
+        @method = [method] if @method.length == 5
+        @method += [method]
+        @method += args.last[:methods] if args.last.is_a?(Hash) && !args.last[:methods].nil?
+        @method.uniq!
+        parse_args(*args, &block)
       end
     end
 
@@ -91,6 +90,17 @@ module ATD
       }
       routes
     end
+
+    private
+
+    # This should also manage @message at some point
+    def parse_args(*args, &block)
+      @block = block
+      @path = args.shift if @path.nil?
+      @output = args.shift if @output.nil?
+      @args = Array(@args).concat(args) - [nil] unless args.nil?
+      self
+    end
   end
 
   # A template {App} that all Apps extend. When a new App is created with {ATD.new ATD.new} it extends this class.
@@ -108,6 +118,19 @@ module ATD
       end
       alias req request
       alias r request
+
+      [:get, :post, :put, :patch, :delete].each do |i|
+        define_method(i) do |*args, &block|
+          request.send(i, *args, &block)
+        end
+      end
+
+      # Starts the rack server
+      # @param [Class] server The server that you would like to use.
+      # @param [Fixnum] port The port you would like the server to run on.
+      def start(server = WEBrick, port = 3150)
+        Rack::Server.start(app: self.new, server: server, Port: port)
+      end
     end
 
     # Sets up the @routes instance variable from the {.routes} class instance variable.
@@ -129,15 +152,13 @@ module ATD
     #   }
     # @param [Array] routes An array of instances of {ATD::Route}.
     def initialize(routes = [])
-      Middleware.setup(ATD::Route)
-      routes.each do |route|
-        Middleware.run(route)
-      end
       routes += self.class.routes
       @routes = {}
       routes.each do |route|
-        Middleware.run(route)
-        @routes = @routes.to_h.deep_merge(route.to_h)
+        filename = ATD::Compilation.pre_parse(route)
+        route_hash = route.to_h
+        route_hash[route.path][route.method][:filename] = filename
+        @routes = @routes.to_h.deep_merge(route_hash)
       end
     end
 
@@ -154,6 +175,7 @@ module ATD
     def call(env)
       route = route(env)
       return error(404) if route.nil?
+      route[:output] = ATD::Compilation.compile(route[:filename], route[:output])
       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"]
       run_block(route[:block])
@@ -163,13 +185,12 @@ module ATD
 
     def route(env)
       return nil if @routes[env["PATH_INFO"]].nil?
-      return @routes[env["PATH_INFO"]][nil] unless @routes[env["PATH_INFO"]][nil].nil?
-      @routes[env["PATH_INFO"]][env["REQUEST_METHOD"].downcase.to_sym]
+      # 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 run_block(block)
       block.call
-      Middleware.run(self)
       [self.class.http[:status_code].to_i, Hash(self.class.http[:headers]), Array(self.class.http[:output])]
     end
 
@@ -191,4 +212,18 @@ end
 alias req request
 alias r request
 
-ATD.new("DefaultApp")
+# Starts the rack server
+# @param [Class] app The app you would like to start
+# @param [Class] server The server that you would like to use.
+# @param [Fixnum] port The port you would like the server to run on.
+def start(app = DefaultApp, server = WEBrick, port = 3150)
+  Rack::Server.start(app: app.new, server: server, Port: port)
+end
+
+[:get, :post, :put, :patch, :delete].each do |i|
+  define_method(i) do |*args, &block|
+    request.send(i, *args, &block)
+  end
+end
+
+Object.const_set(:DefaultApp, Class.new(ATD::App)) # Create DefaultApp

data/lib/extensions/precompilers.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atd
 version: !ruby/object:Gem::Version
-  version: 0.0.0.TEST.GITLAB1
+  version: 0.1.0.TEST.GITLAB1
 platform: ruby
 authors:
 - ACecretMaster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-28 00:00:00.000000000 Z
+date: 2016-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -146,9 +160,10 @@ files:
 - ".gitignore"
 - ".gitlab-ci.yml"
 - ".rubocop.yml"
-- ".travis.yml"
+- CHANGELOG
 - CODE_OF_CONDUCT.md
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - atd.gemspec
@@ -156,9 +171,9 @@ files:
 - bin/setup
 - lib/atd.rb
 - lib/atd/builtin_class_modifications.rb
-- lib/atd/middleware.rb
 - lib/atd/routes.rb
 - lib/atd/version.rb
+- lib/extensions/precompilers.rb
 homepage: https://rubygems.org/gems/atd
 licenses:
 - MIT

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.12.5

data/lib/atd/middleware.rb

@@ -1,30 +0,0 @@
-# All middleware must respond_to?("setup")
-# To register middleware, after the class call ATD::Middleware.register(Your::Middleware)
-module ATD
-  module Middleware
-    @middleware = {}
-    @sources = []
-
-    def self.register(source)
-      @sources.push source
-    end
-
-    def self.run(target = nil)
-      return nil if @middleware[target.class].nil?
-      @middleware[target.class].each do |action|
-        action.call(target)
-      end
-    end
-
-    def self.create(source, target)
-      @middleware[target] = [] if @middleware[target].nil?
-      @middleware[target].push(source)
-    end
-
-    def self.setup(target)
-      # At some point, target should be used so that middleware are only setup on one target.
-      @sources.each(&:setup)
-      target
-    end
-  end
-end