gem "rack-stack", :git => "https://github.com/remi/rack-stack.git"

require "rack/stack" # or "rack-stack"

rack_stack = RackStack.new do
  use MyMiddleware
  map "/admin" do
    run AdminApp.new
  end
  run MyApp.new
end

# A RackStack instance is a Rack application, so you can #call it.
status, headers, body = rack_stack.call(env)

RackStack.new do

  # When a block is given with 1 argument, the current request will be yielded (as a Rack::Request)
  use MyMiddleware, when: ->(request){ request.path_info =~ /about-us/ }

  # When a block is given with no arguments, the block is evaluated against the current request instance
  use MyMiddleware, when: ->{ path_info =~ /about-us/ }

  # When a Hash (or Array of pairs) is given, each value will be compared against the value from the 
  # current request.  In this example, the following would be evaluated: /about-us/ === "<the path info>"
  use MyMiddleware, when: { path_info: /about-us/ }

  # Map also works with :when.
  map "/section", when: ->{ params["mobile"] == "true" } do
    # Nested options work with conditionals as well.
    run AndroidSectionApp.new, when: { user_agent: /Android/i }
    run MobileSectionApp.new
  end

  # Run also works with :when.
  # If RackStack handles a request and NONE of the conditionals match, 
  # a NoMatchingApplicationError will be thrown.
  run @app, when: { host: "domain.com" }

end

@rack_stack = RackStack.new do
  use :cool_middleware, CoolMiddleware
  map :foo, "/foo" do
    run :foo_app, FooApp.new
  end
  run :main, MainApp.new
end

# For middleware, the instance of the middleware that we create & use to process requests is returned.
@rack_stack.get(:cool_middleware)
# => #<CoolMiddleware:0x000000015fb520>

# For endpoints, the application instance is returned.
@rack_stack.get(:main)
# => #<MainApp:0x000000015db7a8>

# Components nested within maps are returned too.
@rack_stack.get(:foo_app)
# => #<FooApp:0x000000015fb740>

# For maps, the RackStack instance (representing the nested map) is returned.
@rack_stack.get(:foo)
# => #<RackStack:0x000000015cf840>

@rack_stack.get(:cool_middleware)
# => #<CoolMiddleware:0x000000015fb520>

# Get is aliased to [], so this also works.
@rack_stack[:cool_middleware]

# We also have a method_missing implementation, so this also works.
@rack_stack.cool_middleware
@rack_stack.respond_to? :cool_middleware # => true

# RackStack#remove removes every Rack component with the given name from the stack.
@rack_stack.remove :cool_middleware

# Example of using RackStack as a middleware (app built using an ordinary Rack::Builder)
Rack::Builder.new {

  use SomeMiddleware

  # RackStack can be used as a middleware, alongside your existing Rack components
  use RackStack.new when: { host: "foo.com" } do
    use AnotherMiddleware
    run SomeApplication.new
  end

  # Or RackStack can be used as a Rack endpoint.
  run RackStack.new do
    run AnotherApplication.new  
  end

}.to_app

rack_stack = RackStack.new

# You can run the RackStack or something else, eg. mount it with Artifice
some_rack_server.run(rack_stack)

# #use, #run, and #map may be used at runtime
rack_stack.use :my_middleware, SomeMiddleware
rack_stack.run SomeApp.new, when: { host: "someapp.com" }
rack_stack.map "/foo" do
  use FooMiddleware
  run FooApp.new
end

# You can easily remove named applications
rack_stack.remove :my_middleware

# For example, if you want to put a #use statement *first*, you can:
rack_stack.stack.unshift RackStack.use(:my_middleware, SomeMiddleware)

# Note that #use/map/run statements are manually reproduced by passing the 
# same arguments to the RackStack::use/map/run methods.

# As another example, you may want to remove un-named applications from your RackStack.
rack_stack.stack.reject! do |component|

  # you can ask a component if it is a use? map? or run?
  if component.use?

    # .instance may be called on any component to get the object that RackStack#get returns for a component.
    instance = component.instance

    # sample of a check that we might want to do to remove a component.
    true if instance.is_a? MyMiddleware && instance.my_middleware_method?
  end
end