├── .editorconfig ├── .github └── workflows │ └── crystal.yml ├── .gitignore ├── .tool-versions ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── ISSUE_TEMPLATE.md ├── LICENSE ├── README.md ├── examples ├── base.cr └── simple-server.cr ├── orion-banner.svg ├── shard.yml ├── spec ├── fixtures │ ├── index.html │ └── test.txt ├── orion │ ├── dsl │ │ ├── concerns_spec.cr │ │ ├── constraints_spec.cr │ │ ├── handlers_spec.cr │ │ ├── helpers_spec.cr │ │ ├── match_spec.cr │ │ ├── methods_spec.cr │ │ ├── resources_spec.cr │ │ ├── scope_spec.cr │ │ └── websockets_spec.cr │ ├── handlers │ │ └── method_override_param_spec.cr │ └── router_spec.cr └── spec_helper.cr └── src ├── app.cr ├── http.cr ├── http └── request.cr ├── macro.cr ├── orion.cr ├── orion ├── CHANGELOG.md ├── action.cr ├── assets.cr ├── assets │ └── pack.cr ├── cache.cr ├── cache │ └── keyable.cr ├── config.cr ├── constraint.cr ├── constraints │ ├── accept_constraint.cr │ ├── content_type_constraint.cr │ ├── format_constraint.cr │ ├── hash_constraint.cr │ ├── host_constraint.cr │ ├── methods_constraint.cr │ ├── params_constraint.cr │ ├── subdomain_constraint.cr │ └── web_socket_constraint.cr ├── controller.cr ├── controller │ ├── base.cr │ ├── cache_helpers.cr │ ├── rendering.cr │ ├── request_helpers.cr │ └── response_helpers.cr ├── dsl.cr ├── dsl │ ├── concerns.cr │ ├── constraints.cr │ ├── handlers.cr │ ├── helpers.cr │ ├── macros.cr │ ├── match.cr │ ├── mount.cr │ ├── request_methods.cr │ ├── resources.cr │ ├── root.cr │ ├── scope.cr │ ├── static.cr │ └── websockets.cr ├── error_page.html.ecr ├── errors.cr ├── exception_page.cr ├── handler.cr ├── handlers.cr ├── handlers │ ├── auto_close.cr │ ├── auto_mime.cr │ ├── config.cr │ ├── exceptions.cr │ ├── logger.cr │ ├── method_override_header.cr │ ├── method_override_param.cr │ ├── reset_path.cr │ ├── route_finder.cr │ └── scope_base_path.cr ├── helpers.cr ├── helpers │ └── mime_helper.cr ├── inflector │ ├── controllerize.cr │ ├── decontrollerize.cr │ ├── path_joiner.cr │ ├── pluralize.cr │ ├── random_const.cr │ ├── singularize.cr │ └── underscore.cr ├── pipeline.cr ├── router.cr ├── server.cr ├── server │ ├── context.cr │ ├── request.cr │ ├── request_processor.cr │ └── response.cr ├── view.cr ├── view │ ├── asset_tag_helpers.cr │ ├── cache_helpers.cr │ ├── capture_helper.cr │ ├── partial_helpers.cr │ ├── registry.cr │ ├── renderer.cr │ └── renderer │ │ ├── defs.cr │ │ ├── layout_finder.cr │ │ ├── partial_finder.cr │ │ ├── tokenize.cr │ │ └── view_finder.cr └── write_tracker.cr └── parse_version.cr /.editorconfig: -------------------------------------------------------------------------------- 1 | [*.cr] 2 | charset = utf-8 3 | end_of_line = lf 4 | insert_final_newline = true 5 | indent_style = space 6 | indent_size = 2 7 | trim_trailing_whitespace = true 8 | -------------------------------------------------------------------------------- /.github/workflows/crystal.yml: -------------------------------------------------------------------------------- 1 | name: Crystal CI 2 | 3 | on: 4 | push: 5 | branches: [ master ] 6 | pull_request: 7 | branches: [ master ] 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | container: 13 | image: crystallang/crystal 14 | steps: 15 | - uses: actions/checkout@v2 16 | - name: Install dependencies 17 | run: shards install 18 | - name: Run tests 19 | run: crystal spec 20 | - name: Build Docs 21 | run: crystal docs 22 | - name: Deploy 23 | uses: peaceiris/actions-gh-pages@v3 24 | with: 25 | github_token: ${{ secrets.GITHUB_TOKEN }} 26 | publish_dir: ./docs 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /doc/ 2 | /docs/ 3 | /lib/ 4 | /bin/ 5 | /.shards/ 6 | /benchmarks/*/.shards/ 7 | /benchmarks/*/shard.lock 8 | /benchmarks/*/Gemfile.lock 9 | /benchmarks/*/lib 10 | /benchmarks/*/bin 11 | /benchmarks/results.txt 12 | 13 | # Libraries don't need dependency lock 14 | # Dependencies will be locked in application that uses them 15 | /shard.lock 16 | -------------------------------------------------------------------------------- /.tool-versions: -------------------------------------------------------------------------------- 1 | crystal 1.1.0 2 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Covenant Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. 6 | 7 | ## Our Standards 8 | 9 | Examples of behavior that contributes to creating a positive environment include: 10 | 11 | * Using welcoming and inclusive language 12 | * Being respectful of differing viewpoints and experiences 13 | * Gracefully accepting constructive criticism 14 | * Focusing on what is best for the community 15 | * Showing empathy towards other community members 16 | 17 | Examples of unacceptable behavior by participants include: 18 | 19 | * The use of sexualized language or imagery and unwelcome sexual attention or advances 20 | * Trolling, insulting/derogatory comments, and personal or political attacks 21 | * Public or private harassment 22 | * Publishing others' private information, such as a physical or electronic address, without explicit permission 23 | * Other conduct which could reasonably be considered inappropriate in a professional setting 24 | 25 | ## Our Responsibilities 26 | 27 | Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. 28 | 29 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. 30 | 31 | ## Scope 32 | 33 | This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. 34 | 35 | ## Enforcement 36 | 37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at jason@waldrip.net. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. 38 | 39 | Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. 40 | 41 | ## Attribution 42 | 43 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] 44 | 45 | [homepage]: http://contributor-covenant.org 46 | [version]: http://contributor-covenant.org/version/1/4/ 47 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | When contributing to this repository, please first discuss the change you wish to make via issue, 4 | email, or any other method with the owners of this repository before making a change. 5 | 6 | Please note we have a [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with the project. 7 | 8 | ## Pull Request Process 9 | 10 | 1. Ensure any install or build dependencies are removed before the end of the layer when doing a 11 | build. 12 | 2. Update the README.md with details of changes to the interface, this includes new environment 13 | variables, exposed ports, useful file locations and container parameters. 14 | 3. Increase the version numbers in any examples files and the README.md to the new version that this 15 | Pull Request would represent. The versioning scheme we use is [SemVer](http://semver.org/). 16 | 4. You may merge the Pull Request in once you have the sign-off of two other developers, or if you 17 | do not have permission to do that, you may request the second reviewer to merge it for you. 18 | -------------------------------------------------------------------------------- /ISSUE_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ## Expected Behavior 2 | 3 | 4 | ## Actual Behavior 5 | 6 | 7 | ## Steps to Reproduce the Problem 8 | 9 | 1. 10 | 1. 11 | 1. 12 | 13 | ## Specifications 14 | 15 | - Version: 16 | - Platform: 17 | - Subsystem: 18 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Obsidian Crystal 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![Orion](https://raw.githubusercontent.com/obsidian/orion/v3.0.0-dev/orion-banner.svg) 2 | 3 | [![Crystal CI](https://github.com/obsidian/orion/workflows/Crystal%20CI/badge.svg)](https://github.com/obsidian/orion/actions?query=workflow%3A%22Crystal+CI%22) 4 | [![GitHub issues](https://img.shields.io/github/issues/obsidian/orion)](https://github.com/obsidian/orion/issues) 5 | [![GitHub stars](https://img.shields.io/github/stars/obsidian/orion)](https://github.com/obsidian/orion/stargazers) 6 | [![GitHub license](https://img.shields.io/github/license/obsidian/orion)](https://github.com/obsidian/orion/blob/master/LICENSE) 7 | [![Documentation](https://img.shields.io/badge/Read-Documentation-%232E1052)](https://obsidian.github.io/orion) 8 | 9 | --- 10 | 11 | ## Introduction 12 | 13 | Orion is minimal, Omni-Conventional, declarative web framework inspired by the ruby-on-rails router and controller components. It provides, the routing, view, and controller framework of your application in a way that can be as simple or complex as you need it to fit your use case. 14 | 15 | ## Simple Example 16 | Orion out of the box is designed to be as simple as you want it to be. A few 17 | lines will get you a functioning web app. Orion also ships with helpful features 18 | such as view rendering and static content delivery. 19 | 20 | ```crystal 21 | require "orion/app" 22 | 23 | root do 24 | "Welcome Home" 25 | end 26 | 27 | get "/posts" do 28 | "Many posts here!" 29 | end 30 | ``` 31 | 32 | ## Flexible Routing 33 | Orion is extemely flexible, it is inspiried by the rails routing and controller framework and therefore has support for `scope`, `concerns`, `use HTTP::Handler`, `constraints` and more! See the modules in `Orion::DSL` more more detail. 34 | 35 | ```crystal 36 | require "orion/app" 37 | require "auth_handlers" 38 | 39 | static "/", dir: "./assets" 40 | 41 | scope "/api" do 42 | use AuthHandlers::Token 43 | end 44 | 45 | use AuthHandlers::CookieSession 46 | 47 | scope constraint: UnauthenticatedUser do 48 | root do 49 | render "views/home.slim" 50 | end 51 | 52 | get "/login", helper: login do 53 | render "views/login.slim" 54 | end 55 | 56 | post "/login" do 57 | if User.authenticate(params["email"], params["password"]) 58 | redirect to: root_path 59 | else 60 | flash[:error] = "Invalid login" 61 | redirect to: login_path 62 | end 63 | end 64 | 65 | scope constraint: AuthenticatedUser do 66 | root do 67 | render "views/dashboard.slim" 68 | end 69 | end 70 | ``` 71 | 72 | ## Installation 73 | Add this to your application's shard.yml: 74 | 75 | ```yml 76 | dependencies: 77 | orion: 78 | github: obsidian/orion 79 | ``` 80 | 81 | See also [Getting Started](https://github.com/obsidian/orion/wiki/Getting-Started). 82 | 83 | ## Documentation 84 | 85 | View the docs at [https://obsidian.github.io/orion](https://obsidian.github.io/orion). 86 | View the guides at [https://github.com/obsidian/orion/wiki](https://github.com/obsidian/orion/wiki). 87 | -------------------------------------------------------------------------------- /examples/base.cr: -------------------------------------------------------------------------------- 1 | require "../src/app" 2 | 3 | root do 4 | raise "Oops" 5 | end 6 | 7 | scope "/foo" do 8 | scope "/bar" do 9 | root do 10 | "Hello Foo" 11 | end 12 | end 13 | end 14 | 15 | get "/users", helper: "users" do 16 | render text: users_path 17 | end 18 | -------------------------------------------------------------------------------- /examples/simple-server.cr: -------------------------------------------------------------------------------- 1 | require "../src/orion" 2 | 3 | router MyApplication do 4 | use HTTP::LogHandler.new 5 | 6 | get "empty" do |context| 7 | context.response.puts "e" 8 | end 9 | 10 | get "/*", ->(context : Context) do 11 | context.response.puts "reviews" 12 | end 13 | 14 | get "/resources/js/*", ->(context : Context) do 15 | context.response.puts "somejs" 16 | end 17 | 18 | get "/robots.txt", ->(context : Context) do 19 | context.response.puts "robots" 20 | end 21 | end 22 | 23 | MyApplication.start(workers: System.cpu_count) 24 | -------------------------------------------------------------------------------- /shard.yml: -------------------------------------------------------------------------------- 1 | name: orion 2 | crystal: "~> 1.0" 3 | version: 4.0.0-beta4 4 | homepage: https://obsidian.github.io/orion 5 | documentation: https://obsidian.github.io/orion 6 | license: MIT 7 | 8 | authors: 9 | - Jason Waldrip 10 | 11 | dependencies: 12 | oak: 13 | github: obsidian/oak 14 | version: ">= 4.0.1" 15 | inflector: 16 | github: phoffer/inflector.cr 17 | kilt: 18 | github: jeromegn/kilt 19 | exception_page: 20 | github: crystal-loot/exception_page 21 | html_builder: 22 | github: crystal-lang/html_builder 23 | cache: 24 | github: mamantoha/cache 25 | crystar: 26 | github: naqvis/crystar 27 | -------------------------------------------------------------------------------- /spec/fixtures/index.html: -------------------------------------------------------------------------------- 1 | Index Page -------------------------------------------------------------------------------- /spec/fixtures/test.txt: -------------------------------------------------------------------------------- 1 | Hello World -------------------------------------------------------------------------------- /spec/orion/dsl/concerns_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::ConcernsSpec 4 | router SampleRouter do 5 | concern :messagable do 6 | get "messages/new", ->(c : Context) { c.response.print "lets send a message" } 7 | end 8 | 9 | scope "users" do 10 | implements :messagable 11 | end 12 | 13 | scope "groups" do 14 | implements :messagable 15 | end 16 | end 17 | 18 | describe "concerns" do 19 | it "should be present when included" do 20 | response = test_route(SampleRouter.new, :get, "/users/messages/new") 21 | response.status_code.should eq 200 22 | response.body.should eq "lets send a message" 23 | end 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /spec/orion/dsl/constraints_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::ConstraintsSpec 4 | class TestConstraint 5 | include Orion::Constraint 6 | 7 | def matches?(request : ::HTTP::Request) 8 | request.headers["TEST"]? == "true" 9 | end 10 | end 11 | 12 | router SampleRouter do 13 | get "resources/:id", ->(c : Context) { c.response.print "resource #{c.request.path_params["id"]}" }, constraints: {id: /\d{4}/} 14 | get "alpha", ->(c : Context) { c.response.print "is js" }, format: "js" 15 | get "bravo", ->(c : Context) { c.response.print "is js or jsx" }, format: /jsx?/ 16 | get "charlie", ->(c : Context) { c.response.print "is an image" }, accept: "image/*" 17 | get "delta", ->(c : Context) { c.response.print "is a png image" }, accept: "image/png" 18 | post "mary", ->(c : Context) { c.response.print "is a jpg image" }, content_type: "image/jpeg" 19 | get "echo", ->(c : Context) { c.response.print "is a png image with unicode" }, accept: "image/png; charset=utf-8" 20 | 21 | host "example.org" do 22 | get "golf", ->(c : Context) { c.response.print "at host" } 23 | end 24 | 25 | subdomain "example" do 26 | get "hotel", ->(c : Context) { c.response.print "at subdomain" } 27 | end 28 | 29 | constraint TestConstraint.new do 30 | get "lima", ->(c : Context) { c.response.print "matches custom" } 31 | end 32 | 33 | constraints TestConstraint.new do 34 | get "zulu", ->(c : Context) { c.response.print "matches customs" } 35 | end 36 | end 37 | 38 | describe "constraints" do 39 | describe "for params" do 40 | context "if matched" do 41 | it "should pass" do 42 | response = test_route(SampleRouter.new, :get, "/resources/9999") 43 | response.status_code.should eq 200 44 | response.body.should eq "resource 9999" 45 | end 46 | end 47 | 48 | context "if not matched" do 49 | it "should not pass" do 50 | response = test_route(SampleRouter.new, :get, "/resources/123") 51 | response.status_code.should eq 404 52 | end 53 | end 54 | end 55 | 56 | describe "checking format" do 57 | context "with a string" do 58 | context "if matched" do 59 | it "should pass" do 60 | response = test_route(SampleRouter.new, :get, "/alpha.js") 61 | response.status_code.should eq 200 62 | response.body.should eq "is js" 63 | end 64 | end 65 | 66 | context "if not matched" do 67 | it "should not pass" do 68 | response = test_route(SampleRouter.new, :get, "/alpha.cr") 69 | response.status_code.should eq 404 70 | end 71 | end 72 | end 73 | end 74 | 75 | describe "checking content_type" do 76 | context "with a string" do 77 | context "if matched" do 78 | it "should pass" do 79 | response = test_route(SampleRouter.new, :post, "/mary", headers: {"Content-Type" => "image/jpeg"}, body: "aaa") 80 | response.status_code.should eq 200 81 | response.body.should eq "is a jpg image" 82 | end 83 | end 84 | 85 | context "if not matched without a body" do 86 | it "should pass" do 87 | response = test_route(SampleRouter.new, :post, "/mary") 88 | response.status_code.should eq 200 89 | response.body.should eq "is a jpg image" 90 | end 91 | end 92 | 93 | context "if not matched" do 94 | it "should not pass" do 95 | response = test_route(SampleRouter.new, :post, "/mary", body: "aaa") 96 | response.status_code.should eq 404 97 | end 98 | end 99 | end 100 | end 101 | 102 | describe "checking accept" do 103 | context "with a string" do 104 | context "if matched" do 105 | it "should pass" do 106 | response = test_route(SampleRouter.new, :get, "/delta", headers: {"Accept" => "image/png"}) 107 | response.status_code.should eq 200 108 | response.body.should eq "is a png image" 109 | end 110 | end 111 | 112 | context "if matched by extension" do 113 | it "should pass" do 114 | response = test_route(SampleRouter.new, :get, "/delta.png") 115 | response.status_code.should eq 200 116 | response.body.should eq "is a png image" 117 | end 118 | end 119 | 120 | context "if matched by wildcard" do 121 | it "should pass" do 122 | response = test_route(SampleRouter.new, :get, "/delta", headers: {"Accept" => "*/*"}) 123 | response.status_code.should eq 200 124 | response.body.should eq "is a png image" 125 | end 126 | end 127 | 128 | context "if not matched" do 129 | it "should not pass" do 130 | response = test_route(SampleRouter.new, :get, "/delta", headers: {"Accept" => "text/html"}) 131 | response.status_code.should eq 404 132 | end 133 | end 134 | end 135 | end 136 | end 137 | end 138 | -------------------------------------------------------------------------------- /spec/orion/dsl/handlers_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::HandlersSpec 4 | class AppendHandler 5 | include HTTP::Handler 6 | 7 | def initialize(@string : String) 8 | end 9 | 10 | def call(c : ::HTTP::Server::Context) 11 | call_next c 12 | c.response.print @string 13 | end 14 | end 15 | 16 | router SampleRouter do 17 | # use HTTP::ErrorHandler 18 | use AppendHandler.new ", and I am a guardian" 19 | root ->(c : Context) { c.response.print "I am Groot" } 20 | scope "scoped" do 21 | use AppendHandler.new ", and I am NOT a racoon" 22 | root ->(c : Context) { c.response.print "My name is Rocket" } 23 | end 24 | end 25 | 26 | describe "handlers" do 27 | it "should run root middleware" do 28 | response = test_route(SampleRouter.new, :get, "/") 29 | response.status_code.should eq 200 30 | response.body.should eq "I am Groot, and I am a guardian" 31 | end 32 | 33 | it "should run group middleware" do 34 | response = test_route(SampleRouter.new, :get, "/scoped") 35 | response.status_code.should eq 200 36 | response.body.should eq "My name is Rocket, and I am NOT a racoon, and I am a guardian" 37 | end 38 | end 39 | end 40 | -------------------------------------------------------------------------------- /spec/orion/dsl/helpers_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::HelpersSpec 4 | c = ->(c : HTTP::Server::Context) {} 5 | 6 | router SampleRouter do 7 | get "foo", c, helper: "foo" 8 | get "bars/:bar_id/locations/:location_id", c, helper: "bar" 9 | scope helper_prefix: "scoped" do 10 | get "baz", c, helper: "baz" 11 | post "bazs", c, helper: {name: "baz", prefix: "create"} 12 | get "bazs", c, helper: {name: "baz", suffix: "index"} 13 | end 14 | end 15 | 16 | describe "helpers" do 17 | it "should define a basic helper" do 18 | SampleRouter::RouteHelpers.foo_path.should eq "/foo" 19 | end 20 | 21 | it "should append params" do 22 | SampleRouter::RouteHelpers.foo_path(f: 1, b: "2", r: true).should eq "/foo?f=1&b=2&r=true" 23 | end 24 | 25 | it "should insert url params" do 26 | SampleRouter::RouteHelpers.bar_path(bar_id: 1, location_id: 5).should eq "/bars/1/locations/5" 27 | end 28 | 29 | it "should insert url params and append the rest" do 30 | SampleRouter::RouteHelpers.bar_path(bar_id: 1, location_id: 5, pour: true).should eq "/bars/1/locations/5?pour=true" 31 | end 32 | 33 | it "should raise if a param is missing" do 34 | expect_raises Orion::ParametersMissing do 35 | SampleRouter::RouteHelpers.bar_path(bar_id: 1) 36 | end 37 | end 38 | 39 | context "within scope" do 40 | it "should scope nested routes" do 41 | SampleRouter::RouteHelpers.scoped_baz_path.should eq "/baz" 42 | end 43 | 44 | it "should prefix a route" do 45 | SampleRouter::RouteHelpers.create_scoped_baz_path.should eq "/bazs" 46 | end 47 | 48 | it "should suffix a route" do 49 | SampleRouter::RouteHelpers.scoped_baz_index_path.should eq "/bazs" 50 | end 51 | end 52 | end 53 | end 54 | -------------------------------------------------------------------------------- /spec/orion/dsl/match_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::MatchSpec 4 | router SampleRouter do 5 | match "/callable", ->(c : Context) { c.response.print "callable match" } 6 | match "/block" do |c| 7 | c.response.print "block match" 8 | end 9 | match "/string" do |c| 10 | "im a string" 11 | end 12 | match "/to-match", to: "samples#to_match" 13 | match "/match-action", controller: SamplesController, action: action_match, helper: "sample_verbose" 14 | end 15 | 16 | class SamplesController < SampleRouter::BaseController 17 | def to_match 18 | response.print "to match" 19 | end 20 | 21 | def match 22 | response.print "controller match" 23 | end 24 | 25 | def action_match 26 | response.print "action match" 27 | end 28 | end 29 | 30 | {% for method in ::Orion::DSL::RequestMethods::METHODS %} 31 | describe {{ method.downcase }} do 32 | context "with callable" do 33 | it "should succeed" do 34 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/callable") 35 | response.status_code.should eq 200 36 | response.body.should eq "callable match" 37 | end 38 | end 39 | 40 | context "with a block" do 41 | it "should succeed" do 42 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/block") 43 | response.status_code.should eq 200 44 | response.body.should eq "block match" 45 | end 46 | end 47 | 48 | context "with a string return" do 49 | it "should succeed" do 50 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/string") 51 | response.status_code.should eq 200 52 | response.body.should eq "im a string\n" 53 | end 54 | end 55 | 56 | context "with to" do 57 | it "should succeed" do 58 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/to-match") 59 | response.status_code.should eq 200 60 | response.body.should eq "to match" 61 | end 62 | end 63 | 64 | context "with controller and action" do 65 | it "should succeed" do 66 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/match-action") 67 | response.status_code.should eq 200 68 | response.body.should eq "action match" 69 | end 70 | end 71 | end 72 | {% end %} 73 | end 74 | -------------------------------------------------------------------------------- /spec/orion/dsl/methods_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::MethodsSpec 4 | {% for method in ::Orion::DSL::RequestMethods::METHODS %} 5 | module {{ method.capitalize.id }} 6 | router SampleRouter do 7 | {{ method.downcase.id }} "/callable", ->(c : Context){ c.response.print "callable {{ method.downcase.id }}" } 8 | {{ method.downcase.id }} "/block", helper: "block" do |c| 9 | c.response.print "block {{ method.downcase.id }}" 10 | end 11 | {{ method.downcase.id }} "/to-{{ method.downcase.id }}", to: "samples#to_{{ method.downcase.id }}" 12 | {{ method.downcase.id }} "/{{ method.downcase.id }}-action", controller: SamplesController, action: action_{{ method.downcase.id }}, helper: "sample_verbose" 13 | end 14 | 15 | class SamplesController < SampleRouter::BaseController 16 | def to_{{ method.downcase.id }} 17 | response.print "to {{ method.downcase.id }}" 18 | end 19 | 20 | def {{ method.downcase.id }} 21 | response.print "controller {{ method.downcase.id }}" 22 | end 23 | 24 | def action_{{ method.downcase.id }} 25 | response.print "action {{ method.downcase.id }}" 26 | end 27 | end 28 | 29 | describe {{ method.downcase }} do 30 | context "with callable" do 31 | it "should succeed" do 32 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/callable") 33 | response.status_code.should eq 200 34 | response.body.should eq "callable {{ method.downcase.id }}" 35 | end 36 | end 37 | 38 | context "with a block" do 39 | it "should succeed" do 40 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/block") 41 | response.status_code.should eq 200 42 | response.body.should eq "block {{ method.downcase.id }}" 43 | end 44 | end 45 | 46 | context "with to" do 47 | it "should succeed" do 48 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/to-{{ method.downcase.id }}") 49 | response.status_code.should eq 200 50 | response.body.should eq "to {{ method.downcase.id }}" 51 | end 52 | end 53 | 54 | context "with controller and action" do 55 | it "should succeed" do 56 | response = test_route(SampleRouter.new, :{{ method.downcase.id }}, "/{{ method.downcase.id }}-action") 57 | response.status_code.should eq 200 58 | response.body.should eq "action {{ method.downcase.id }}" 59 | end 60 | end 61 | end 62 | end 63 | {% end %} 64 | end 65 | -------------------------------------------------------------------------------- /spec/orion/dsl/resources_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::Resources::Spec 4 | router SampleRouter do 5 | resources :users do 6 | get "profile", action: profile 7 | end 8 | 9 | resources :users_constrained, controller: UsersController, id_constraint: /^\d{4}$/, id_param: :user_id 10 | resources :users_api, controller: UsersController, id_param: :user_id, format: "json" 11 | resources :users_api_2, controller: UsersController, id_param: :user_id, accept: "application/json" 12 | 13 | resource :person do 14 | get "profile", action: profile 15 | end 16 | resource :person_api, controller: PersonController, format: "json" 17 | resource :person_api_2, controller: PersonController, accept: "application/json" 18 | end 19 | 20 | class UsersController < SampleRouter::BaseController 21 | def profile 22 | response.print "profile #{request.path_params["user_id"]}" 23 | end 24 | 25 | def index 26 | response.print "index" 27 | end 28 | 29 | def new 30 | response.print "new" 31 | end 32 | 33 | def create 34 | response.print "create" 35 | end 36 | 37 | def show 38 | response.print "show #{request.path_params["user_id"]}" 39 | end 40 | 41 | def edit 42 | response.print "edit #{request.path_params["user_id"]}" 43 | end 44 | 45 | def update 46 | response.print "update #{request.path_params["user_id"]}" 47 | end 48 | 49 | def delete 50 | response.print "delete #{request.path_params["user_id"]}" 51 | end 52 | end 53 | 54 | class PersonController < SampleRouter::BaseController 55 | def profile 56 | response.print "profile" 57 | end 58 | 59 | def new 60 | response.print "new" 61 | end 62 | 63 | def create 64 | response.print "create" 65 | end 66 | 67 | def show 68 | response.print "show" 69 | end 70 | 71 | def edit 72 | response.print "edit" 73 | end 74 | 75 | def update 76 | response.print "update" 77 | end 78 | 79 | def delete 80 | response.print "delete" 81 | end 82 | end 83 | 84 | describe ".resources" do 85 | it "should return the index action" do 86 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.users_path) 87 | response.status_code.should eq 200 88 | response.body.should eq "index" 89 | end 90 | 91 | it "should return the new action" do 92 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.new_user_path) 93 | response.status_code.should eq 200 94 | response.body.should eq "new" 95 | end 96 | 97 | it "should return the create action" do 98 | response = test_route(SampleRouter.new, :post, SampleRouter::RouteHelpers.users_path) 99 | response.status_code.should eq 200 100 | response.body.should eq "create" 101 | end 102 | 103 | it "should return the show action" do 104 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.user_path user_id: 1) 105 | response.status_code.should eq 200 106 | response.body.should eq "show 1" 107 | end 108 | 109 | it "should return the edit action" do 110 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.edit_user_path user_id: 1) 111 | response.status_code.should eq 200 112 | response.body.should eq "edit 1" 113 | end 114 | 115 | it "should return the update action" do 116 | response = test_route(SampleRouter.new, :put, SampleRouter::RouteHelpers.user_path user_id: 1) 117 | response.status_code.should eq 200 118 | response.body.should eq "update 1" 119 | end 120 | 121 | it "should return the update action" do 122 | response = test_route(SampleRouter.new, :patch, SampleRouter::RouteHelpers.user_path user_id: 1) 123 | response.status_code.should eq 200 124 | response.body.should eq "update 1" 125 | end 126 | 127 | it "should return the update action" do 128 | response = test_route(SampleRouter.new, :delete, SampleRouter::RouteHelpers.user_path user_id: 1) 129 | response.status_code.should eq 200 130 | response.body.should eq "delete 1" 131 | end 132 | 133 | it "should return the profile action" do 134 | response = test_route(SampleRouter.new, :get, "users/1/profile") 135 | response.status_code.should eq 200 136 | response.body.should eq "profile 1" 137 | end 138 | 139 | context "with an id constraint" do 140 | it "should return 200 when matched" do 141 | response = test_route(SampleRouter.new, :get, "users_constrained/9999") 142 | response.status_code.should eq 200 143 | response.body.should eq "show 9999" 144 | end 145 | 146 | it "should return 404 when not matched" do 147 | response = test_route(SampleRouter.new, :get, "users_constrained/9") 148 | response.status_code.should eq 404 149 | end 150 | end 151 | 152 | context "with a format constraint" do 153 | it "should return 200 when matched" do 154 | response = test_route(SampleRouter.new, :get, "users_api/1.json") 155 | response.status_code.should eq 200 156 | response.body.should eq "show 1" 157 | end 158 | 159 | it "should return 404 when not matched" do 160 | response = test_route(SampleRouter.new, :get, "users_api/1") 161 | response.status_code.should eq 404 162 | end 163 | end 164 | 165 | context "with an accept constraint" do 166 | it "should return 200 when matched with format" do 167 | response = test_route(SampleRouter.new, :get, "users_api_2/1.json") 168 | response.status_code.should eq 200 169 | response.body.should eq "show 1" 170 | end 171 | 172 | it "should return 200 when matched with header" do 173 | response = test_route(SampleRouter.new, :get, "users_api_2/1", headers: {"Accept" => "application/json"}) 174 | response.status_code.should eq 200 175 | response.body.should eq "show 1" 176 | end 177 | 178 | it "should return 404 when not matched" do 179 | response = test_route(SampleRouter.new, :get, "users_api_2/1", headers: {"Accept" => "text/html"}) 180 | response.status_code.should eq 404 181 | end 182 | end 183 | end 184 | 185 | describe ".resource" do 186 | it "should return the new action" do 187 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.new_person_path) 188 | response.status_code.should eq 200 189 | response.body.should eq "new" 190 | end 191 | 192 | it "should return the create action" do 193 | response = test_route(SampleRouter.new, :post, SampleRouter::RouteHelpers.person_path) 194 | response.status_code.should eq 200 195 | response.body.should eq "create" 196 | end 197 | 198 | it "should return the show action" do 199 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.person_path) 200 | response.status_code.should eq 200 201 | response.body.should eq "show" 202 | end 203 | 204 | it "should return the edit action" do 205 | response = test_route(SampleRouter.new, :get, SampleRouter::RouteHelpers.edit_person_path) 206 | response.status_code.should eq 200 207 | response.body.should eq "edit" 208 | end 209 | 210 | it "should return the update action" do 211 | response = test_route(SampleRouter.new, :put, SampleRouter::RouteHelpers.person_path) 212 | response.status_code.should eq 200 213 | response.body.should eq "update" 214 | end 215 | 216 | it "should return the update action" do 217 | response = test_route(SampleRouter.new, :patch, SampleRouter::RouteHelpers.person_path) 218 | response.status_code.should eq 200 219 | response.body.should eq "update" 220 | end 221 | 222 | it "should return the update action" do 223 | response = test_route(SampleRouter.new, :delete, SampleRouter::RouteHelpers.person_path) 224 | response.status_code.should eq 200 225 | response.body.should eq "delete" 226 | end 227 | 228 | it "should return the profile action" do 229 | response = test_route(SampleRouter.new, :get, "person/profile") 230 | response.status_code.should eq 200 231 | response.body.should eq "profile" 232 | end 233 | 234 | context "with a format constraint" do 235 | it "should return 200 when matched" do 236 | response = test_route(SampleRouter.new, :get, "person_api.json") 237 | response.status_code.should eq 200 238 | response.body.should eq "show" 239 | end 240 | 241 | it "should return 404 when not matched" do 242 | response = test_route(SampleRouter.new, :get, "person_api") 243 | response.status_code.should eq 404 244 | end 245 | end 246 | 247 | context "with an accept constraint" do 248 | it "should return 200 when matched with format" do 249 | response = test_route(SampleRouter.new, :get, "person_api_2.json") 250 | response.status_code.should eq 200 251 | response.body.should eq "show" 252 | end 253 | 254 | it "should return 200 when matched with header" do 255 | response = test_route(SampleRouter.new, :get, "person_api_2", headers: {"Accept" => "application/json"}) 256 | response.status_code.should eq 200 257 | response.body.should eq "show" 258 | end 259 | 260 | it "should return 404 when not matched" do 261 | response = test_route(SampleRouter.new, :get, "person_api_2", headers: {"Accept" => "text/html"}) 262 | response.status_code.should eq 404 263 | end 264 | end 265 | end 266 | end 267 | -------------------------------------------------------------------------------- /spec/orion/dsl/scope_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::ScopeSpec 4 | router SampleRouter do 5 | get "home", ->(c : Context) { c.response.print c.request.base_path } 6 | scope "messages" do 7 | get "new", ->(c : Context) { c.response.print c.request.base_path } 8 | end 9 | end 10 | 11 | describe "scope" do 12 | context "out of scope" do 13 | it "should have the default base path" do 14 | response = test_route(SampleRouter.new, :get, "/home") 15 | response.status_code.should eq 200 16 | response.body.should eq "/" 17 | end 18 | end 19 | 20 | context "within scope" do 21 | it "should set the base path" do 22 | response = test_route(SampleRouter.new, :get, "/messages/new") 23 | response.status_code.should eq 200 24 | response.body.should eq "/messages" 25 | end 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /spec/orion/dsl/websockets_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | module Orion::DSL::WebSocketsSpec 4 | router SampleRouter do 5 | ws "/match", ->(ws : WebSocket, c : Context) { 6 | ws.send("Match") 7 | } 8 | get "/match", ->(c : Context) { 9 | c.response.print("Match Non WS") 10 | } 11 | end 12 | 13 | describe "ws" do 14 | it "matches on given route" do 15 | io, response = test_ws(SampleRouter.new, "/match") 16 | io.to_s.should eq("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n\x81\u0005Match") 17 | end 18 | 19 | it "returns 404 for an unmatched route" do 20 | io, response = test_ws(SampleRouter.new, "/no_match") 21 | response.status_code.should eq(404) 22 | end 23 | 24 | it "should allow a non ws request to coexist" do 25 | response = test_route(SampleRouter.new, :get, "/match") 26 | response.status_code.should eq 200 27 | response.body.should eq "Match Non WS" 28 | end 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /spec/orion/handlers/method_override_param_spec.cr: -------------------------------------------------------------------------------- 1 | require "../../spec_helper" 2 | 3 | describe Orion::Handlers::MethodOverrideParam do 4 | context "given a query param" do 5 | it "should set override the method" do 6 | context = mock_context(:get, "/?_method=POST") 7 | Orion::Handlers::MethodOverrideParam.new.call(context) 8 | context.request.method.should eq "POST" 9 | end 10 | end 11 | 12 | context "given a form param" do 13 | it "should set override the method" do 14 | io = IO::Memory.new 15 | builder = HTTP::FormData::Builder.new(io) 16 | builder.field("_method", "POST") 17 | builder.finish 18 | io.rewind 19 | context = mock_context(:get, "/", body: io, headers: {"Content-Type" => "multipart/form-data; boundary=\"#{builder.boundary}\""}) 20 | Orion::Handlers::MethodOverrideParam.new.call(context) 21 | context.request.method.should eq "POST" 22 | end 23 | end 24 | end 25 | -------------------------------------------------------------------------------- /spec/orion/router_spec.cr: -------------------------------------------------------------------------------- 1 | require "../spec_helper" 2 | 3 | params = {} of String => String 4 | 5 | module RouterSpec 6 | router Router do 7 | static path: "/assets", dir: "./spec/fixtures" 8 | root ->(c : Context) { c.response.print "I am Groot" } 9 | root to: "sample#action" 10 | root to: "Sample#action" 11 | root controller: SampleController, action: action 12 | root do |c| 13 | params = c.request.path_params 14 | end 15 | get "/:first/:second", ->(c : Context) { params = c.request.path_params } 16 | get "/:first/:second", to: "sample#action" 17 | get "/:first/:second", to: "Sample#action" 18 | get "/:first/:second", to: "Sample#action" 19 | get "/:first/:second", controller: SampleController, action: action 20 | get "/:first/:second" do |c| 21 | params = c.request.path_params 22 | end 23 | head "/:first/:second", ->(c : Context) { params = c.request.path_params } 24 | head "/:first/:second", to: "sample#action" 25 | head "/:first/:second", to: "Sample#action" 26 | head "/:first/:second", controller: SampleController, action: action 27 | head "/:first/:second" do |c| 28 | params = c.request.path_params 29 | end 30 | post "/:first/:second", ->(c : Context) { params = c.request.path_params } 31 | post "/:first/:second", to: "sample#action" 32 | post "/:first/:second", to: "Sample#action" 33 | post "/:first/:second", controller: SampleController, action: action 34 | post "/:first/:second" do |c| 35 | params = c.request.path_params 36 | end 37 | put "/:first/:second", ->(c : Context) { params = c.request.path_params } 38 | put "/:first/:second", to: "sample#action" 39 | put "/:first/:second", to: "Sample#action" 40 | put "/:first/:second", controller: SampleController, action: action 41 | put "/:first/:second" do |c| 42 | params = c.request.path_params 43 | end 44 | delete "/:first/:second", ->(c : Context) { params = c.request.path_params } 45 | delete "/:first/:second", to: "sample#action" 46 | delete "/:first/:second", to: "Sample#action" 47 | delete "/:first/:second", controller: SampleController, action: action 48 | delete "/:first/:second" do |c| 49 | params = c.request.path_params 50 | end 51 | connect "/:first/:second", ->(c : Context) { params = c.request.path_params } 52 | connect "/:first/:second", to: "sample#action" 53 | connect "/:first/:second", to: "Sample#action" 54 | connect "/:first/:second", controller: SampleController, action: action 55 | connect "/:first/:second" do |c| 56 | params = c.request.path_params 57 | end 58 | options "/:first/:second", ->(c : Context) { params = c.request.path_params } 59 | options "/:first/:second", to: "sample#action" 60 | options "/:first/:second", to: "Sample#action" 61 | options "/:first/:second", controller: SampleController, action: action 62 | options "/:first/:second" do |c| 63 | params = c.request.path_params 64 | end 65 | trace "/:first/:second", ->(c : Context) { params = c.request.path_params } 66 | trace "/:first/:second", to: "sample#action" 67 | trace "/:first/:second", to: "Sample#action" 68 | trace "/:first/:second", controller: SampleController, action: action 69 | trace "/:first/:second" do |c| 70 | params = c.request.path_params 71 | end 72 | patch "/:first/:second", ->(c : Context) { params = c.request.path_params } 73 | patch "/:first/:second", to: "sample#action" 74 | patch "/:first/:second", to: "Sample#action" 75 | patch "/:first/:second", controller: SampleController, action: action 76 | patch "/:first/:second" do |c| 77 | params = c.request.path_params 78 | end 79 | match "/:first/:second", ->(c : Context) { params = c.request.path_params } 80 | match "/:first/:second", to: "sample#action" 81 | match "/:first/:second", to: "Sample#action" 82 | match "/:first/:second", controller: SampleController, action: action 83 | match "/:first/:second" do |c| 84 | params = c.request.path_params 85 | end 86 | put "/hello", ->(c : Context) { c.response.print "I put things" } 87 | ws "/socket", ->(ws : WebSocket, c : Context) { 88 | ws.send "hello world" 89 | } 90 | ws "/:first/:second", to: "sample#action" 91 | ws "/:first/:second", to: "Sample#action" 92 | ws "/:first/:second", controller: SampleController, action: socket_action 93 | ws "/:first/:second" do |ws, req| 94 | ws.send "hello world" 95 | end 96 | end 97 | 98 | class SampleController < Router::BaseController 99 | def action 100 | params = request.path_params 101 | end 102 | 103 | def socket_action 104 | websocket.send "Hello World" 105 | end 106 | end 107 | 108 | describe "a basic router" do 109 | it "should run a basic route" do 110 | response = test_route(Router.new, :get, Router::RouteHelpers.root_path) 111 | response.status_code.should eq 200 112 | response.body.should eq "I am Groot" 113 | end 114 | 115 | it "should parse params" do 116 | response = test_route(Router.new, :get, "/foo/bar") 117 | response.status_code.should eq 200 118 | params["first"].should eq "foo" 119 | params["second"].should eq "bar" 120 | end 121 | end 122 | 123 | describe "method override header" do 124 | it "should override the header" do 125 | response = test_route(Router.new, :get, "/hello", headers: {"X-Method-Override" => "PUT"}) 126 | response.status_code.should eq 200 127 | response.body.should eq "I put things" 128 | end 129 | end 130 | 131 | describe "missing route" do 132 | it "should return 404" do 133 | response = test_route(Router.new, :get, "/missing") 134 | response.status_code.should eq 404 135 | end 136 | end 137 | end 138 | -------------------------------------------------------------------------------- /spec/spec_helper.cr: -------------------------------------------------------------------------------- 1 | require "../src/orion" 2 | require "spec" 3 | 4 | def mock_context(method, path, host = "example.org", *, headers = {} of String => String, io = IO::Memory.new, body = nil) 5 | http_headers = HTTP::Headers.new 6 | headers.each { |k, v| http_headers[k] = v } 7 | http_headers["HOST"] = host 8 | request = Orion::Server::Request.new(method.to_s.upcase, path, http_headers) 9 | request.body = body 10 | response = Orion::Server::Response.new io 11 | Orion::Server::Context.new(request, response) 12 | end 13 | 14 | def test_route(router : Orion::Router, method, path, *, headers = {} of String => String, body = nil) 15 | io = IO::Memory.new 16 | context = mock_context(method, path, headers: headers, io: io, body: body) 17 | router.call(context) 18 | HTTP::Client::Response.from_io io.tap(&.rewind) 19 | end 20 | 21 | def test_ws(router : Orion::Router, path, host = "example.org") 22 | input_io = IO::Memory.new 23 | output_io = IO::Memory.new 24 | context = mock_context("GET", path, host, headers: { 25 | "Upgrade" => "websocket", 26 | "Connection" => "Upgrade", 27 | "Sec-WebSocket-Key" => "dGhlIHNhbXBsZSBub25jZQ==", 28 | "Sec-WebSocket-Version" => "13", 29 | }, io: output_io) 30 | context.request.to_io(input_io) 31 | begin 32 | router.processor.process(input_io.tap(&.rewind), output_io) 33 | rescue IO::Error 34 | # Raises because the IO:: Memory is empty 35 | end 36 | response = HTTP::Client::Response.from_io output_io.tap(&.rewind) 37 | {output_io, response} 38 | end 39 | -------------------------------------------------------------------------------- /src/app.cr: -------------------------------------------------------------------------------- 1 | require "./orion" 2 | include Orion::DSL 3 | -------------------------------------------------------------------------------- /src/http.cr: -------------------------------------------------------------------------------- 1 | require "http" 2 | require "./http/*" 3 | -------------------------------------------------------------------------------- /src/http/request.cr: -------------------------------------------------------------------------------- 1 | class HTTP::Request 2 | # :nodoc: 3 | setter path_params : Hash(String, String)? 4 | property base_path : String = "/" 5 | property action : Orion::Action? 6 | 7 | # Returns the list of path params set by an Orion route. 8 | def path_params 9 | @path_params ||= {} of String => String 10 | end 11 | 12 | # The format of the http request 13 | def format 14 | formats.first 15 | end 16 | 17 | # The formats of the http request 18 | def formats 19 | Orion::MIMEHelper.request_extensions(self).tap do |set| 20 | set << File.extname(resource) 21 | end 22 | end 23 | end 24 | -------------------------------------------------------------------------------- /src/macro.cr: -------------------------------------------------------------------------------- 1 | # Define a new router 2 | macro router(name) 3 | module {{ name }} 4 | include Orion::DSL 5 | 6 | {{ yield }} 7 | end 8 | end 9 | -------------------------------------------------------------------------------- /src/orion.cr: -------------------------------------------------------------------------------- 1 | require "oak" 2 | require "kilt" 3 | require "./http" 4 | require "./macro" 5 | require "./orion/*" 6 | 7 | module Orion 8 | # :nodoc: 9 | FLAGS = {} of String => Bool 10 | 11 | alias Logger = Handlers::Logger 12 | 13 | {{ run "./parse_version.cr" }} 14 | end 15 | -------------------------------------------------------------------------------- /src/orion/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # 4.0.0 2 | 3 | ## New Features 4 | 5 | * A new view system allows for users to render views and partials while maintaining a layer of security between the view and controller. 6 | * View helpers allow you do define helpers via a module or block to extend methods into your view layer. 7 | * Built in view helpers. 8 | * Statically served assets created with the `static` macro are now bundled with the binary in release mode and are unpacked when the server starts. 9 | 10 | 11 | ## Breaking Changes 12 | 13 | * Views are no longer rendered inline within the controller. Local variable access and instance variables must be passed as a named tuple to the `locals` key on the render method and accessed via `locals[:foo]` within the view. 14 | 15 | ## Bug Fixes 16 | 17 | * Servers created with `require orion/app` were not getting their entire user defined config before booting up. This is now fixed. 18 | 19 | # 3.1.0 20 | 21 | 22 | 23 | ## New Features 24 | 25 | ## Breaking Changes 26 | 27 | ## Bug Fixes 28 | 29 | # 3.0.0 30 | 31 | ## New Features 32 | 33 | ## Breaking Changes 34 | 35 | ## Bug Fixes -------------------------------------------------------------------------------- /src/orion/action.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::Action 3 | getter helper : String? 4 | getter constraints = [] of Constraint 5 | @proc : Handler::HandlerProc 6 | @pipeline : Orion::Pipeline 7 | 8 | def initialize(@proc : Handler::HandlerProc, *, handlers = [] of ::HTTP::Handler, constraints = [] of Constraint, @helper = nil) 9 | @constraints = constraints.dup 10 | @pipeline = Pipeline.new(handlers) 11 | end 12 | 13 | def invoke(c) 14 | @proc.call(c) 15 | end 16 | 17 | def call(c) 18 | c.request.action = self 19 | @pipeline.call(c) 20 | end 21 | 22 | def matches_constraints?(request : ::HTTP::Request) 23 | constraints.all? &.matches?(request) 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /src/orion/assets.cr: -------------------------------------------------------------------------------- 1 | require "uuid" 2 | 3 | module Assets 4 | def self.unpack(pack) 5 | File.join(Dir.tempdir, "orion", "pack", UUID.random.to_s).tap do |dir| 6 | io = IO::Memory.new 7 | Base64.decode(pack, io) 8 | Compress::Gzip::Reader.open(io.rewind) do |gzip| 9 | Crystar::Reader.open(gzip) do |tar| 10 | tar.each_entry do |entry| 11 | filename = File.join(dir, entry.name) 12 | Dir.mkdir_p(File.dirname(filename)) 13 | File.open filename, "w+" do |file| 14 | IO.copy entry.io, file 15 | end 16 | end 17 | end 18 | end 19 | end 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /src/orion/assets/pack.cr: -------------------------------------------------------------------------------- 1 | require "crystar" 2 | require "compress/gzip" 3 | dir = ARGV[0] 4 | 5 | io = IO::Memory.new 6 | Compress::Gzip::Writer.open(io, level: Compress::Gzip::BEST_COMPRESSION) do |gzip| 7 | Crystar::Writer.open(gzip) do |tar| 8 | Dir.glob(File.join(dir, "**", "*"), match_hidden: true).each do |filename| 9 | File.open(filename) do |file| 10 | hdr = Crystar.file_info_header(file, file.path) 11 | hdr.name = filename 12 | tar.write_header hdr 13 | tar.write file.gets_to_end.to_slice 14 | end unless File.directory? filename 15 | end 16 | end 17 | end 18 | Base64.encode(io).split("\n").join.inspect(STDOUT) 19 | -------------------------------------------------------------------------------- /src/orion/cache.cr: -------------------------------------------------------------------------------- 1 | require "cache" 2 | 3 | class Orion::Cache 4 | @store : ::Cache::Store(String, String) 5 | 6 | def initialize(@store = ::Cache::NullStore(String, String).new(expires_in: 0.seconds)) 7 | end 8 | 9 | delegate read, write, fetch, delete, clear, to: @store 10 | 11 | # Read an item from cache 12 | def read(keyable : Keyable) 13 | read(keyable.cache_key) 14 | end 15 | 16 | # Write an item to cache 17 | def write(keyable : Keyable, value) 18 | write(keyable.cache_key, value) 19 | end 20 | 21 | # Read the item from cache, if it doesn't exist, invoke the block 22 | def fetch(key : Keyable, &block) 23 | fetch(keyable.cache_key, &block) 24 | end 25 | 26 | # If the conition is true invoke `fetch` 27 | def fetch_if(condition, key, &block) 28 | condition ? fetch(key, &block) : yield 29 | end 30 | 31 | # Delete the item from cache 32 | def delete(keyable : Keyable, value) 33 | delete(keyable.cache_key, value) 34 | end 35 | end 36 | 37 | require "./cache/*" 38 | -------------------------------------------------------------------------------- /src/orion/cache/keyable.cr: -------------------------------------------------------------------------------- 1 | module Orion::Cache::Keyable 2 | macro define_cache_key(*keys) 3 | def cache_key : String 4 | {{ keys.map(&.id) }}.join("-") 5 | end 6 | end 7 | 8 | abstract def cache_key : String 9 | end 10 | -------------------------------------------------------------------------------- /src/orion/config.cr: -------------------------------------------------------------------------------- 1 | require "socket" 2 | require "openssl" 3 | 4 | # These are the options available when setting properties with the `config` 5 | # method within your application. 6 | class Orion::Config 7 | struct ReadOnly 8 | getter port : Int32? 9 | getter address : ::Socket::IPAddress | ::Socket::UNIXAddress | Nil 10 | getter host : String? 11 | getter path : String? 12 | getter name : String 13 | getter uri : URI? 14 | getter workers : Int32 | Int64 15 | getter asset_host : String? 16 | getter cache : Orion::Cache 17 | getter logger : Log? 18 | 19 | def initialize(config : Orion::Config) 20 | @port = config.port 21 | @address = config.address 22 | @host = config.host 23 | @path = config.path 24 | @name = config.name 25 | @uri = config.uri 26 | @workers = config.workers 27 | @asset_host = config.asset_host 28 | @cache = config.cache 29 | @logger = config.logger 30 | end 31 | end 32 | 33 | setter port : Int32? = 4000 34 | setter address : ::Socket::IPAddress | ::Socket::UNIXAddress | Nil 35 | setter host : String = ::Socket::IPAddress::LOOPBACK 36 | setter path : String? 37 | 38 | property name : String = File.basename Dir.current 39 | property socket : ::Socket::Server? 40 | property tls : ::OpenSSL::SSL::Context::Server? 41 | property reuse_port : Bool = false 42 | property autoclose : Bool = true 43 | property strip_extension : Bool = false 44 | property workers : Int32 | Int64 = 1 45 | property asset_host : String? = nil 46 | property cache : Orion::Cache = Orion::Cache.new 47 | property logger : Log? = Log.for(Orion) 48 | 49 | def port=(port : String) 50 | self.port = port.to_i32 51 | end 52 | 53 | def port=(port : Nil) 54 | end 55 | 56 | def uri=(uri : String) 57 | self.uri = URI.parse(uri) 58 | end 59 | 60 | def uri=(uri : URI) 61 | case uri.scheme 62 | when "tcp" 63 | self.address = Socket::IPAddress.parse(uri) 64 | when "unix" 65 | self.address = Socket::UNIXAddress.parse(uri) 66 | when "tls" 67 | self.address = Socket::IPAddress.parse(uri) 68 | self.tls = OpenSSL::SSL::Context::Server.from_hash(HTTP::Params.parse(uri.query || "")) 69 | else 70 | raise ArgumentError.new "Unsupported socket type: #{uri.scheme}" 71 | end 72 | end 73 | 74 | def uri 75 | case {address = self.address, tls = self.tls} 76 | when {::Socket::IPAddress, ::OpenSSL::SSL::Context::Server} 77 | URI.new(scheme: "tls", host: address.address, port: address.port) 78 | when {::Socket::IPAddress, Nil} 79 | URI.new(scheme: "tcp", host: address.address, port: address.port) 80 | when {::Socket::UNIXAddress, _} 81 | URI.new(scheme: "unix", path: address.path) 82 | else 83 | nil 84 | end 85 | end 86 | 87 | def host 88 | case (address = @address) 89 | when ::Socket::IPAddress 90 | address.address 91 | when ::Socket::UNIXAddress 92 | nil 93 | else 94 | @host 95 | end 96 | end 97 | 98 | def port 99 | case (address = @address) 100 | when ::Socket::IPAddress 101 | address.port 102 | when ::Socket::UNIXAddress 103 | nil 104 | else 105 | @port 106 | end 107 | end 108 | 109 | def path 110 | case (address = @address) 111 | when ::Socket::UNIXAddress 112 | address.path 113 | when ::Socket::IPAddress 114 | nil 115 | else 116 | @path 117 | end 118 | end 119 | 120 | def address 121 | address = @address 122 | host = @host 123 | port = @port 124 | path = @path 125 | return address if address 126 | return ::Socket::IPAddress.new(host, port) if host && port 127 | return ::Socket::UNIXAddress.new(path) if path 128 | end 129 | 130 | def readonly 131 | ReadOnly.new self 132 | end 133 | end 134 | -------------------------------------------------------------------------------- /src/orion/constraint.cr: -------------------------------------------------------------------------------- 1 | # Include `Orion::Constraint` module and implment it's required methods to 2 | # create custom constraints. You can read more about constraints in 3 | # `Orion::DSL::Constraints`. 4 | module Orion::Constraint 5 | abstract def matches?(request : HTTP::Request) 6 | end 7 | 8 | require "./constraints/*" 9 | -------------------------------------------------------------------------------- /src/orion/constraints/accept_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::AcceptConstraint 3 | include Constraint 4 | 5 | def initialize(@accept : String | Array(String)) 6 | end 7 | 8 | def matches?(request : ::HTTP::Request) 9 | return false unless request.headers["Accept"]? 10 | type_for_accept(request).any? do |mime_type| 11 | matches?(mime_type, @accept) 12 | end 13 | end 14 | 15 | private def matches?(mime_type : String, string : String) 16 | mime_parts = mime_type.split("/") 17 | match_parts = string.split("/") 18 | category_matches = mime_parts[0] === match_parts[0] || mime_parts[0] === "*" || match_parts[0] === "*" 19 | format_matches = mime_parts[1] === match_parts[1] || mime_parts[1] === "*" || match_parts[1] === "*" 20 | category_matches && format_matches 21 | end 22 | 23 | private def matches?(mime_type : String, strings : Array(String)) 24 | strings.any? do |string| 25 | matches?(mime_type, string) 26 | end 27 | end 28 | 29 | private def type_for_accept(request : HTTP::Request) 30 | request.headers["accept"]?.to_s.split(",").map(&.strip).map do |accept| 31 | accept.split(";").map(&.strip) 32 | end.sort_by do |parts| 33 | part = parts[1..-1].find { |p| p.starts_with? "q=" } 34 | part ? -part.split("=")[-1].strip.to_f : -1 35 | end.map(&.[0]).map do |content_type| 36 | content_type 37 | end 38 | end 39 | end 40 | -------------------------------------------------------------------------------- /src/orion/constraints/content_type_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::ContentTypeConstraint 3 | include Constraint 4 | 5 | def initialize(@content_type : String | Array(String)) 6 | end 7 | 8 | def matches?(request : ::HTTP::Request) 9 | return true unless request.body 10 | return false unless request.headers["Content-Type"]? 11 | matches?(type_for_request(request), @content_type) 12 | end 13 | 14 | private def matches?(mime_type : String, string : String) 15 | mime_type == string 16 | end 17 | 18 | private def matches?(mime_type : String, strings : Array(String)) 19 | strings.any? do |string| 20 | matches?(mime_type, string) 21 | end 22 | end 23 | 24 | def type_for_request(request : HTTP::Request) 25 | content_type = request.headers["content-type"]?.to_s.split(';').first 26 | end 27 | end 28 | -------------------------------------------------------------------------------- /src/orion/constraints/format_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::FormatConstraint 3 | include Constraint 4 | 5 | def initialize(@format : String | Regex | Array(String)) 6 | end 7 | 8 | def matches?(request : ::HTTP::Request) 9 | extension = File.extname(request.path).lchop(".") 10 | matches?(extension, @format) 11 | end 12 | 13 | private def matches?(extension : String, string : String) 14 | extension == string.lchop(".") 15 | end 16 | 17 | private def matches?(extension : String, regex : Regex) 18 | extension =~ regex 19 | end 20 | 21 | private def matches?(extension : String, strings : Array(String)) 22 | strings.any? do |string| 23 | matches?(extension, string) 24 | end 25 | end 26 | end 27 | -------------------------------------------------------------------------------- /src/orion/constraints/hash_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | module Orion::HashConstraint(T) 3 | include Constraint 4 | 5 | def initialize(constraints : Hash(Symbol, T)) 6 | hash = constraints.each_with_object({} of String => T) do |(key, value), hash| 7 | hash[key.to_s] = value 8 | end 9 | initialize(hash) 10 | end 11 | 12 | def initialize(constraints : Hash(String, T)) 13 | @constraints = constraints 14 | end 15 | end 16 | -------------------------------------------------------------------------------- /src/orion/constraints/host_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::HostConstraint 3 | include Constraint 4 | 5 | def initialize(@constraint : String | Regex) 6 | end 7 | 8 | def matches?(request : ::HTTP::Request) 9 | if host = request.hostname 10 | matches? host, @constraint 11 | end 12 | end 13 | 14 | private def matches?(host : String, string : String) 15 | host == string 16 | end 17 | 18 | private def matches?(host : String, regex : Regex) 19 | host =~ regex 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /src/orion/constraints/methods_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::RequestMethodsConstraint 3 | include Constraint 4 | 5 | @methods : Array(String) 6 | 7 | def initialize(method : String) 8 | initialize([method]) 9 | end 10 | 11 | def initialize(methods : Array(String)) 12 | @methods = methods.map(&.downcase) 13 | end 14 | 15 | def matches?(request : ::HTTP::Request) 16 | return true if request.method.downcase == "*" 17 | @methods.any?(&.== request.method.downcase) 18 | end 19 | end 20 | -------------------------------------------------------------------------------- /src/orion/constraints/params_constraint.cr: -------------------------------------------------------------------------------- 1 | require "./hash_constraint" 2 | 3 | # :nodoc: 4 | struct Orion::ParamsConstraint 5 | include HashConstraint(Regex) 6 | 7 | def matches?(request : ::HTTP::Request) 8 | @constraints.all? do |key, regex| 9 | next true if key.empty? 10 | if value = request.path_params[key]? 11 | regex.match value 12 | end 13 | end 14 | end 15 | end 16 | -------------------------------------------------------------------------------- /src/orion/constraints/subdomain_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::SubdomainConstraint 3 | include Constraint 4 | 5 | def initialize(constraints) 6 | initialize constraints.to_hash 7 | end 8 | 9 | def initialize(@constraint : String | Regex) 10 | end 11 | 12 | def matches?(request : ::HTTP::Request) 13 | host_parts = request.hostname.to_s.split('.') 14 | last_host_part = host_parts.pop 15 | host_parts.pop unless last_host_part = "localhost" 16 | subdomain = host_parts.join('.') 17 | matches? subdomain, @constraint 18 | end 19 | 20 | private def matches?(subdomain : String, string : String) 21 | subdomain == string 22 | end 23 | 24 | private def matches?(subdomain : String, regex : Regex) 25 | subdomain =~ regex 26 | end 27 | end 28 | -------------------------------------------------------------------------------- /src/orion/constraints/web_socket_constraint.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | struct Orion::WebSocketConstraint 3 | include Constraint 4 | 5 | def matches?(request : ::HTTP::Request) 6 | return false unless upgrade = request.headers["Upgrade"]? 7 | return false unless upgrade.compare("websocket", case_insensitive: true) == 0 8 | 9 | request.headers.includes_word?("Connection", "Upgrade") 10 | end 11 | end 12 | -------------------------------------------------------------------------------- /src/orion/controller.cr: -------------------------------------------------------------------------------- 1 | require "./cache" 2 | require "./controller/request_helpers" 3 | require "./controller/response_helpers" 4 | require "./controller/rendering" 5 | 6 | # The `Orion::Controller` module can be included in any struct or class to add 7 | # the various helpers methods to make constructing your application easier. 8 | module Orion::Controller 9 | include Rendering 10 | include RequestHelpers 11 | include ResponseHelpers 12 | include CacheHelpers 13 | 14 | # The http context 15 | getter context : Server::Context 16 | 17 | # The websocket, if the controller was initialized from a `ws` route. 18 | getter! websocket : ::HTTP::WebSocket 19 | 20 | # :nodoc: 21 | def initialize(@context, @websocket = nil) 22 | end 23 | end 24 | 25 | require "./controller/base" 26 | -------------------------------------------------------------------------------- /src/orion/controller/base.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | abstract class Orion::Controller::Base 3 | include Orion::Controller 4 | end 5 | -------------------------------------------------------------------------------- /src/orion/controller/cache_helpers.cr: -------------------------------------------------------------------------------- 1 | module Orion::Controller::CacheHelpers 2 | def cache 3 | @context.config.cache 4 | end 5 | end 6 | -------------------------------------------------------------------------------- /src/orion/controller/rendering.cr: -------------------------------------------------------------------------------- 1 | require "../view" 2 | 3 | # This module handles all rendering inside your controllers. 4 | module Orion::Controller::Rendering 5 | include Orion::View 6 | 7 | # Render json 8 | macro render(*, json) 9 | response.content_type = "application/json" 10 | {{ json }}.to_json(response) 11 | end 12 | 13 | # Render plain text 14 | macro render(*, text, content_type = "text/plain") 15 | response.content_type = "text/plain" 16 | response.puts({{ text }}) 17 | end 18 | 19 | # :nodoc: 20 | def __name__ 21 | self.class.name.underscore 22 | end 23 | end 24 | -------------------------------------------------------------------------------- /src/orion/controller/request_helpers.cr: -------------------------------------------------------------------------------- 1 | module Orion::Controller::RequestHelpers 2 | # The `HTTP::Request` object. 3 | def request 4 | @context.request 5 | end 6 | 7 | # The query params of the `HTTP::Request`. 8 | def query_params 9 | request.query_params 10 | end 11 | 12 | # The path params of the `HTTP::Request` if any routes have named params in the path. 13 | def path_params 14 | request.path_params 15 | end 16 | 17 | # The remote address of the incoming `HTTP::Request`. 18 | def remote_address 19 | request.remote_address 20 | end 21 | 22 | # The resource of the `HTTP::Request`. 23 | def resource 24 | request.resource 25 | end 26 | 27 | # The hostname of the `HTTP::Request`. 28 | def hostname 29 | request.hostname 30 | end 31 | 32 | # The host with port of the `HTTP::Request`. 33 | def host 34 | request.headers["Host"]? 35 | end 36 | 37 | # Format of the `HTTP::Request` 38 | def format 39 | request.format 40 | end 41 | 42 | # Formats of the `HTTP::Request` 43 | def formats 44 | request.formats 45 | end 46 | end 47 | -------------------------------------------------------------------------------- /src/orion/controller/response_helpers.cr: -------------------------------------------------------------------------------- 1 | module Orion::Controller::ResponseHelpers 2 | # The `HTTP:Response`. 3 | def response 4 | @context.response 5 | end 6 | 7 | # Set the status of the response 8 | def status=(status) 9 | response.status = status 10 | end 11 | 12 | # Set the status of the response 13 | def status_code=(status_code) 14 | response.status_code = status_code 15 | end 16 | 17 | # Set the content type of the response 18 | def content_type=(content_type) 19 | response.content_type = content_type 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /src/orion/dsl.cr: -------------------------------------------------------------------------------- 1 | require "./dsl/*" 2 | 3 | # The `Orion::DSL` module contains all the macros and methods that are available 4 | # when creating an Orion application. See the various submodules to see each 5 | # macro and/or method you can invoke when building your app. 6 | module Orion::DSL 7 | # Setup the router 8 | private macro included 9 | module RouteHelpers 10 | extend self 11 | end 12 | 13 | # :nodoc: 14 | ROUTER_INITIALIZED = true 15 | # :nodoc: 16 | BASE_PATH = "/" 17 | # :nodoc: 18 | CONSTRAINTS = [] of ::Orion::Constraint 19 | # :nodoc: 20 | CONCERNS = {} of Symbol => String 21 | # :nodoc: 22 | HANDLERS = [] of HTTP::Handler 23 | # :nodoc: 24 | PREFIXES = [] of String 25 | # :nodoc: 26 | TREE = Tree.new 27 | # :nodoc: 28 | CONTROLLER = BaseController 29 | # :nodoc: 30 | ORION_CONFIG = ::Orion::Config.new 31 | 32 | # Add the controller 33 | class BaseController < Orion::Controller::Base 34 | include RouteHelpers 35 | end 36 | 37 | def self.config 38 | ORION_CONFIG 39 | end 40 | 41 | def self.new(*args, **opts) 42 | ::Orion::Router.new(TREE, *args, **opts) 43 | end 44 | 45 | def self.start 46 | start config: config 47 | end 48 | 49 | def self.start(*args, **opts) 50 | ::Orion::Router.start(TREE, *args, **opts) 51 | end 52 | 53 | include ::Orion::DSL::Macros 54 | 55 | use ::Orion::Handlers::Config.new(ORION_CONFIG) 56 | 57 | macro finished 58 | {% if @type.stringify == "" %} 59 | start unless ::Orion::FLAGS["started"]? 60 | {% end %} 61 | end 62 | end 63 | 64 | # :nodoc: 65 | alias Tree = Oak::Tree(Action) 66 | # :nodoc: 67 | alias Context = ::Orion::Server::Context 68 | # :nodoc: 69 | alias Response = ::Orion::Server::Response 70 | # :nodoc: 71 | alias Request = ::Orion::Server::Request 72 | # :nodoc: 73 | alias WebSocket = HTTP::WebSocket 74 | 75 | # :nodoc: 76 | CONTROLLER = nil 77 | 78 | # :nodoc: 79 | def self.normalize_path(*, base_path : String, path : String) 80 | return base_path if path.empty? 81 | parts = [base_path, path].map(&.to_s) 82 | String.build do |str| 83 | parts.each_with_index do |part, index| 84 | part.check_no_null_byte 85 | 86 | str << "/" if index > 0 87 | 88 | byte_start = 0 89 | byte_count = part.bytesize 90 | 91 | if index > 0 && part.starts_with?("/") 92 | byte_start += 1 93 | byte_count -= 1 94 | end 95 | 96 | if index != parts.size - 1 && part.ends_with?("/") 97 | byte_count -= 1 98 | end 99 | 100 | str.write part.unsafe_byte_slice(byte_start, byte_count) 101 | end 102 | end 103 | end 104 | end 105 | -------------------------------------------------------------------------------- /src/orion/dsl/concerns.cr: -------------------------------------------------------------------------------- 1 | # Concerns allow you to create a pattern or concern that you wish 2 | # 3 | # to repeat across scopes or resources in your router. 4 | # #### Defining a concern 5 | # 6 | # To define a concern call `concern` with a `Symbol` for the name. 7 | # 8 | # ``` 9 | # concern :authenticated do 10 | # use Authentication.new 11 | # end 12 | # ``` 13 | # #### Using concerns 14 | # 15 | # Once a concern is defined you can call `implements` with a named concern from 16 | # anywhere in your router. 17 | # 18 | # ``` 19 | # concern :authenticated do 20 | # use Authentication.new 21 | # end 22 | 23 | # scope "users" do 24 | # implements :authenticated 25 | # get ":id" 26 | # end 27 | # ``` 28 | module Orion::DSL::Concerns 29 | macro concern(name, &block) 30 | {% CONCERNS[name] = block.body.stringify %} 31 | end 32 | 33 | macro implements(*names) 34 | {% for name in names %} 35 | {{ CONCERNS[name].id }} 36 | {% end %} 37 | end 38 | end 39 | -------------------------------------------------------------------------------- /src/orion/dsl/constraints.cr: -------------------------------------------------------------------------------- 1 | # Constraints can be used to further determine if a route is hit beyond just it's path. Routes have some predefined constraints you can specify, but you can also 2 | # pass in a custom constraint. 3 | # 4 | # #### Parameter constraints 5 | # 6 | # When defining a route, you can pass in parameter constraints. The path params will 7 | # be checked against the provided regex before the route is chosen as a valid route. 8 | # 9 | # ``` 10 | # get "users/:id", constraints: {id: /[0-9]{4}/} 11 | # ``` 12 | # 13 | # #### Format constraints 14 | # 15 | # You can constrain the request to a certain format. Such as restricting 16 | # the extension of the URL to '.json'. 17 | # 18 | # ``` 19 | # get "api/users/:id", format: "json" 20 | # ``` 21 | # 22 | # #### Request Mime-Type constraints 23 | # 24 | # You can constrain the request to a certain mime-type by using the `content_type` param 25 | # on the route. This will ensure that if the request has a body, it will provide the proper 26 | # content type. 27 | # 28 | # ``` 29 | # put "api/users/:id", content_type: "application/json" 30 | # ``` 31 | # 32 | # #### Response Mime-Type constraints 33 | # 34 | # You can constrain the response to a certain mime-type by using the `accept` param 35 | # on the route. This is similar to the format constraint but allows clients to 36 | # specify the `Accept` header rather than the extension. 37 | # 38 | # > Orion will automatically add mime-type headers for requests with no Accept header and a specified extension. 39 | # 40 | # ``` 41 | # get "api/users/:id", accept: "application/json" 42 | # ``` 43 | # 44 | # #### Combined Mime-Type constraints 45 | # 46 | # You can constrain the request and response to a certain mime-type by using the `type` param 47 | # on the route. This will ensure that if the request has a body, it will provide the proper 48 | # content type. In addition, it will also validate that the client provides a proper 49 | # accept header for the response. 50 | # 51 | # Orion will automatically add mime-type headers for requests with no Accept header and 52 | # a specified extension. 53 | # 54 | # ``` 55 | # put "api/users/:id", type: "application/json" 56 | # ``` 57 | # 58 | # #### Host constraints 59 | # 60 | # You can constrain the request to a specific host by wrapping routes 61 | # in a `host` block. In this method, any routes within the block will be 62 | # matched at that constraint. 63 | # 64 | # You may also choose to limit the request to a certain format. Such as restricting 65 | # the extension of the URL to '.json'. 66 | # 67 | # ``` 68 | # host "example.com" do 69 | # get "users/:id", format: "json" 70 | # end 71 | # ``` 72 | # 73 | # #### Subdomain constraints 74 | # 75 | # You can constrain the request to a specific subdomain by wrapping routes 76 | # in a `subdomain` block. In this method, any routes within the block will be 77 | # matched at that constraint. 78 | # 79 | # You may also choose to limit the request to a certain format. Such as restricting 80 | # the extension of the URL to '.json'. 81 | # 82 | # ``` 83 | # subdomain "api" do 84 | # get "users/:id", format: "json" 85 | # end 86 | # ``` 87 | # 88 | # #### Custom Constraints 89 | # 90 | # You can also pass in your own constraints by just passing a class/struct that 91 | # implements the `Orion::Constraint` module. 92 | # 93 | # ``` 94 | # struct MyConstraint 95 | # def matches?(req : HTTP::Request) 96 | # true 97 | # end 98 | # end 99 | # 100 | # constraint MyConstraint.new do 101 | # get "users/:id", format: "json" 102 | # end 103 | # ``` 104 | module Orion::DSL::Constraints 105 | # :nodoc: 106 | CONSTRAINTS = [] of Constraint 107 | 108 | # Constrain routes by an `Orion::Constraint` 109 | macro constraint(constraint) 110 | constraints({{ constraint }}) do 111 | {{ yield }} 112 | end 113 | end 114 | 115 | # Constrain routes by one or more `Orion::Constraint`s 116 | macro constraints(*constraints) 117 | scope do 118 | {% for constraint, i in constraints %} # Add the array of provided constraints 119 | CONSTRAINTS << {{ constraint }} 120 | {% end %} 121 | {{ yield }} 122 | end 123 | end 124 | 125 | # Constrain routes by a given domain 126 | macro host(host) 127 | constraint(::Orion::HostConstraint.new({{ host }})) do 128 | {{ yield }} 129 | end 130 | end 131 | 132 | # Constrain routes by a given subdomain 133 | macro subdomain(subdomain) 134 | constraint(::Orion::SubdomainConstraint.new({{ subdomain }})) do 135 | {{ yield }} 136 | end 137 | end 138 | end 139 | -------------------------------------------------------------------------------- /src/orion/dsl/handlers.cr: -------------------------------------------------------------------------------- 1 | # Handlers allow you to maniplate the request stack by passing instances of classes 2 | # implementing the 3 | # [`HTTP::Handler`](https://crystal-lang.org/api/HTTP/Handler.html) _(a.k.a. middleware)_ 4 | # module. 5 | # 6 | # > Handlers will only apply to the routes specified below them, so be sure to place your handlers near the top of your route. 7 | # 8 | # ``` 9 | # use HTTP::ErrorHandler 10 | # use HTTP::LogHandler.new(File.open("tmp/application.log")) 11 | # ``` 12 | # 13 | # ### Nested Routes using `scope` 14 | # 15 | # Scopes are a method in which you can nest routes under a common path. This prevents 16 | # the need for duplicating paths and allows a developer to easily change the parent 17 | # of a set of child paths. 18 | # 19 | # ``` 20 | # scope "users" do 21 | # root to: "Users#index" 22 | # get ":id", to: "Users#show" 23 | # delete ":id", to: "Users#destroy" 24 | # end 25 | # ``` 26 | # 27 | # #### Handlers within nested routes 28 | # 29 | # Instances of link:https://crystal-lang.org/api/HTTP/Handler.html[`HTTP::Handler`] can be 30 | # used within a `scope` block and will only apply to the subsequent routes within that scope. 31 | # It is important to note that the parent context's handlers will also be used. 32 | # 33 | # > Handlers will only apply to the routes specified below them, so be sure to place your handlers near the top of your scope. 34 | # 35 | # ``` 36 | # scope "users" do 37 | # use AuthorizationHandler.new 38 | # root to: "Users#index" 39 | # get ":id", to: "Users#show" 40 | # delete ":id", to: "Users#destroy" 41 | # end 42 | # ``` 43 | module Orion::DSL::Handlers 44 | # Insert a new handler. This is the same as `handlers.push(HTTP::LogHandler.new)` 45 | macro use(handler) 46 | HANDLERS << case (handler = {{handler}}) 47 | when HTTP::Handler 48 | handler 49 | else 50 | handler.new 51 | end 52 | end 53 | 54 | # Direct access the handlers array, giving you access to methods like `unshift`, 55 | # `push` and `clear`. 56 | macro handlers 57 | HANDLERS 58 | end 59 | end 60 | -------------------------------------------------------------------------------- /src/orion/dsl/helpers.cr: -------------------------------------------------------------------------------- 1 | # Route helpers provide type-safe methods to generate paths and URLs to defined routes 2 | # in your application. By including the `Helpers` module on the router (i.e. `MyApplicationRouter::Helpers`) 3 | # you can access any helper defined in the router by `{{name}}_path` to get its corresponding 4 | # route. In addition, when you have a `@context : HTTP::Server::Context` instance var, 5 | # you will also be able to access a `{{name}}_url` to get the full URL. 6 | # 7 | # ``` 8 | # scope "users", helper_prefix: "user" do 9 | # get "/new", to: "users#new", helper: "new" 10 | # end 11 | # 12 | # class UsersController < BaseController 13 | # def new 14 | # File.open("new.html") { |f| IO.copy(f, response) } 15 | # end 16 | # 17 | # def show 18 | # user = User.find(request.path_params["id"]) 19 | # response.headers["Location"] = new_user_path 20 | # response.status_code = 301 21 | # response.close 22 | # end 23 | # end 24 | # ``` 25 | # 26 | # #### Making route helpers from your routes 27 | # 28 | # In order to make a helper from your route, you can use the `helper` named argument in your route. 29 | # 30 | # ``` 31 | # scope "users" do 32 | # get "/new", to: "Users#new", helper: "new" 33 | # end 34 | # ``` 35 | # 36 | # #### Using route helpers in your code 37 | # 38 | # As you add helpers they are added to the nested `Helpers` module of your router. 39 | # you may include this module anywhere in your code to get access to the methods, 40 | # or call them on the module directly. 41 | # 42 | # _If `@context : HTTP::Server::Context` is present in the class, you will also be 43 | # able to use the `{helper}_url` versions of the helpers._ 44 | # 45 | # ``` 46 | # resources :users 47 | # 48 | # class User 49 | # include RouteHelpers 50 | # 51 | # def route 52 | # user_path user_id: self.id 53 | # end 54 | # end 55 | # 56 | # puts RouteHelpers.users_path 57 | # ``` 58 | module Orion::DSL::Helpers 59 | private macro define_helper(*, base_path, path, spec) 60 | {% name_parts = PREFIXES + [] of StringLiteral %} 61 | 62 | {% if spec.is_a? BoolLiteral %} 63 | {% raise "Cannot use a boolean helper outside of a scope." if PREFIXES.size == 0 %} 64 | {% elsif spec.is_a?(NamedTupleLiteral) || spec.is_a?(HashLiteral) %} 65 | {% name_parts.unshift(spec[:prefix]) if spec[:prefix] %} 66 | {% name_parts.push(spec[:name]) if spec[:name] %} 67 | {% name_parts.push(spec[:suffix]) if spec[:suffix] %} 68 | {% elsif spec.is_a? StringLiteral %} 69 | {% name_parts.push(spec) if spec %} 70 | {% else %} 71 | {% raise "Unsupported spec type: #{spec.class_name}" %} 72 | {% end %} 73 | 74 | {% method_name = name_parts.map(&.id).join("_").id %} 75 | 76 | module ::{{ RouteHelpers }} 77 | # Returns the full path for `{{ method_name.id }}` 78 | def self.{{ method_name.id }}_path(**params) 79 | path = ::Orion::DSL.normalize_path(base_path: {{ base_path }}, path: {{ path }}) 80 | result = TREE.find(path).not_nil! 81 | path_param_names = result.params.keys 82 | 83 | {% "Convert all the params to a string" %} 84 | params_hash = ({} of String => String).tap do |memo| 85 | params.each do |key, value| 86 | memo[key.to_s] = value.to_s 87 | result.params.delete key.to_s 88 | end 89 | end 90 | 91 | raise Orion::ParametersMissing.new(result.params.keys) unless result.params.keys.empty? 92 | 93 | # Assign the path params 94 | path_param_names.each do |name| 95 | path = path.gsub /(:|\*)#{name}/, params_hash[name] 96 | params_hash.delete name 97 | end 98 | 99 | query = HTTP::Params.encode(params_hash) unless params_hash.empty? 100 | 101 | URI.new(path: path, query: query).to_s 102 | end 103 | 104 | def {{ method_name.id }}_path(**params) 105 | ::{{ RouteHelpers }}.{{ method_name.id }}_path(**params) 106 | end 107 | 108 | # Returns the full url for `{{ method_name.id }}` 109 | def {{ method_name.id }}_url(**params) 110 | uri = URI.parse {{ method_name.id }}_path(**params, host: request.headers["Host"]?) 111 | uri.host = @context.request.headers["Host"]? 112 | end 113 | end 114 | end 115 | end 116 | -------------------------------------------------------------------------------- /src/orion/dsl/macros.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | module Orion::DSL::Macros 3 | private macro included 4 | include ::Orion::DSL::Concerns 5 | include ::Orion::DSL::Constraints 6 | include ::Orion::DSL::Handlers 7 | include ::Orion::DSL::Helpers 8 | include ::Orion::DSL::Match 9 | include ::Orion::DSL::Mount 10 | include ::Orion::DSL::RequestMethods 11 | include ::Orion::DSL::WebSockets 12 | include ::Orion::DSL::Root 13 | include ::Orion::DSL::Scope 14 | include ::Orion::DSL::Resources 15 | include ::Orion::DSL::Static 16 | end 17 | end 18 | -------------------------------------------------------------------------------- /src/orion/dsl/match.cr: -------------------------------------------------------------------------------- 1 | # Catch-all routes using `match` 2 | # 3 | # In some instances, you may just want to redirect all verbs to a particular 4 | # controller and action. 5 | # 6 | # You can use the `match` method and pass it's route and 7 | # any variation of the [Generic Route Arguments](#generic-route-arguments). 8 | # 9 | # ``` 10 | # match "404", controller: ErrorsController, action: error_404 11 | # ``` 12 | # 13 | # ### Generic route arguments 14 | # There are a variety of ways that you can interact with basic routes. Below are 15 | # some examples and guidelines on the different ways you can interact with the router. 16 | # #### Using `to: String` to target a controller and action 17 | # One of the most common ways we will be creating routes in this guide is to use 18 | # the `to` argument supplied with a controller and action in the form of a string. 19 | # In the example below `users#create` will map to `UsersController.new(cxt : Orion::Server::Context).create`. 20 | # You can also pass an exact constant name. 21 | # 22 | # ``` 23 | # post "users", to: "users#create" 24 | # ``` 25 | # 26 | # #### Using `controller: Type` and `action: Method` 27 | # A longer form of the `to` argument strategy above allows us to pass the controller and action 28 | # independently. 29 | # 30 | # ``` 31 | # post "users", controller: UsersController, action: create 32 | # ``` 33 | # 34 | # #### Using block syntax 35 | # Sometimes, we may want a more link:https://github.com/kemalcr/kemal[kemal] or 36 | # link:http://sinatrarb.com/[sinatra] like approach. To accomplish this, we can 37 | # simply pass a block that will be evaluated as a controller. 38 | # 39 | # ``` 40 | # post "users" do 41 | # "Foo" 42 | # end 43 | # ``` 44 | # 45 | # #### Using a `call` able object 46 | # Lastly a second argument can be any 47 | # object that responds to `#call(cxt : Orion::Server::Context)`. 48 | # 49 | # ``` 50 | # post "users", ->(context : Orion::Server::Context) { 51 | # context.response.puts "foo" 52 | # } 53 | # ``` 54 | module Orion::DSL::Match 55 | # Defines a match route to a callable object. 56 | # 57 | # You can route to any object that responds to `call` with an `Orion::Server::Context`. 58 | # 59 | # ``` 60 | # module Callable 61 | # def call(cxt : Orion::Server::Context) 62 | # # ... do something 63 | # end 64 | # end 65 | # 66 | # match "/path", Callable 67 | # ``` 68 | macro match(path, callable, *, via = :all, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 69 | {% if !format && path.split(".").size > 1 %} 70 | {% format = path.split(".")[-1] %} 71 | {% path = path.split(".")[0..-2].join(".") %} 72 | {% end %} 73 | 74 | # create the action 75 | %action = ::Orion::Action.new( 76 | -> (context : ::Orion::Server::Context) { 77 | write_tracker = ::Orion::WriteTracker.new 78 | output = context.response.output 79 | context.response.output = ::IO::MultiWriter.new(output, write_tracker, sync_close: true) 80 | return_value = {{ callable }}.call(context) 81 | # If no response has been written handle the return value as a response 82 | if !write_tracker.written 83 | case return_value 84 | when String 85 | context.response.puts return_value 86 | when IO 87 | is_invalid = return_value.closed? || return_value == context.response || context.response.output || context.response.@original_output 88 | IO.copy(return_value, context.response) unless is_invalid 89 | else 90 | end 91 | end 92 | nil 93 | }, 94 | handlers: HANDLERS, 95 | constraints: CONSTRAINTS 96 | ) 97 | 98 | # Add the route to the tree 99 | TREE.add( 100 | ::Orion::DSL.normalize_path(base_path: {{ BASE_PATH }}, path: {{ path }}), 101 | %action 102 | ) 103 | 104 | {% if helper %} # Define the helper 105 | define_helper(base_path: {{ BASE_PATH }}, path: {{ path }}, spec: {{ helper }}) 106 | {% end %} 107 | 108 | {% if constraints %} # Define the param constraints 109 | %action.constraints.unshift ::Orion::ParamsConstraint.new({{ constraints }}.to_h) 110 | {% end %} 111 | 112 | {% if content_type %} # Define the content type constraint 113 | %action.constraints.unshift ::Orion::ContentTypeConstraint.new({{ content_type }}) 114 | {% end %} 115 | 116 | {% if type %} # Define the content type and accept constraint 117 | %action.constraints.unshift ::Orion::ContentTypeConstraint.new({{ type }}) 118 | %action.constraints.unshift ::Orion::AcceptConstraint.new({{ type }}) 119 | {% end %} 120 | 121 | {% if format %} # Define the format constraint 122 | %action.constraints.unshift ::Orion::FormatConstraint.new({{ format }}) 123 | {% end %} 124 | 125 | {% if accept %} # Define the content type constraint 126 | %action.constraints.unshift ::Orion::AcceptConstraint.new({{ accept }}) 127 | {% end %} 128 | 129 | {% if via != :all && !via.nil? %} # Define the method constraint 130 | %action.constraints.unshift ::Orion::RequestMethodsConstraint.new({{ via }}) 131 | {% end %} 132 | end 133 | 134 | # Defines a match route to a controller and action (short form). 135 | # You can route to a controller and action by passing the `to` argument in 136 | # the form of `"#action"`. 137 | # 138 | # ``` 139 | # class MyController 140 | # def new(@context : Orion::Server::Context) 141 | # end 142 | # 143 | # def match 144 | # # ... do something 145 | # end 146 | # end 147 | # 148 | # match "/path", to: "My#match" 149 | # ``` 150 | macro match(path, *, to, via = :all, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 151 | {% parts = to.split("#") %} 152 | {% controller = run("../inflector/controllerize.cr", parts[0].id) %} 153 | {% action = parts[1] %} 154 | {% raise("`to` must be in the form `controller#action`") unless controller && action && parts.size == 2 %} 155 | match({{ path }}, controller: {{ controller.id }}, action: {{ action.id }}, via: {{ via }}, helper: {{ helper }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}) 156 | end 157 | 158 | # Defines a match route to a controller and action (long form). 159 | # You can route to a controller and action by passing the `controller` and 160 | # `action` arguments, if action is omitted it will default to `match`. 161 | # 162 | # ``` 163 | # class MyController 164 | # def new(@context : Orion::Server::Context) 165 | # end 166 | # 167 | # def match 168 | # # ... do something 169 | # end 170 | # end 171 | # 172 | # match "/path", controller: MyController, action: match 173 | # ``` 174 | macro match(path, *, action, controller = CONTROLLER, via = :all, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 175 | match({{ path }}, ->(context : Orion::Server::Context) { {{ controller }}.new(context).{{ action }} }, via: {{ via }}, helper: {{ helper }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}) 176 | end 177 | 178 | # Defines a match route with a block. 179 | # 180 | # When given with 0 argument it will yield the block and have access to any method within the BaseController of the application. 181 | # When given with 1 argument it will yield the block with `Orion::Server::Context` and have access to any method within the BaseController of the application. 182 | # When given with 2 arguments it will yield the block with `HTTP::Request` and `HTTP::Server::Response` and have access to any method within the BaseController of the application. 183 | # 184 | # ``` 185 | # match "/path" do |context| 186 | # # ... do something 187 | # end 188 | # ``` 189 | macro match(path, *, via = :all, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil, &block) 190 | {% controller_const = run "../inflector/random_const.cr", "Controller" %} 191 | struct {{ controller_const }} 192 | include ::Orion::Controller 193 | include RouteHelpers 194 | 195 | def handle 196 | {% if block.args.size == 0 %} 197 | {{ block.body }} 198 | {% elsif block.args.size == 1 %} 199 | action_block = ->({{ "#{block.args[0]} : Orion::Server::Context".id }}){ 200 | {{ block.body }} 201 | } 202 | action_block.call(context) 203 | {% elsif block.args.size == 2 %} 204 | action_block = ->({{ "#{block.args[0]} : HTTP::Request, #{block.args[1]} : HTTP::Server::Response".id }}){ 205 | {{ block.body }} 206 | } 207 | action_block.call(request, response) 208 | {% else %} 209 | {% raise "block must have 0..2 arguments" %} 210 | {% end %} 211 | end 212 | end 213 | match({{ path }}, controller: {{ controller_const }}, action: handle, via: {{ via }}, helper: {{ helper }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}) 214 | end 215 | end 216 | -------------------------------------------------------------------------------- /src/orion/dsl/mount.cr: -------------------------------------------------------------------------------- 1 | # You can mount other orion and crystal applications directly within your app. 2 | # This can be useful when separating out concerns between different functional 3 | # areas of your application. 4 | module Orion::DSL::Mount 5 | # Mount an application at the specified path. 6 | macro mount(app, *, at = "/") 7 | scope {{ at }} do 8 | use ::Orion::Handlers::ResetPath.new 9 | match("/*", {{ app }}) 10 | end 11 | end 12 | end 13 | -------------------------------------------------------------------------------- /src/orion/dsl/request_methods.cr: -------------------------------------------------------------------------------- 1 | # Request method macros are shorthard ways of constraining a request to a single 2 | # request method. You can read more about the options available to each of these 3 | # macros in the `Orion::DSL::Match`. 4 | module Orion::DSL::RequestMethods 5 | METHODS = %w{GET HEAD POST PUT DELETE CONNECT OPTIONS TRACE PATCH} 6 | 7 | {% for method in METHODS %} 8 | # Defines a {{ method.id }} route to a callable object. 9 | # 10 | # You can route to any object that responds to `call` with an `HTTP::Server::Context`, 11 | # this also works for any `Proc(HTTP::Server::Context, _)`. 12 | # 13 | # ``` 14 | # module Callable 15 | # def call(cxt : HTTP::Server::Context) 16 | # # ... do something 17 | # end 18 | # end 19 | # 20 | # match "/path", Callable 21 | # ``` 22 | macro {{ method.downcase.id }}(path, callable, *, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 23 | match(\{{ path }}, \{{ callable }}, via: {{ method.downcase }}, helper: \{{ helper }}, constraints: \{{ constraints }}, format: \{{ format }}, accept: \{{ accept }}, content_type: \{{ content_type }}, type: \{{ type }}) 24 | end 25 | 26 | # Defines a {{ method.id }} route to a controller and action (short form). 27 | # You can route to a controller and action by passing the `to` argument in 28 | # the form of `"#action"`. 29 | # 30 | # ``` 31 | # class MyController < BaseController 32 | # def match 33 | # # ... do something 34 | # end 35 | # end 36 | # 37 | # match "/path", to: "My#{{ method.downcase.id }}" 38 | # ``` 39 | macro {{ method.downcase.id }}(path, *, to, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 40 | match(\{{ path }}, to: \{{ to }}, via: {{ method.downcase }}, helper: \{{ helper }}, constraints: \{{ constraints }}, format: \{{ format }}, accept: \{{ accept }}, content_type: \{{ content_type }}, type: \{{ type }}) 41 | end 42 | 43 | # Defines a {{ method.id }} route to a controller and action (long form). 44 | # You can route to a controller and action by passing the `controller` and 45 | # `action` arguments, if action is omitted it will default to `match`. 46 | # 47 | # ``` 48 | # class MyController 49 | # def new(@context : HTTP::Server::Context) 50 | # end 51 | # 52 | # def match 53 | # # ... do something 54 | # end 55 | # end 56 | # 57 | # match "/path", controller: MyController, action: {{ method.downcase.id }} 58 | # ``` 59 | macro {{ method.downcase.id }}(path, *, action, controller = CONTROLLER, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 60 | match(\{{ path }}, controller: \{{ controller }}, action: \{{ action }}, via: {{ method.downcase }}, helper: \{{ helper }}, constraints: \{{ constraints }}, format: \{{ format }}, accept: \{{ accept }}, content_type: \{{ content_type }}, type: \{{ type }}) 61 | end 62 | 63 | # Defines a {{ method.id }} route with a block. 64 | # 65 | # You can pass a block. Each block will be evaluated as a controller method 66 | # and have access to all controller helper methods. 67 | # 68 | # ``` 69 | # match "/path" do 70 | # # ... do something 71 | # end 72 | # ``` 73 | macro {{ method.downcase.id }}(path, *, helper = nil, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil, &block) 74 | match(\{{ path }}, via: {{ method.downcase }}, helper: \{{ helper }}, constraints: \{{ constraints }}, format: \{{ format }}, accept: \{{ accept }}, content_type: \{{ content_type }}, type: \{{ type }}) \{{block}} 75 | end 76 | {% end %} 77 | end 78 | -------------------------------------------------------------------------------- /src/orion/dsl/resources.cr: -------------------------------------------------------------------------------- 1 | # A common way in Orion to route is to do so against a known resource. This method 2 | # will create a series of routes targeted at a specific controller. 3 | # 4 | # _The following is an example controller definition and the matching 5 | # resources definition._ 6 | # 7 | # ``` 8 | # class PostsController 9 | # include Orion::ControllerHelper 10 | # include ResponseHelpers 11 | # 12 | # def index 13 | # @posts = Post.all 14 | # render :index 15 | # end 16 | # 17 | # def new 18 | # @post = Post.new 19 | # render :new 20 | # end 21 | # 22 | # def create 23 | # post = Post.create(request) 24 | # redirect to: post_path post_id: post.id 25 | # end 26 | # 27 | # def show 28 | # @post = Post.find(request.path_params["post_id"]) 29 | # end 30 | # 31 | # def edit 32 | # @post = Post.find(request.path_params["post_id"]) 33 | # render :edit 34 | # end 35 | # 36 | # def update 37 | # post = Post.find(request.path_params["post_id"]) 38 | # HTTP::FormData.parse(request) do |part| 39 | # post.attributes[part.name] = part.body.gets_to_end 40 | # end 41 | # redirect to: post_path post_id: post.id 42 | # end 43 | # 44 | # def delete 45 | # post = Post.find(request.path_params["post_id"]) 46 | # post.delete 47 | # redirect to: posts_path 48 | # end 49 | # end 50 | # 51 | # resources :posts 52 | # ``` 53 | # 54 | # #### Including/Excluding Actions 55 | # 56 | # By default, the actions `index`, `new`, `create`, `show`, `edit`, `update`, `delete` 57 | # are included. You may include or exclude explicitly by using the `only` and `except` params. 58 | # 59 | # > NOTE: The index action is not added for [singular resources](#singular-resources). 60 | # 61 | # ``` 62 | # resources :posts, except: [:edit, :update] 63 | # resources :users, only: [:new, :create, :show] 64 | # ``` 65 | # 66 | # #### Nested Resources and Routes 67 | # 68 | # You can add nested resources and member routes by providing a block to the 69 | # `resources` definition. 70 | # 71 | # ``` 72 | # resources :posts do 73 | # post "feature", action: feature 74 | # resources :likes 75 | # resources :comments 76 | # end 77 | # ``` 78 | # 79 | # #### Singular Resources 80 | # 81 | # In addition to using the collection of `resources` method, You can also add 82 | # singular resources which do not provide a `id_param` or `index` action. 83 | # 84 | # ``` 85 | # resource :profile 86 | # ``` 87 | # 88 | # #### Customizing ID 89 | # 90 | # You can customize the ID path parameter by passing the `id_param` parameter. 91 | # 92 | # ``` 93 | # resources :posts, id_param: :article_id 94 | # ``` 95 | # 96 | # #### Constraining the ID 97 | # 98 | # You can set constraints on the ID parameter by passing the `id_constraint` parameter. 99 | # 100 | # See `Orion::DSL::Constraints` for more details on constraints. 101 | # 102 | # ``` 103 | # resources :posts, id_constraint: /^\d{4}$/ 104 | # ``` 105 | module Orion::DSL::Resources 106 | macro resources(name, *, controller = nil, only = nil, except = nil, id_constraint = nil, format = nil, accept = nil, id_param = nil, content_type = nil, type = nil) 107 | {% raise "resource name must be a symbol" unless name.is_a? SymbolLiteral %} 108 | {% name = name.id %} 109 | {% singular_name = run "../inflector/singularize.cr", name %} 110 | {% id_param = (id_param || "#{singular_name.id}_id").id.stringify %} 111 | {% singular_underscore_name = run("../inflector/underscore.cr", singular_name) %} 112 | {% controller = controller || run("../inflector/controllerize.cr", name.downcase) %} 113 | {% underscore_name = run("../inflector/underscore.cr", name) %} 114 | 115 | scope {{ "/#{name}" }}, controller: {{ controller }} do 116 | {% if content_type %} # Define the content type constraint 117 | CONSTRAINTS << ::Orion::ContentTypeConstraint.new({{ content_type }}) 118 | {% end %} 119 | 120 | {% if type %} # Define the content type and accept constraint 121 | CONSTRAINTS << ::Orion::ContentTypeConstraint.new({{ type }}) 122 | CONSTRAINTS << ::Orion::AcceptConstraint.new({{ type }}) 123 | {% end %} 124 | 125 | {% if format %} # Define the format constraint 126 | CONSTRAINTS << ::Orion::FormatConstraint.new({{ format }}) 127 | {% end %} 128 | 129 | {% if accept %} # Define the accept constraint 130 | CONSTRAINTS << ::Orion::AcceptConstraint.new({{ accept }}) 131 | {% end %} 132 | 133 | scope helper_prefix: {{ underscore_name }} do 134 | resource_action(:get, "/", :index, only: {{ only }}, except: {{ except }}, helper: true) 135 | resource_action(:post, "/", :create, only: {{ only }}, except: {{ except }}) 136 | end 137 | 138 | scope helper_prefix: {{ singular_underscore_name }} do 139 | resource_action(:get, "/new", :new, only: {{ only }}, except: {{ except }}, helper: { prefix: "new" }) 140 | end 141 | 142 | scope {{ "/:#{id_param.id}" }}, helper_prefix: {{ singular_underscore_name.stringify }} do 143 | {% if id_constraint %} 144 | CONSTRAINTS << ::Orion::ParamsConstraint.new({ {{ id_param }} => {{ id_constraint }} }) 145 | {% end %} 146 | 147 | resource_action(:get, "", :show, only: {{ only }}, except: {{ except }}, helper: true) 148 | resource_action(:get, "/edit", :edit, only: {{ only }}, except: {{ except }}, helper: { prefix: "edit" }) 149 | resource_action(:put, "", :update, only: {{ only }}, except: {{ except }}) 150 | resource_action(:patch, "", :update, only: {{ only }}, except: {{ except }}) 151 | resource_action(:delete, "", :delete, only: {{ only }}, except: {{ except }}) 152 | 153 | {{ yield }} 154 | end 155 | end 156 | end 157 | 158 | macro resource(name, *, controller = nil, only = nil, except = nil, format = nil, accept = nil, content_type = nil, type = nil) 159 | {% raise "resource name must be a symbol" unless name.is_a? SymbolLiteral %} 160 | {% name = name.id %} 161 | {% controller = controller || run("../inflector/controllerize.cr", name.downcase) %} 162 | {% underscore_name = run("../inflector/underscore.cr", name) %} 163 | 164 | scope {{ "/#{name}" }}, helper_prefix: {{ underscore_name }}, controller: {{ controller }} do 165 | {% if content_type %} # Define the content type constraint 166 | CONSTRAINTS << ::Orion::ContentTypeConstraint.new({{ content_type }}) 167 | {% end %} 168 | 169 | {% if type %} # Define the content type and accept constraint 170 | CONSTRAINTS << ::Orion::ContentTypeConstraint.new({{ type }}) 171 | CONSTRAINTS << ::Orion::AcceptConstraint.new({{ type }}) 172 | {% end %} 173 | 174 | {% if format %} # Define the format constraint 175 | CONSTRAINTS << ::Orion::FormatConstraint.new({{ format }}) 176 | {% end %} 177 | 178 | {% if accept %} # Define the accept constraint 179 | CONSTRAINTS << ::Orion::AcceptConstraint.new({{ accept }}) 180 | {% end %} 181 | 182 | resource_action(:get, "/new", :new, only: {{ only }}, except: {{ except }}, helper: { prefix: "new" }) 183 | resource_action(:post, "", :create, only: {{ only }}, except: {{ except }}) 184 | resource_action(:get, "", :show, only: {{ only }}, except: {{ except }}, helper: true) 185 | resource_action(:get, "/edit", :edit, only: {{ only }}, except: {{ except }}, helper: { prefix: "edit" }) 186 | resource_action(:put, "", :update, only: {{ only }}, except: {{ except }}) 187 | resource_action(:patch, "", :update, only: {{ only }}, except: {{ except }}) 188 | resource_action(:delete, "", :delete, only: {{ only }}, except: {{ except }}) 189 | 190 | {{ yield }} 191 | end 192 | end 193 | 194 | private macro resource_action(method, path, action, *, only = nil, except = nil, helper = false) 195 | {% except = !except || except.is_a?(ArrayLiteral) ? except : [except] %} 196 | {% only = !only || only.is_a?(ArrayLiteral) ? only : [only] %} 197 | {% if (!only || only.includes?(action)) && (!except || !except.includes?(action)) %} 198 | {{ method.id }}({{ path }}, action: {{ action.id }}, helper: {{ helper }}) 199 | {% end %} 200 | end 201 | end 202 | -------------------------------------------------------------------------------- /src/orion/dsl/root.cr: -------------------------------------------------------------------------------- 1 | # The root macro is a shortcut to making a `get "/"` at the root of you application 2 | # or at the root of a scope. 3 | module Orion::DSL::Root 4 | # Define a `GET /` route at the current path with a callable object. 5 | # 6 | # ``` 7 | # module Callable 8 | # def call(cxt : HTTP::Server::Context) 9 | # # ... do something 10 | # end 11 | # end 12 | # 13 | # router MyRouter do 14 | # root Callable 15 | # end 16 | # ``` 17 | macro root(callable, *, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 18 | get("/", {{ callable }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}, helper: "root") 19 | end 20 | 21 | # Define a `GET /` route at the current path with a controller and action (short form). 22 | # 23 | # ``` 24 | # router MyRouter do 25 | # root to: "#action" 26 | # end 27 | # ``` 28 | macro root(*, to, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil) 29 | get("/", to: {{ to }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}, helper: "root") 30 | end 31 | 32 | # Define a `GET /` route at the current path with a controller and action (long form). 33 | # 34 | # ``` 35 | # router MyRouter do 36 | # root controller: Controller action: action 37 | # end 38 | # ``` 39 | macro root(*, action, controller = CONTROLLER, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil, &block) 40 | get("/", action: {{ action }}, controller: {{ controller }}, constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}, helper: "root") 41 | end 42 | 43 | # Define a `GET /` route at the current path with a callable object. 44 | # 45 | # ``` 46 | # router MyRouter do 47 | # root do |context| 48 | # # ... 49 | # end 50 | # end 51 | # ``` 52 | macro root(*, constraints = nil, format = nil, accept = nil, content_type = nil, type = nil, &block) 53 | {% args = block.args.map { |n| "#{n} : HTTP::Server::Context".id }.join(", ").id %} 54 | get("/", constraints: {{ constraints }}, format: {{ format }}, accept: {{ accept }}, content_type: {{ content_type }}, type: {{ type }}, helper: "root") {{block}} 55 | end 56 | end 57 | -------------------------------------------------------------------------------- /src/orion/dsl/scope.cr: -------------------------------------------------------------------------------- 1 | # Scopes are a method in which you can nest routes under a common path. This prevents 2 | # the need for duplicating paths and allows a developer to easily change the parent 3 | # of a set of child paths. 4 | # 5 | # ``` 6 | # router MyApplicationRouter do 7 | # scope "users" do 8 | # root to: "Users#index" 9 | # get ":id", to: "Users#show" 10 | # delete ":id", to: "Users#destroy" 11 | # end 12 | # end 13 | # ``` 14 | # 15 | # #### Handlers within nested routes 16 | # 17 | # Instances of link:https://crystal-lang.org/api/HTTP/Handler.html[`HTTP::Handler`] can be 18 | # used within a `scope` block and will only apply to the subsequent routes within that scope. 19 | # It is important to note that the parent context's handlers will also be used. 20 | # 21 | # > Handlers will only apply to the routes specified below them, so be sure to place your handlers near the top of your scope. 22 | # 23 | # ``` 24 | # router MyApplicationRouter do 25 | # scope "users" do 26 | # use AuthorizationHandler.new 27 | # root to: "Users#index" 28 | # get ":id", to: "Users#show" 29 | # delete ":id", to: "Users#destroy" 30 | # end 31 | # end 32 | # ``` 33 | module Orion::DSL::Scope 34 | # Create a scope, optionall nested under a path. 35 | macro scope(path = nil, helper_prefix = nil, controller = nil) 36 | {% prefixes = PREFIXES + [helper_prefix] if helper_prefix %} 37 | {% scope_const = run "../inflector/random_const.cr", "Scope" %} 38 | 39 | # :nodoc: 40 | module {{ scope_const }} 41 | include ::Orion::DSL::Macros 42 | 43 | CONSTRAINTS = {% if @type.stringify != "" %}::{{ @type }}{% end %}::CONSTRAINTS.dup 44 | HANDLERS = {% if @type.stringify != "" %}::{{ @type }}{% end %}::HANDLERS.dup 45 | 46 | # Set the controller 47 | {% if controller %} 48 | CONTROLLER = {{ controller }} 49 | {% end %} 50 | 51 | # Set the base path 52 | {% if path %} 53 | BASE_PATH = [{% if @type.stringify != "" %}::{{ @type }}{% end %}::BASE_PATH.rchop('/'), {{ path }}.lchop('/')].join('/') 54 | use Orion::Handlers::ScopeBasePath.new(BASE_PATH) 55 | {% else %} 56 | BASE_PATH = {% if @type.stringify != "" %}::{{ @type }}{% end %}::BASE_PATH 57 | {% end %} 58 | 59 | # Setup the helper prefixes 60 | {% if helper_prefix %} 61 | PREFIXES = {{ prefixes }} 62 | {% end %} 63 | 64 | # Yield the block 65 | {{ yield }} 66 | end 67 | end 68 | end 69 | -------------------------------------------------------------------------------- /src/orion/dsl/static.cr: -------------------------------------------------------------------------------- 1 | require "uuid" 2 | require "crystar" 3 | 4 | # The static macros allows you to bind static content to given path. 5 | # You can use this for strings and/or files that will never change in a given 6 | # release 7 | module Orion::DSL::Static 8 | # Mount a directory of static files. 9 | # 10 | # router MyRouter do 11 | # static dir: "./public", path: "/" 12 | # end 13 | # ``` 14 | macro static(path = "/", *, dir) 15 | {% if flag?(:packagestatics) || (flag?(:release) && !flag?(:dontpackagestatics)) %} 16 | {% dir = dir.gsub(/^\.\//, "") %} 17 | %dir = File.join(Assets.unpack({{ run "../assets/pack.cr", dir, `date +%s%N` }}), {{ dir }}) 18 | {% else %} 19 | %dir = {{ dir }} 20 | {% end %} 21 | mount ::HTTP::StaticFileHandler.new(%dir, false, false), at: {{ path }} 22 | end 23 | 24 | macro static(*, path, string) 25 | %str : String = {{string}} 26 | get {{ path }}, ->(c : ::Orion::Server::Context){ c.response.puts %str } 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /src/orion/dsl/websockets.cr: -------------------------------------------------------------------------------- 1 | # The websocket handlers allow you to easily add websocket support to your 2 | # application. 3 | module Orion::DSL::WebSockets 4 | # Defines a websocket route to a callable object. 5 | # 6 | # You can route to any object that responds to `call` with a `HTTP::WebSocket` and an `HTTP::Server::Context`. 7 | # 8 | # ``` 9 | # router MyRouter do 10 | # ws "/path", Callable 11 | # end 12 | # 13 | # module Callable 14 | # def call(ws : HTTP::WebSocket, cxt : HTTP::Server::Context) 15 | # # ... do something 16 | # end 17 | # end 18 | # ``` 19 | macro ws(path, ws_callable, *, helper = nil) 20 | # Build the ws handlers 21 | %ws_handler = HTTP::WebSocketHandler.new do |websocket, context| 22 | {{ ws_callable }}.call(websocket, context.as(::Orion::Server::Context)) 23 | nil 24 | end 25 | 26 | # Build the proc 27 | %proc = -> (context : ::Orion::Server::Context) { 28 | %ws_handler.call(context) 29 | nil 30 | } 31 | 32 | # Define the action 33 | %action = ::Orion::Action.new( 34 | %proc, 35 | handlers: HANDLERS, 36 | constraints: CONSTRAINTS 37 | ) 38 | 39 | # Add the route to the tree 40 | %full_path = ::Orion::DSL.normalize_path(base_path: {{ BASE_PATH }}, path: {{ path }}) 41 | TREE.add(%full_path, %action) 42 | 43 | {% if helper %} # Define the helper 44 | define_helper(base_path: {{ BASE_PATH }}, path: {{ path }}, spec: {{ helper }}) 45 | {% end %} 46 | 47 | %action.constraints.unshift ::Orion::RequestMethodsConstraint.new("GET") 48 | %action.constraints.unshift ::Orion::WebSocketConstraint.new 49 | end 50 | 51 | # Defines a websocket route to a websocket compatible controller and action (short form). 52 | # You can route to a controller and action by passing the `to` argument in 53 | # the form of `"MyWebSocket#action"`. 54 | # 55 | # ``` 56 | # router WebApp do 57 | # ws "/path", to: "Sample#ws" 58 | # end 59 | # 60 | # class SampleController < WebApp::BaseController 61 | # def ws 62 | # # ... do something 63 | # end 64 | # end 65 | # ``` 66 | macro ws(path, *, to, helper = nil) 67 | {% parts = to.split("#") %} 68 | {% controller = run("../inflector/controllerize.cr", parts[0].id) %} 69 | {% action = parts[1] %} 70 | {% raise("`to` must be in the form `controller#action`") unless controller && action && parts.size == 2 %} 71 | ws({{ path }}, controller: {{ controller.id }}, action: {{ action.id }}, helper: {{ helper }}) 72 | end 73 | 74 | # Defines a match route to a controller and action (long form). 75 | # You can route to a controller and action by passing the `controller` and 76 | # `action` arguments, if action is omitted it will default to `match`. 77 | # 78 | # ``` 79 | # router WebApp do 80 | # ws "/path", controller: SampleController, action: ws 81 | # end 82 | # 83 | # class SampleController < WebApp::BaseController 84 | # def ws 85 | # # ... do something 86 | # end 87 | # end 88 | # ``` 89 | macro ws(path, *, action, controller = CONTROLLER, helper = nil) 90 | ws( 91 | {{ path }}, 92 | ->(websocket : HTTP::WebSocket, context : ::Orion::Server::Context) { 93 | {{ controller }}.new(context, websocket).{{ action }} 94 | }, 95 | helper: {{ helper }} 96 | ) 97 | end 98 | 99 | # Defines a match route with a block. 100 | # 101 | # Pass a block as the response and it will be evaluated as a controller 102 | # 0..2 block parameters are accepted. The block itself will always be evaluated 103 | # as a controller and have access to all controller methods and macros. 104 | # 105 | # ``` 106 | # router MyRouter do 107 | # ws "/path" do |websocket, context| 108 | # # ... do something 109 | # end 110 | # end 111 | # ``` 112 | macro ws(path, *, helper = nil, &block) 113 | {% controller_const = run "../inflector/random_const.cr", "Controller" %} 114 | struct {{ controller_const }} 115 | include ::Orion::Controller 116 | 117 | def handle 118 | {% if block.args.size == 0 %} 119 | {{ block.body }} 120 | {% elsif block.args.size == 1 %} 121 | action_block = ->({{ "#{block.args[0]} : HTTP::WebSocket".id }}){ 122 | {{ block.body }} 123 | } 124 | action_block.call(websocket) 125 | {% elsif block.args.size == 2 %} 126 | action_block = ->({{ "#{block.args[0]} : HTTP::WebSocket, #{block.args[1]} : HTTP::Request".id }}){ 127 | {{ block.body }} 128 | } 129 | action_block.call(websocket, request) 130 | {% else %} 131 | {% raise "block must have 0..2 arguments" %} 132 | {% end %} 133 | end 134 | end 135 | ws({{ path }}, controller: {{ controller_const }}, action: handle, helper: {{ helper }}) 136 | end 137 | end 138 | -------------------------------------------------------------------------------- /src/orion/error_page.html.ecr: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | <%= page_title %> 6 | 7 | 37 | 38 | 39 | 40 |
41 |
42 |

<%= message %>

43 |

<%= subtext %>

44 |
45 |
46 | 47 | 48 | -------------------------------------------------------------------------------- /src/orion/errors.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | macro exception(const) 3 | # :nodoc: 4 | class Orion::{{ const }} < Exception; end 5 | end 6 | 7 | exception DoubleRenderError 8 | exception RoutingError 9 | 10 | # :nodoc: 11 | class Orion::ParametersMissing < Exception 12 | def initialize(keys : Array(String)) 13 | initialize("Missing parameters: #{keys.join(", ")}") 14 | end 15 | end 16 | -------------------------------------------------------------------------------- /src/orion/exception_page.cr: -------------------------------------------------------------------------------- 1 | require "exception_page" 2 | 3 | class Orion::ExceptionPage < ::ExceptionPage 4 | def styles : Styles 5 | ExceptionPage::Styles.new( 6 | accent: "#2E1052", 7 | logo_uri: "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 64 64" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;"><g id="Layer1"><g><rect x="11.044" y="7.117" width="41.432" height="32.739" style="fill:#0d0d0d;"/></g><g><path d="M37.043,18.572c-0.617,1.411 0.832,2.248 1.163,4.497c0.433,-3.039 -1.163,-4.497 -1.163,-4.497" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M33.263,17.891c0.719,0.272 2.299,-0.612 2.664,0.085c0.365,0.696 0.786,-1.283 -0.563,-1.185c-1.349,0.098 -2.101,1.1 -2.101,1.1" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M37.912,25.952c-0.491,1.645 -2.423,1.24 -2.292,1.99c0.199,1.143 -0.358,2.168 -0.875,2.313c0,0 0.438,-2.06 -0.517,-2.096c0.239,0.578 0.239,1.879 -1.033,2.524c-1.244,0.631 -3.657,0.909 -6.519,-0.247c-1.233,-0.615 -3.723,-2.949 -3.697,-5.928c0.397,1.193 0.954,1.626 0.954,1.626c-0.239,-1.229 -0.875,-3.47 0.079,-4.952c0.954,-1.482 2.823,-0.686 3.379,-1.229c0.557,-0.542 -1.125,-1.843 -0.974,-2.669c0.258,-1.409 3.87,-2.672 4.824,-1.913c0.954,0.759 0.316,1.646 0.992,2.225c-0.08,-0.723 0.596,-1.338 0.198,-2.025c0.755,0.398 -0.119,1.482 0.597,2.169c0.715,0.687 1.987,-0.614 2.583,-0.289c0.597,0.325 0.279,2.132 0.875,2.892c0,-0.976 0.557,-1.772 0.557,-1.772c-0.112,1.327 1.985,3.643 0.869,7.381m-0.793,-11.089c0,0 0.513,1.087 0.276,2.32c-0.141,-0.705 -0.459,-1.366 -0.92,-1.97c-0.016,-0.018 -0.033,-0.039 -0.052,-0.067c-0.025,-0.032 -0.051,-0.063 -0.076,-0.095c-0.419,-0.417 -0.672,1.093 -1.435,1.125c-0.808,0.034 -0.754,-1.859 -2.922,-1.899c2.939,-0.932 3.017,1.155 3.219,0.63c0.202,-0.524 -0.281,-1.159 -0.997,-1.619c-0.436,-0.254 -0.906,-0.484 -1.405,-0.687c-0.273,2.041 -3.623,-0.789 -7.45,2.692c-2.454,-0.683 -4.329,0.793 -4.958,2.673c1.853,0.387 1.964,2.665 1.06,2.993c-0.904,0.327 -0.74,-1.094 -0.803,-1.759c-1.678,3.527 0.875,7.988 3.199,9.183c-3.209,-1.119 -3.364,1.83 -4.193,0.725c-0.307,1.78 0.694,2.825 1.823,2.88c-0.718,1.381 0.055,3.701 2.486,4.696c-0.387,-0.553 -1.047,-0.921 -0.939,-2.32c0.055,0.663 1.491,2.154 3.646,2.486c0.678,0.104 1.449,0.23 2.204,0.403c-1.336,-1.251 -2.023,-2.564 -2.856,-2.564c-0.614,0 -0.56,0.491 0.08,0.993c0.698,0.546 2.008,0.956 1.289,0.895c-0.879,-0.076 -1.523,-0.289 -2.001,-0.574c-0.568,-0.337 -0.968,-1.347 -1.088,-2.095c-0.002,0.218 -0.036,0.598 0.031,0.996c-0.439,-0.805 -0.431,-1.615 -0.719,-1.718c-0.56,-0.199 -1.036,1.197 -1.301,0.613c-0.266,-0.584 0.731,-1.277 0.306,-1.384c-0.425,-0.107 -0.905,-0.957 -1.107,-1.618c0.329,0.137 0.796,1.111 1.705,-0.226c0.64,-0.943 1.743,-0.557 3.106,0.488c0.783,0.645 2.461,2.74 0.533,2.608c0.535,0.793 1.145,0.489 1.145,0.489c0.834,1.63 2.158,1.44 3.81,2.939c0.724,0.657 0.889,1.674 0.663,2.209c1.105,-1.413 -0.386,-3.557 -1.936,-5.147c0,0 2.131,1.737 3.815,1.477c-2.206,-0.959 -2.542,-2.7 -4.734,-4.117c2.996,1.492 8.942,1.868 9.517,0.146c0,0 -1.458,0.835 -2.577,0.13c2.577,-0.13 3.636,-1.612 3.923,-4.302c0.163,-1.535 -0.605,-2.463 -0.033,-3.045c0.225,-0.229 0.87,-0.652 1.255,0.811c1.005,-3.792 -3.042,-9.344 -4.589,-10.394" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M24.056,28.912c-1.189,-0.426 -2.204,-0.673 -3.271,0.207c0.784,-0.087 -0.009,0.552 -0.724,0.552c0,0 -0.145,1.468 1.151,1.812c-0.547,-0.571 -0.614,-1.415 -0.02,-1.913c0.595,-0.498 1.786,-0.202 1.483,0.612c-0.117,0.315 -0.468,0.61 -0.468,0.61c1.272,0 1.047,-1.735 1.849,-1.88" style="fill:#5c4866;fill-rule:nonzero;"/></g><g><path d="M31.019,35.649c-0.458,-0.944 -0.995,-1.761 -2.093,-2.347c-1.125,0.178 1.252,1.531 2.093,2.347" style="fill:#282a1e;fill-rule:nonzero;"/></g><g><path d="M29.65,16.143c0.23,0.218 0.56,0.799 1.192,0.555c-1.019,-0.53 -1.192,-0.555 -1.192,-0.555" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M34.678,20.005c-0.791,-0.972 -2.128,-0.03 -1.916,0.788c0.213,0.818 -0.82,1.245 -1.159,0.562c-0.115,-0.318 -0.169,-0.576 -0.125,-0.742c-1.398,-0.162 0.464,3.773 -0.923,3.52c-0.881,-0.162 0.399,-1.528 -0.606,-2.095c0.415,0.959 -2.905,0.478 -4.353,2.605c-1.762,2.588 0.251,5.711 1.962,6.123c6.589,1.585 6.367,-3.697 5.968,-5.194c-0.011,-0.04 -0.023,-0.082 -0.036,-0.124c0,0 0,0 0,-0.001c-0.261,-1.908 -0.728,-2.219 -0.728,-2.979c0,-0.668 0.669,-1.125 0.603,-0.092c-0.066,1.034 0.887,1.338 1.495,1.216c-0.912,-0.364 0.608,-2.614 -0.182,-3.587" style="fill:#47282e;fill-rule:nonzero;"/></g><g><path d="M27.209,21.109c-0.249,0.528 -0.695,0.582 -1.139,1.245c0.039,-0.348 -0.023,-1.081 -0.359,-1.245c-0.024,1.622 -2.676,1.739 -1.034,4.745c-0.413,-2.606 3.037,-2.848 2.532,-4.745" style="fill:#47282e;fill-rule:nonzero;"/></g><g><path d="M27.26,18.214c-0.223,-0.901 0.726,-1.986 1.941,-1.596c1.121,0.361 2.277,2.111 0.526,4.119c0.408,-1.145 0.37,-2.529 -0.427,-2.111c-0.786,0.412 0.657,2.98 -0.893,3.588c0.549,-1.236 -0.16,-2.128 -0.727,-1.892c0.361,-0.589 0.428,-1.217 -0.42,-2.108" style="fill:#47282e;fill-rule:nonzero;"/></g><g><path d="M35.981,20.978c-1.846,1.236 -0.175,3.879 -0.739,4.041c0.641,-0.501 0.641,-1.317 0.641,-1.317c0.313,0.428 -0.529,3.328 -1.183,3.886c1.235,-0.458 2.908,-1.702 2.715,-4.106c-0.09,-1.113 -1.022,-1.745 -1.022,-1.745c0.081,0.432 -0.086,0.741 -0.412,0.624c-0.325,-0.117 -0.366,-0.793 0,-1.383" style="fill:#47282e;fill-rule:nonzero;"/></g><g><path d="M31.526,24.766c0.361,-0.457 0.287,-1.025 -0.145,-1.639c-0.251,-0.357 -0.035,-1.22 0.389,-0.643c0.517,0.704 0.739,0.006 0.124,-0.783c-0.301,-0.387 -0.741,-1.147 -0.463,-1.609c-0.648,0.611 0.031,1.592 -0.085,1.815c-0.112,0.216 -0.805,0.503 -0.432,1.122c0.447,0.74 -0.543,1.241 -0.215,1.641c0.328,0.399 0.827,0.096 0.827,0.096" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M30.221,31.191c2.352,0.667 3.953,1.078 4.693,0.873c0.74,-0.206 0.633,-1.152 0.633,-1.152c0,0 2.334,0.764 3.667,-1.111c0.964,-1.357 0.553,-3.608 0.553,-3.608c-1.468,1.075 -0.894,-2.063 0.478,-2.438c0.668,-0.183 1.282,0.375 1.282,0.375c0.168,-1.676 -0.841,-1.399 -0.841,-1.399c0.441,-0.872 -0.026,-3.139 -1.682,-3.139c0,0 1.887,0.73 0.48,3.139c-1.339,2.293 -0.4,3.738 -2.953,5.981c0.825,0.163 2.032,-1.255 2.032,-1.255c0.24,1.744 -1.442,2.578 -3.114,2.903c-1.893,0.368 -5.228,0.831 -5.228,0.831" style="fill:#5c4866;fill-rule:nonzero;"/></g><g><path d="M24.209,27.588c-1.268,-0.906 -2.889,-2.343 -3.104,-3.833c0.469,0.455 0.784,0.888 0.784,0.888c-0.315,-0.433 -0.746,-1.78 -0.373,-2.605c0.373,-0.825 1.424,-1.249 0.801,-3.034c0.361,0.21 0.661,0.473 0.661,0.473c0,0 0,-1.934 -1.668,-1.934c1.21,-1.116 2.55,-1.695 3.747,-1.8c-1.59,0.842 -2.005,1.905 -1.258,1.8c0.747,-0.105 1.888,-2.108 2.876,-1.99c0,0 -0.924,0.799 -1.199,1.667c-0.449,1.416 0.472,2.205 0.941,2.415c-0.846,0.105 -1.729,-0.103 -2.598,0.687c-1.502,1.364 -1.012,4.906 0.39,7.266" style="fill:#5c4866;fill-rule:nonzero;"/></g><g><path d="M24.873,29.973c-1.102,-0.482 -1.685,0.894 -0.893,1.326c1.029,0.561 1.975,-0.854 0.893,-1.326" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M25.568,29.032c-2.016,-1.041 -1.243,-4.605 -2.38,-4.791c0.583,-0.227 0.904,0.418 1.051,1.315c0.067,0.407 0.036,-0.556 0.48,-1.259c0.327,-0.516 0.887,-0.759 1.212,-0.41c-1.28,0.111 -0.967,3.422 -0.731,2.547c0.25,-0.926 0.72,-0.782 0.699,-1.159c0.047,0.677 -1.332,1.827 -0.331,3.757" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M36.501,24.518c-1.384,0.578 -0.956,1.952 -1.465,2.268c-0.51,0.316 -0.959,-0.915 -2.252,-0.269c1.264,0.171 1.293,2.232 0.999,2.484c-0.294,0.251 -0.176,-0.78 -0.822,-0.671c0.352,1.108 -1.528,2.123 -1.942,1.628c-0.413,-0.495 0.253,-0.726 0.459,-2.019c0.206,-1.292 -0.616,-2.401 -1.603,-2.613c0,0 0.667,0.528 0.447,0.968c-0.259,-0.47 -1.483,-1.099 -3.092,-0.408c-2.178,0.936 -1.427,3.73 -0.432,4.331c3.453,2.087 8.278,0.001 9.307,-1.216c1.029,-1.217 -0.012,-3.365 0.396,-4.483" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M27.128,30.351c-0.488,-0.203 -1.439,-0.927 -1.441,-1.823c-0.001,-0.566 0.275,-0.944 0.59,-1.111c-0.178,0.241 -0.253,0.8 0.021,0.783c0.365,-0.023 0.088,-0.938 0.873,-1.506c0.499,-0.359 1.419,-0.196 1.725,0.022c0.305,0.066 -0.022,-0.524 -0.022,-0.524c1.322,0.662 1.871,2.411 1.085,3.95c-0.103,-0.866 -0.122,-0.079 -0.736,0.209c-0.622,0.293 -1.397,0.293 -2.095,0" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M29.2,28.498c-0.005,0.093 -0.063,0.202 -0.144,0.325c-0.306,-0.932 -1.284,-0.763 -1.444,-1.162c-0.277,0.264 -1.01,0.819 -1.125,1.505c-0.116,0.69 0.481,1.235 0.991,1.321c0.312,0.08 0.683,0.032 0.996,-0.109c0.009,0.049 0.019,0.098 0.034,0.148c1.114,-0.391 0.883,-1.659 0.692,-2.028" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M36.53,27.13c0.801,-0.592 1.418,-1.538 1.379,-2.487c0.57,0.828 0.802,2.266 -1.379,2.487" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M23.819,20.322c-1.16,0.603 -1.809,1.716 -0.371,3.433c-0.291,-1.392 -0.227,-2.691 0.371,-3.433" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M30.221,26.873c0.219,0.354 0.388,0.731 0.353,1.462c0.292,-0.475 0.421,-1.067 -0.353,-1.462" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M36.105,29.001c0.996,-2 0.57,-2.953 0.996,-3.493c-0.877,0.346 -1.321,2.602 -1.737,3.521c-0.412,0.908 -1.228,1.103 -1.473,1.112c-0.628,0.024 -0.51,-0.571 -0.976,-0.589c0.397,0.611 -0.647,1.205 -2.262,1.253c-0.982,0.029 -1.923,0.021 -3.134,-0.513c-2.922,-1.291 -4.46,-2.812 -4.507,-5.298c-0.039,-2.099 1.504,-3.112 1.504,-3.112c-0.771,-0.175 -1.34,1.241 -1.34,1.241c0.272,-1.241 1.44,-2.474 0.628,-2.718c0.299,0.507 -0.47,0.749 -1.025,1.714c-0.661,1.148 -0.253,2.526 -0.253,2.526c-0.183,-0.683 -0.671,-0.847 -1.002,-0.847c0.305,0.245 0.428,1.121 1.255,2.582c0.812,1.435 1.999,2.692 1.651,2.621c-1.49,-0.302 -1.33,1.56 -0.375,2.312c-0.166,-0.672 -0.236,-1.495 1.557,-1.364c0,0 -0.487,0.136 -0.458,0.612c0.448,-0.431 1.476,-0.192 1.755,0c0.533,0.369 0.558,1.022 0.995,1.863c0.474,0.914 1.27,1.256 1.802,1.375c-0.486,-0.37 -0.734,-1.066 -0.372,-1.253c0.318,-0.163 0.486,0.459 0.861,0.703c-0.244,-0.397 0,-0.825 -0.641,-1.405c-0.192,-0.174 -0.303,-0.314 -0.327,-0.423c0.177,-0.443 3.274,0.198 5.74,-0.876c1.741,-0.759 1.759,-2.276 2.522,-2.621c-0.263,0.021 -1.013,0.331 -1.384,1.077" style="fill:#7d6687;fill-rule:nonzero;"/></g><g><path d="M24.488,31.274c-0.367,-0.031 -0.132,-1.051 0.289,-0.993c0.42,0.058 0.813,1.085 -0.289,0.993" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M23.645,25.673c0.004,0.914 0.778,2.533 1.831,3.487c-1.078,-0.726 -1.606,-0.608 -1.606,-1.179c0.108,0.274 0.387,0.279 0.364,0.073c-0.044,-0.413 -0.688,-0.597 -0.751,-1.181c-0.05,-0.459 0.157,-0.375 0.162,-1.2" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M34.914,29.659c-0.05,0.153 0.681,0.381 0.902,-0.338l-0.902,0.338Z" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M29.279,30.797c0.447,0.145 1.898,-0.388 2.199,-0.437c-0.399,0.392 0.519,0.572 1.003,-0.159c0.446,0.516 0.572,0.083 1.145,0.343c-0.955,-0.084 -1.156,1.01 -4.347,0.253" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M34.701,29.566c0.181,0.121 0.536,0.214 0.89,-0.104c0.514,-0.461 0.438,-1.336 0.94,-1.874c-0.554,0.311 -0.907,1.399 -0.984,1.58c0,-0.207 -0.017,-0.484 0.052,-0.665c-0.181,0.155 -0.177,0.959 -0.898,1.063" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M25.719,29.386c-0.519,-0.709 -1.599,-0.527 -2.498,-1.405c0.131,0.22 0.477,0.515 0.867,0.793c-0.329,-0.137 -0.678,-0.234 -1.011,-0.234c0.641,0.299 1.52,0.661 1.52,0.661c-0.477,-0.018 -1.122,0.615 -2.088,0.662c2.116,0.27 2.967,-0.281 2.967,-0.281c-1.105,-0.695 -0.617,-0.764 0.243,-0.196" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M23.121,25.522c-0.121,-0.448 -0.244,-1.136 -0.069,-1.761c0.241,-0.861 0.343,-1.535 0.187,-1.879c0.114,0.71 -0.412,1.258 -0.503,1.934c0.091,-0.676 0.021,-0.626 0.096,-1.059c-0.364,0.598 -0.406,1.645 0.289,2.765" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M24.38,24.335c-0.09,-0.352 -0.144,-1.202 0.593,-1.266c-0.235,0.46 -0.376,0.518 -0.593,1.266" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M25.584,23.186c-0.277,-0.501 -0.258,-1.463 0.237,-1.883c1.009,-0.856 2,-0.554 2.693,-1.321c-0.292,0.765 -1.966,1.506 -2.238,1.651c0.209,-0.065 0.399,0.135 0.34,0.405c-0.252,-0.386 -1.157,0.238 -1.032,1.148" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M25.074,22.466c-0.024,-0.333 0.214,-0.898 0.747,-0.651c-0.279,0.127 -0.656,0.223 -0.747,0.651" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M31.637,24.382c0,0.283 -0.23,0.514 -0.514,0.514c-0.284,0 -0.514,-0.231 -0.514,-0.514c0,-0.284 0.23,-0.515 0.514,-0.515c0.284,0 0.514,0.231 0.514,0.515" style="fill:#5c4866;fill-rule:nonzero;"/></g><g><path d="M26.05,30.768c-0.561,0 -1.158,-0.139 -1.461,0.751c0.378,-0.292 1.175,-0.251 1.461,-0.751" style="fill:#7d6687;fill-rule:nonzero;"/></g><g><path d="M28.013,16.414c1.233,-0.783 1.303,0.38 1.036,0.747c0.694,-0.373 0.597,-1.099 0.37,-1.215c0.227,0.116 0.77,0.949 1.54,0.726c-0.344,-0.173 -1.344,-1.617 -2.946,-0.258" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M35.878,25.99c-0.775,0.632 -0.514,1.458 -0.795,2.345c0.574,-0.65 0.655,-1.591 0.795,-2.345" style="fill:#7d6687;fill-rule:nonzero;"/></g><g><path d="M24.651,19.114c0.216,-0.227 0.825,-2.665 2.024,-3.561c-0.263,0.508 -0.657,2.783 -2.024,3.561" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M30.802,21.109c-0.661,-0.748 -0.123,-1.14 -0.277,-1.706c0.455,0.58 0.12,1.351 0.277,1.706" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M35.448,29.367c0,0.137 -0.111,0.249 -0.248,0.249c-0.137,0 -0.248,-0.112 -0.248,-0.249c0,-0.137 0.111,-0.248 0.248,-0.248c0.137,0 0.248,0.111 0.248,0.248" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M24.68,31.183c-0.238,-0.159 0.096,-0.354 0.228,-0.55c0.296,0.202 0.116,0.618 -0.228,0.55" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M29.245,27.741c0,0.108 -0.088,0.196 -0.196,0.196c-0.109,0 -0.197,-0.088 -0.197,-0.196c0,-0.108 0.088,-0.196 0.197,-0.196c0.108,0 0.196,0.088 0.196,0.196" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M28.45,26.522c0,0.123 -0.1,0.223 -0.223,0.223c-0.123,0 -0.222,-0.1 -0.222,-0.223c0,-0.123 0.099,-0.222 0.222,-0.222c0.123,0 0.223,0.099 0.223,0.222" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M33.263,27.34c0,0.088 -0.072,0.159 -0.159,0.159c-0.089,0 -0.16,-0.071 -0.16,-0.159c0,-0.088 0.071,-0.16 0.16,-0.16c0.087,0 0.159,0.072 0.159,0.16" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M32.606,26.873c0.294,-0.074 0.905,0.092 1.139,0.467c-0.281,-0.712 -0.887,-1.04 -1,-1.819c-0.254,0.672 0.176,1.18 0.176,1.18c-0.308,-0.103 -0.315,0.172 -0.315,0.172" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M25.191,27.3c-0.239,0.638 -0.074,1.219 0.166,1.57c0.418,0.615 0.729,0.687 0.84,0.857c0.19,0.29 -0.393,-0.212 -0.705,0.167c0,0 0.698,0.009 1.776,0.36c0.822,0.269 1.322,0.561 1.881,0.627c1.173,0.138 1.147,-0.19 2.329,-0.314c0,0 -0.616,-0.31 -1.156,-0.068c-0.564,0.253 -0.526,-0.145 0,-0.181c-0.363,-0.176 -0.324,0.023 -1.267,0.069c-0.828,0.04 -1.021,-0.059 -1.654,-0.312c-0.634,-0.253 -2.052,-0.982 -1.577,-1.627c-0.31,-0.111 -0.464,0.539 -0.435,0.071c0.04,-0.636 -0.195,-0.535 -0.198,-1.219" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M27.569,29.873c0.499,-0.257 0.715,0.762 1.302,0.956c0,0 0.168,2.175 -0.367,1.384c-0.495,-0.731 -1.522,-1.853 -0.932,-1.853c0.327,0 0.136,-0.456 -0.003,-0.487" style="fill:#7d6687;fill-rule:nonzero;"/></g><g><path d="M27.015,30.467c1.261,0.33 1.73,0.965 2.146,2.031c-1.35,-0.263 -1.497,-1.439 -2.146,-2.031" style="fill:#45314a;fill-rule:nonzero;"/></g><g><path d="M27.789,30.914c0.356,-0.021 0.96,0.467 1.013,0.835c-1.159,-0.04 -1.288,-0.818 -1.013,-0.835" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M28.36,31.439c-0.32,0 -0.375,-0.418 -0.375,-0.418c0.461,0.069 0.64,0.418 0.375,0.418" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M27.26,30.303c1.321,0.249 1.857,0.941 2.427,1.571c-0.6,-0.326 -0.827,-0.579 -0.827,-0.579c0.471,0.549 0.803,1.373 1.25,1.66c0,0 -1.032,-0.662 -1.545,-1.426c-0.682,-1.016 -1.305,-1.226 -1.305,-1.226" style="fill:#b7add6;fill-rule:nonzero;"/></g><g><path d="M25.852,31.062c0,0.082 -0.067,0.149 -0.149,0.149c-0.082,0 -0.149,-0.067 -0.149,-0.149c0,-0.082 0.067,-0.149 0.149,-0.149c0.082,0 0.149,0.067 0.149,0.149" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M28.556,32.749c0,0.139 -0.112,0.252 -0.251,0.252c-0.139,0 -0.251,-0.113 -0.251,-0.252c0,-0.138 0.112,-0.251 0.251,-0.251c0.139,0 0.251,0.113 0.251,0.251" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M28.056,31.997c0,0.071 -0.057,0.128 -0.128,0.128c-0.07,0 -0.127,-0.057 -0.127,-0.128c0,-0.07 0.057,-0.127 0.127,-0.127c0.071,0 0.128,0.057 0.128,0.127" style="fill:#ede8ad;fill-rule:nonzero;"/></g><g><path d="M32.39,24.284c-0.931,0 -1.242,0.31 -1.242,1.241c0,-0.931 -0.31,-1.241 -1.241,-1.241c0.931,0 1.241,-0.311 1.241,-1.242c0,0.931 0.311,1.242 1.242,1.242" style="fill:#fff;fill-rule:nonzero;"/></g><g><path d="M34.796,28.335c0.045,0.242 0,0.518 -0.327,0.659c0.153,-0.202 0.286,-0.515 0.327,-0.659" style="fill:#ff005e;fill-rule:nonzero;"/></g><g><path d="M24.329,20.322c0.087,-0.284 0.641,-0.264 0.744,-0.855c-0.224,0.427 -0.799,0.091 -0.744,0.855" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M29.784,31.826c0.838,-0.197 1.154,1.051 1.339,1.303c-0.451,-0.269 -0.902,-1.088 -1.339,-1.303" style="fill:#7d6687;fill-rule:nonzero;"/></g><g><path d="M21.524,29.57c-0.578,0.109 -0.695,0.773 -0.487,1.297c-0.02,-0.604 0.524,-0.784 0.487,-1.297" style="fill:#282a1e;fill-rule:nonzero;"/></g><g><path d="M29.053,19.114c0.223,-0.754 0.829,-0.995 1.142,-0.218c-0.462,-0.203 -0.777,-0.603 -1.142,0.218" style="fill:#911740;fill-rule:nonzero;"/></g><g><path d="M43.805,22.618c0,0.449 -0.364,0.813 -0.813,0.813c-0.449,0 -0.813,-0.364 -0.813,-0.813c0,-0.449 0.364,-0.813 0.813,-0.813c0.449,0 0.813,0.364 0.813,0.813" style="fill:#dcdcdc;fill-opacity:0.44;fill-rule:nonzero;"/></g><g><path d="M36.878,31.997c0,0.449 -0.364,0.813 -0.813,0.813c-0.449,0 -0.813,-0.364 -0.813,-0.813c0,-0.449 0.364,-0.813 0.813,-0.813c0.449,0 0.813,0.364 0.813,0.813" style="fill:#5c4866;fill-rule:nonzero;"/></g><g><path d="M44.657,22.555c-1.297,0 -1.729,0.432 -1.729,1.729c0,-1.297 -0.433,-1.729 -1.729,-1.729c1.296,0 1.729,-0.433 1.729,-1.729c0,1.296 0.432,1.729 1.729,1.729" style="fill:#fff;fill-rule:nonzero;"/></g><g><path d="M37.587,31.996c-1.136,0 -1.515,0.379 -1.515,1.515c0,-1.136 -0.378,-1.515 -1.514,-1.515c1.136,0 1.514,-0.379 1.514,-1.514c0,1.135 0.379,1.514 1.515,1.514" style="fill:#fff;fill-rule:nonzero;"/></g></g><g id="Porthole"><g><g><g><path d="M56.002,9.243l0,-5.233l-48.003,0l-0.013,0c0,0 -0.127,0.006 -0.349,0.016c-0.221,0.009 -0.541,0.054 -0.915,0.145c-0.748,0.182 -1.712,0.641 -2.433,1.385c-0.743,0.72 -1.214,1.687 -1.409,2.446c-0.099,0.379 -0.149,0.706 -0.164,0.933c-0.015,0.228 -0.023,0.358 -0.023,0.358c0,0 0.003,0.144 0.005,0.288c0.006,0.143 0.012,0.287 0.012,0.287l0,0.008l2.536,31.081l0.001,0.013c0,0 0.016,0.129 0.044,0.354c0.031,0.224 0.092,0.547 0.214,0.918c0.113,0.375 0.304,0.792 0.551,1.212c0.256,0.414 0.58,0.82 0.954,1.174c0.377,0.35 0.802,0.645 1.228,0.87c0.431,0.214 0.854,0.375 1.23,0.457c0.374,0.092 0.694,0.129 0.916,0.14c0.222,0.009 0.349,0.015 0.349,0.015l42.527,0l0.012,-0.001c0,0 0.127,-0.005 0.35,-0.014c0.221,-0.012 0.541,-0.049 0.915,-0.141c0.376,-0.083 0.799,-0.244 1.23,-0.458c0.425,-0.226 0.85,-0.521 1.227,-0.872c0.374,-0.355 0.697,-0.761 0.953,-1.175c0.246,-0.42 0.438,-0.837 0.55,-1.212c0.121,-0.372 0.183,-0.694 0.213,-0.918c0.028,-0.225 0.043,-0.354 0.043,-0.354l0.002,-0.012l2.535,-31.08l0,-0.01c0,0 0.006,-0.144 0.012,-0.288l0.005,-0.287c0,0 -0.006,-0.174 -0.038,-0.521c-0.047,-0.344 -0.128,-0.872 -0.407,-1.513c-0.274,-0.635 -0.737,-1.396 -1.539,-2.05c-0.781,-0.658 -1.958,-1.188 -3.321,-1.194l0,5.233c0.088,0.005 0.143,0.067 0.159,0.11c0.021,0.035 0.008,0.059 0.015,0.059c-0.004,0 -0.005,0.023 -0.001,0.023l0,0.004l-2.535,31.08l0,0.003c-0.008,0.002 -0.006,0.149 -0.122,0.252c-0.11,0.109 -0.254,0.095 -0.256,0.102l-0.002,0.001l-42.521,0c-0.002,-0.009 -0.147,0.007 -0.257,-0.103c-0.115,-0.102 -0.114,-0.25 -0.121,-0.252l-0.001,-0.001l-2.535,-31.079l0,-0.007c0.004,0 0.003,-0.023 -0.001,-0.023c0.009,-0.002 -0.004,-0.06 0.055,-0.117c0.052,-0.056 0.111,-0.043 0.119,-0.052l0.001,0c0,0 16.001,0 48.003,0Z" style="fill-rule:nonzero;"/></g></g></g><g><path d="M40.78,7.868c-0.91,0 -1.789,0.331 -2.474,0.93l-0.993,0.869c-0.435,0.381 -0.995,0.591 -1.574,0.591l-3.955,0l0,0l-3.954,0c-0.579,0 -1.139,-0.21 -1.575,-0.591l-0.993,-0.869c-0.684,-0.599 -1.563,-0.93 -2.473,-0.93l-7.402,0l0,2.646l8.447,0c0.738,0 1.45,0.269 2.003,0.756l0.608,0.535c0.475,0.418 1.087,0.649 1.72,0.649l7.238,0c0.634,0 1.245,-0.231 1.721,-0.649l0.607,-0.535c0.554,-0.487 1.266,-0.756 2.004,-0.756l8.875,0l0,-2.646l-7.83,0Zm-5.06,28.567l-7.872,0c-0.537,0 -1.05,0.222 -1.417,0.614l-0.789,0.843c-0.394,0.42 -0.944,0.659 -1.521,0.659l-8.734,0l0,2.148l7.901,0c0.689,0 1.344,-0.295 1.801,-0.811l0.77,-0.868c0.465,-0.525 1.131,-0.825 1.832,-0.825l8.187,0c0.7,0 1.367,0.3 1.831,0.824l0.77,0.869c0.457,0.516 1.113,0.811 1.802,0.811l8.329,0l0,-2.148l-9.163,0c-0.576,0 -1.127,-0.239 -1.521,-0.66l-0.788,-0.842c-0.367,-0.392 -0.88,-0.614 -1.418,-0.614Z" style="fill-rule:nonzero;"/></g><g><path d="M46.921,7.868l0,2.646l3.737,0c0.831,0 1.486,0.706 1.423,1.535l-1.911,25.318c-0.05,0.668 -0.606,1.184 -1.276,1.184l-1.973,0l0,2.148l5.522,0c0.939,0 1.722,-0.72 1.8,-1.656l2.43,-29.217c0.088,-1.054 -0.744,-1.958 -1.801,-1.958l-7.951,0Z" style="fill-rule:nonzero;"/></g><g><path d="M8.696,7.868c-1.057,0 -1.888,0.904 -1.801,1.958l2.431,29.217c0.078,0.936 0.86,1.656 1.799,1.656l5.511,0l0,-1.231c-0.005,-0.306 -0.01,-0.611 -0.014,-0.917l-1.947,0c-0.67,0 -1.226,-0.516 -1.277,-1.184l-1.911,-25.318c-0.062,-0.829 0.593,-1.535 1.423,-1.535l3.71,0l0,-2.646l-7.924,0Z" style="fill-rule:nonzero;"/></g><g><g><g><path d="M51.259,10.164l0,-0.429l-11.417,0l-0.007,0c0,0 -0.152,-0.003 -0.376,0.023c-0.226,0.024 -0.523,0.09 -0.804,0.198c-0.282,0.109 -0.545,0.261 -0.728,0.394c-0.184,0.131 -0.294,0.234 -0.294,0.234l-0.005,0.005l-0.622,0.559l-0.005,0.004c0,0 -0.332,0.309 -0.755,0.463c-0.417,0.17 -0.87,0.164 -0.87,0.164l-0.006,0l-3.8,0l0,0.214l0.214,-0.214l-3.643,0c0,0 -0.452,0.007 -0.869,-0.163c-0.423,-0.155 -0.756,-0.463 -0.756,-0.463l-0.004,-0.004l-0.622,-0.559l-0.005,-0.005c0,0 -0.11,-0.103 -0.294,-0.234c-0.183,-0.133 -0.446,-0.285 -0.728,-0.394c-0.282,-0.109 -0.578,-0.175 -0.803,-0.199c-0.225,-0.026 -0.377,-0.023 -0.377,-0.023l-0.007,0l-11.362,0l-0.007,0c0,0 -0.044,0.002 -0.12,0.006c-0.076,0.004 -0.186,0.018 -0.313,0.053c-0.255,0.063 -0.574,0.236 -0.807,0.497c-0.236,0.26 -0.375,0.592 -0.415,0.85c-0.046,0.258 -0.025,0.432 -0.025,0.432l0,0.008l1.971,26.68l0.001,0.008c0,0 0.005,0.144 0.069,0.351c0.06,0.207 0.202,0.466 0.412,0.666c0.209,0.2 0.476,0.33 0.689,0.377c0.211,0.052 0.358,0.045 0.358,0.045l9.757,0c0,0 0.122,0.003 0.302,-0.021c0.18,-0.022 0.417,-0.082 0.638,-0.18c0.221,-0.098 0.423,-0.234 0.56,-0.352c0.137,-0.116 0.222,-0.213 0.222,-0.213l0.005,-0.005l0.935,-1.144l0.005,-0.005c0,0 0.054,-0.063 0.161,-0.153c0.104,-0.09 0.257,-0.192 0.424,-0.266c0.167,-0.074 0.345,-0.119 0.481,-0.136c0.136,-0.018 0.226,-0.016 0.226,-0.016l0.007,0l7.866,0.052l0.007,0c0,0 0.373,-0.006 0.709,0.151c0.166,0.074 0.32,0.176 0.424,0.266c0.105,0.089 0.163,0.155 0.163,0.155l0.004,0.004l0.935,1.092l0.005,0.006c0,0 0.328,0.373 0.78,0.563c0.221,0.099 0.458,0.159 0.638,0.181c0.18,0.024 0.302,0.021 0.302,0.021l0.007,0l9.75,0c0,0 0.147,0.007 0.358,-0.044c0.212,-0.048 0.481,-0.177 0.69,-0.377c0.21,-0.199 0.352,-0.459 0.412,-0.666c0.064,-0.206 0.069,-0.351 0.069,-0.351l0.001,-0.008l1.972,-26.679l0,-0.008c0,0 0.001,-0.058 0.004,-0.174c-0.009,-0.115 -0.016,-0.292 -0.093,-0.512c-0.073,-0.22 -0.218,-0.483 -0.474,-0.722c-0.258,-0.23 -0.647,-0.432 -1.12,-0.432l0,0.429c0.352,0.001 0.637,0.15 0.831,0.322c0.192,0.179 0.302,0.376 0.356,0.542c0.059,0.165 0.063,0.299 0.071,0.386c-0.002,0.087 -0.004,0.131 -0.004,0.131l0,0.006l-1.971,26.68l-0.001,0.005c0,0 -0.004,0.107 -0.051,0.257c-0.043,0.15 -0.147,0.338 -0.299,0.483c-0.151,0.144 -0.343,0.237 -0.495,0.271c-0.151,0.036 -0.256,0.032 -0.256,0.032l-9.749,0l-0.007,0c0,0 -0.403,0.006 -0.766,-0.165c-0.18,-0.08 -0.346,-0.192 -0.458,-0.289c-0.114,-0.097 -0.176,-0.168 -0.176,-0.168l-0.005,-0.004l-0.934,-1.093l-0.006,-0.005c0,0 -0.309,-0.349 -0.733,-0.528c-0.208,-0.092 -0.43,-0.148 -0.599,-0.168c-0.169,-0.022 -0.282,-0.02 -0.282,-0.02l-0.007,0l-7.867,-0.051l-0.007,0c0,0 -0.115,-0.003 -0.284,0.019c-0.169,0.021 -0.391,0.077 -0.598,0.169c-0.208,0.092 -0.398,0.22 -0.527,0.331c-0.128,0.108 -0.208,0.199 -0.208,0.199l-0.005,0.006l-0.935,1.143l-0.005,0.005c0,0 -0.059,0.068 -0.174,0.166c-0.113,0.097 -0.278,0.208 -0.459,0.289c-0.362,0.17 -0.766,0.164 -0.766,0.164l-9.755,0c0,0 -0.106,0.004 -0.257,-0.033c-0.151,-0.033 -0.343,-0.126 -0.495,-0.271c-0.152,-0.145 -0.255,-0.333 -0.298,-0.484c-0.046,-0.15 -0.051,-0.256 -0.051,-0.256l0,-0.006l-1.972,-26.679l0,-0.006c0,0 -0.015,-0.133 0.019,-0.326c0.031,-0.195 0.135,-0.444 0.311,-0.639c0.176,-0.196 0.413,-0.324 0.602,-0.37c0.188,-0.05 0.32,-0.045 0.32,-0.045l0.007,0l11.362,0l0.006,0c0,0 0.132,-0.002 0.327,0.021c0.196,0.021 0.454,0.078 0.699,0.173c0.499,0.182 0.89,0.547 0.89,0.547l0.005,0.004l0.622,0.559l0.005,0.005c0,0 0.39,0.362 0.887,0.544c0.245,0.094 0.502,0.15 0.697,0.171c0.195,0.023 0.327,0.02 0.327,0.02l0.007,0l3.851,0l0,-0.215c-0.072,0.072 -0.143,0.143 -0.215,0.215l3.593,0c0,0 0.131,0.002 0.327,-0.02c0.195,-0.021 0.452,-0.078 0.697,-0.172c0.497,-0.182 0.887,-0.544 0.887,-0.544l0.005,-0.005l0.622,-0.559l0.005,-0.004c0,0 0.391,-0.365 0.89,-0.547c0.245,-0.095 0.503,-0.152 0.699,-0.173c0.195,-0.022 0.326,-0.02 0.326,-0.02l11.424,0Z" style="fill-rule:nonzero;"/></g></g></g><g><g><g><path d="M27.843,35.764l7.882,0c0.709,0 1.418,0.315 1.891,0.827l0.788,0.828c0.276,0.276 0.67,0.473 1.025,0.473l9.458,0c0.315,0 0.591,-0.276 0.591,-0.592l1.931,-25.299c0,-0.197 -0.039,-0.434 -0.197,-0.552c-0.158,-0.157 -0.355,-0.276 -0.552,-0.276l-10.916,0c-0.591,0 -1.142,0.237 -1.576,0.592l-0.591,0.551c-0.591,0.513 -1.379,0.828 -2.167,0.828l-7.251,0c-0.789,0 -1.577,-0.315 -2.168,-0.828l-0.591,-0.551c-0.433,-0.355 -0.985,-0.592 -1.576,-0.592l-10.916,0c-0.197,0 -0.394,0.119 -0.552,0.276c-0.157,0.118 -0.197,0.355 -0.197,0.552l1.931,25.299c0,0.316 0.276,0.592 0.591,0.592l9.458,0c0.355,0 0.749,-0.197 1.025,-0.473l0.788,-0.828c0.473,-0.512 1.182,-0.827 1.891,-0.827Zm21.044,2.206l-9.458,0c-0.394,0 -0.788,-0.197 -1.064,-0.473l-0.788,-0.866c-0.473,-0.513 -1.143,-0.789 -1.852,-0.789l-7.882,0c-0.709,0 -1.379,0.276 -1.852,0.789l-0.788,0.866c-0.276,0.276 -0.67,0.473 -1.064,0.473l-9.458,0c-0.354,0 -0.67,-0.275 -0.67,-0.63l-1.931,-25.339c0,-0.236 0.079,-0.434 0.237,-0.631c0.157,-0.157 0.355,-0.275 0.591,-0.275l10.916,0c0.591,0 1.182,0.236 1.615,0.63l0.592,0.512c0.591,0.513 1.339,0.828 2.128,0.828l7.251,0c0.788,0 1.536,-0.315 2.128,-0.828l0.591,-0.512c0.433,-0.394 1.024,-0.63 1.615,-0.63l10.916,0c0.237,0 0.434,0.118 0.591,0.275c0.158,0.197 0.237,0.395 0.237,0.631l-1.931,25.339c0,0.355 -0.315,0.63 -0.67,0.63Z" style="fill:#fff;fill-rule:nonzero;"/></g></g></g><g><g><g><path d="M27.851,35.488l7.866,0c0.848,0 1.658,0.347 2.237,0.964l0.771,0.887c0.192,0.193 0.462,0.308 0.732,0.308l9.447,0c0.077,0 0.154,-0.077 0.154,-0.192l1.928,-25.68c0,-0.077 -0.038,-0.154 -0.077,-0.232c-0.077,-0.077 -0.154,-0.115 -0.27,-0.115l-10.912,0c-0.463,0 -0.925,0.193 -1.272,0.501l-0.617,0.54c-0.656,0.617 -1.543,0.925 -2.429,0.925l-7.249,0c-0.887,0 -1.774,-0.308 -2.429,-0.925l-0.617,-0.54c-0.347,-0.308 -0.81,-0.501 -1.273,-0.501l-10.912,0c-0.115,0 -0.193,0.038 -0.27,0.115c-0.038,0.078 -0.077,0.155 -0.077,0.232l1.928,25.68c0,0.115 0.077,0.192 0.154,0.192l9.447,0c0.27,0 0.54,-0.115 0.733,-0.308l0.771,-0.887c0.578,-0.617 1.388,-0.964 2.236,-0.964Zm21.053,2.236l-9.447,0c-0.308,0 -0.578,-0.115 -0.771,-0.347l-0.81,-0.848c-0.539,-0.617 -1.349,-0.964 -2.159,-0.964l-7.866,0c-0.809,0 -1.619,0.347 -2.159,0.964l-0.81,0.848c-0.193,0.232 -0.462,0.347 -0.771,0.347l-9.447,0c-0.115,0 -0.231,-0.115 -0.231,-0.231l-1.928,-25.68c0,-0.115 0.039,-0.231 0.116,-0.308c0.077,-0.116 0.154,-0.154 0.308,-0.154l10.912,0c0.501,0 0.964,0.192 1.311,0.501l0.617,0.54c0.656,0.617 1.504,0.925 2.391,0.925l7.249,0c0.886,0 1.735,-0.308 2.39,-0.925l0.617,-0.54c0.347,-0.309 0.848,-0.501 1.311,-0.501l10.912,0c0.116,0 0.232,0.038 0.309,0.154c0.077,0.077 0.115,0.193 0.115,0.308l-1.928,25.68c0,0.116 -0.115,0.231 -0.231,0.231Z" style="fill:#eafaff;fill-rule:nonzero;"/></g></g></g><g><path d="M7.594,34.779l-0.023,0.087l-0.022,0.087c0,0 -0.007,0.03 -0.023,0.087c0.552,0.133 1.063,0.129 1.523,0.154c0.461,0.02 0.878,0.062 1.249,0.155c0.748,0.173 1.272,0.566 1.644,0.91c0.09,0.091 0.174,0.176 0.253,0.255c0.076,0.084 0.139,0.168 0.201,0.242c0.061,0.075 0.117,0.144 0.168,0.206c0.045,0.067 0.086,0.128 0.122,0.181c0.146,0.215 0.218,0.323 0.218,0.323l0.004,0.006c0,0 0.128,0.218 0.32,0.546c0.176,0.334 0.414,0.782 0.583,1.254c0.178,0.469 0.298,0.955 0.339,1.322c0.045,0.367 0.024,0.608 0.024,0.608c0,0 -0.004,0.049 -0.014,0.146c-0.011,0.089 -0.033,0.256 -0.091,0.397c0.054,0.027 0.081,0.04 0.081,0.04l0.081,0.04l0.081,0.039c0,0 0.027,0.014 0.081,0.04c0.101,-0.246 0.107,-0.398 0.126,-0.514c0.01,-0.111 0.015,-0.166 0.015,-0.166c0,0 0.023,-0.274 -0.026,-0.672c-0.045,-0.399 -0.173,-0.915 -0.359,-1.406c-0.178,-0.495 -0.423,-0.957 -0.605,-1.303c-0.198,-0.337 -0.329,-0.561 -0.329,-0.561l-0.004,-0.006c0,0 -0.076,-0.113 -0.229,-0.339c-0.038,-0.056 -0.081,-0.119 -0.129,-0.19c-0.053,-0.066 -0.113,-0.139 -0.178,-0.219c-0.065,-0.079 -0.132,-0.168 -0.213,-0.257c-0.085,-0.085 -0.176,-0.177 -0.274,-0.274c-0.398,-0.372 -0.985,-0.808 -1.804,-0.998c-0.404,-0.101 -0.85,-0.145 -1.318,-0.165c-0.467,-0.024 -0.963,-0.025 -1.449,-0.142c-0.015,0.058 -0.023,0.087 -0.023,0.087Z" style="fill-rule:nonzero;"/></g><g><g><g><path d="M54.506,8.364l0,-0.829l-13.867,0l-0.008,0c0,0 -0.185,-0.004 -0.459,0.027c-0.275,0.029 -0.637,0.106 -0.983,0.236c-0.345,0.13 -0.669,0.311 -0.894,0.47c-0.227,0.158 -0.363,0.283 -0.363,0.283l-0.006,0.004l-0.972,0.851l-0.004,0.004c0,0 -0.262,0.236 -0.593,0.353c-0.325,0.129 -0.678,0.123 -0.678,0.123l-0.006,0.001l-4.303,0l0,0.414c0.138,-0.138 0.276,-0.276 0.414,-0.414l-3.895,0c0,0 -0.353,0.005 -0.678,-0.124c-0.331,-0.118 -0.592,-0.354 -0.592,-0.354l-0.005,-0.004l-0.972,-0.85l-0.006,-0.005c0,0 -0.136,-0.124 -0.363,-0.282c-0.226,-0.16 -0.55,-0.34 -0.895,-0.47c-0.345,-0.13 -0.707,-0.207 -0.982,-0.236c-0.275,-0.031 -0.459,-0.027 -0.459,-0.027l-13.872,0l-0.008,0c0,0 -0.056,0.003 -0.155,0.008c-0.098,0.004 -0.239,0.023 -0.403,0.067c-0.165,0.038 -0.348,0.118 -0.534,0.219c-0.182,0.109 -0.361,0.249 -0.516,0.413c-0.151,0.168 -0.276,0.357 -0.369,0.548c-0.085,0.193 -0.15,0.382 -0.175,0.55c-0.03,0.167 -0.037,0.31 -0.034,0.408c0.004,0.098 0.005,0.154 0.005,0.154l0.001,0.008l2.392,28.752l0,0.008c0,0 0.007,0.05 0.018,0.138c0.012,0.088 0.037,0.213 0.085,0.357c0.089,0.292 0.296,0.655 0.597,0.93c0.299,0.277 0.678,0.453 0.976,0.517c0.148,0.037 0.275,0.051 0.363,0.055c0.089,0.004 0.139,0.007 0.139,0.007l0.008,0l11.972,0c0,0 0.147,0.003 0.365,-0.026c0.219,-0.027 0.505,-0.099 0.773,-0.22c0.268,-0.12 0.512,-0.287 0.677,-0.432c0.166,-0.145 0.261,-0.257 0.261,-0.257l0.005,-0.005l0.753,-0.85l0.004,-0.005c0,0 0.069,-0.08 0.188,-0.184c0.117,-0.104 0.293,-0.223 0.485,-0.31c0.192,-0.086 0.397,-0.138 0.553,-0.157c0.156,-0.02 0.262,-0.018 0.262,-0.018l4.446,0l0,-0.415c-0.139,0.139 -0.277,0.277 -0.415,0.415l4.026,0l0.006,0c0,0 0.106,-0.002 0.262,0.018c0.156,0.019 0.362,0.071 0.554,0.158c0.191,0.086 0.367,0.205 0.485,0.31c0.118,0.103 0.187,0.184 0.187,0.184l0.004,0.005l0.753,0.85l0.005,0.005c0,0 0.095,0.112 0.262,0.256c0.164,0.146 0.409,0.313 0.676,0.433c0.268,0.12 0.555,0.193 0.773,0.219c0.218,0.029 0.366,0.026 0.366,0.026l0.007,0l11.965,0l0.008,0c0,0 0.05,-0.003 0.139,-0.007c0.088,-0.004 0.215,-0.019 0.363,-0.055c0.298,-0.065 0.676,-0.241 0.976,-0.518c0.3,-0.275 0.507,-0.638 0.596,-0.93c0.048,-0.144 0.073,-0.27 0.084,-0.357c0.012,-0.088 0.018,-0.138 0.018,-0.138l0.001,-0.008l2.392,-28.752l0,-0.008c0,0 0.003,-0.075 0.007,-0.225c-0.011,-0.15 -0.019,-0.38 -0.12,-0.666c-0.097,-0.285 -0.288,-0.624 -0.624,-0.928c-0.336,-0.295 -0.842,-0.547 -1.449,-0.547l0,0.829c0.381,0.001 0.689,0.157 0.901,0.34c0.208,0.191 0.33,0.401 0.389,0.577c0.063,0.178 0.065,0.321 0.074,0.413c-0.003,0.094 -0.004,0.142 -0.004,0.142l0,0.005l-2.392,28.751l-0.001,0.006c0,0 -0.006,0.128 -0.064,0.308c-0.054,0.182 -0.183,0.406 -0.37,0.578c-0.187,0.172 -0.421,0.282 -0.606,0.322c-0.185,0.043 -0.313,0.038 -0.313,0.038l-0.005,0.001l-11.971,0c0,0 -0.422,0.007 -0.799,-0.172c-0.385,-0.164 -0.659,-0.484 -0.659,-0.484l-0.005,-0.005l-0.753,-0.849l-0.005,-0.006c0,0 -0.096,-0.114 -0.264,-0.26c-0.168,-0.148 -0.415,-0.317 -0.687,-0.439c-0.271,-0.123 -0.562,-0.196 -0.784,-0.223c-0.221,-0.029 -0.37,-0.026 -0.37,-0.026l-4.448,0l0,0.414c0.138,-0.138 0.276,-0.276 0.414,-0.414l-4.025,0l-0.007,0c0,0 -0.15,-0.003 -0.371,0.026c-0.221,0.027 -0.512,0.1 -0.784,0.223c-0.271,0.122 -0.519,0.291 -0.686,0.438c-0.169,0.147 -0.265,0.261 -0.265,0.261l-0.005,0.005l-0.753,0.85l-0.004,0.005c0,0 -0.275,0.32 -0.659,0.484c-0.378,0.179 -0.799,0.172 -0.799,0.172l-0.006,0l-11.965,0l-0.006,0c0,0 -0.128,0.004 -0.313,-0.039c-0.184,-0.039 -0.419,-0.149 -0.606,-0.321c-0.187,-0.173 -0.316,-0.397 -0.37,-0.578c-0.058,-0.18 -0.065,-0.308 -0.065,-0.308l0,-0.006l-2.392,-28.751l0,-0.006c0,0 -0.018,-0.142 0.018,-0.35c0.032,-0.207 0.146,-0.473 0.338,-0.682c0.192,-0.209 0.448,-0.344 0.653,-0.392c0.101,-0.028 0.189,-0.041 0.25,-0.042c0.062,-0.004 0.097,-0.006 0.097,-0.006l0.006,0l13.87,0c0,0 0.148,-0.003 0.367,0.022c0.22,0.022 0.509,0.084 0.784,0.188c0.276,0.103 0.535,0.248 0.715,0.375c0.181,0.126 0.29,0.225 0.29,0.225l0.005,0.005l0.972,0.85l0.006,0.005c0,0 0.374,0.337 0.845,0.505c0.465,0.184 0.968,0.176 0.968,0.176l4.312,0l0,-0.414l-0.415,0.414l3.896,0c0,0 0.504,0.008 0.969,-0.176c0.471,-0.167 0.845,-0.504 0.845,-0.504l0.006,-0.005l0.972,-0.851l0.005,-0.004c0,0 0.109,-0.1 0.291,-0.226c0.179,-0.127 0.438,-0.271 0.713,-0.375c0.276,-0.104 0.565,-0.166 0.785,-0.188c0.219,-0.025 0.366,-0.022 0.366,-0.022l13.874,0Z" style="fill-rule:nonzero;"/></g></g></g><g><path d="M56.673,9.825l-2.43,29.218c-0.078,0.936 -0.861,1.655 -1.8,1.655l-12.162,0c-0.689,0 -1.345,-0.294 -1.802,-0.81l-0.769,-0.869c-0.465,-0.524 -1.132,-0.824 -1.832,-0.824l-8.187,0c-0.701,0 -1.367,0.3 -1.832,0.824l-0.77,0.869c-0.456,0.516 -1.112,0.81 -1.801,0.81l-12.163,0c-0.939,0 -1.721,-0.719 -1.799,-1.655l-2.431,-29.218c-0.087,-1.053 0.744,-1.957 1.801,-1.957l14.093,0c0.91,0 1.789,0.331 2.473,0.93l0.993,0.869c0.436,0.381 0.996,0.591 1.575,0.591l3.954,0l0,0l3.955,0c0.579,0 1.139,-0.21 1.574,-0.591l0.993,-0.869c0.685,-0.599 1.564,-0.93 2.474,-0.93l14.092,0c1.058,0 1.889,0.904 1.801,1.957m-0.652,-4.688l-48.474,0.001c-2.036,0 -3.637,1.74 -3.468,3.768l2.569,30.892c0.17,2.053 1.887,3.632 3.946,3.632l42.38,0c2.06,0 3.776,-1.58 3.947,-3.632l2.569,-30.892c0.169,-2.029 -1.433,-3.769 -3.469,-3.769" style="fill:#fff;fill-rule:nonzero;"/></g><g><g><g><path d="M55.18,7.083l0,-0.842l-15.6,0c0,0 -0.462,-0.006 -0.888,0.163c-0.432,0.154 -0.774,0.463 -0.774,0.463l-0.006,0.005l-1.565,1.369l-0.004,0.004c0,0 -0.2,0.18 -0.452,0.27c-0.249,0.098 -0.518,0.095 -0.518,0.095l-0.006,0l-4.004,0l0,0.421c0.141,-0.141 0.281,-0.281 0.421,-0.421l-3.588,0c0,0 -0.269,0.004 -0.518,-0.095c-0.252,-0.089 -0.452,-0.27 -0.452,-0.27l-0.005,-0.004l-1.565,-1.369l-0.005,-0.005c0,0 -0.343,-0.309 -0.775,-0.463c-0.426,-0.169 -0.887,-0.163 -0.887,-0.163l-0.008,0l-15.589,0l-0.007,0c0,0 -0.074,0.004 -0.205,0.011c-0.129,0.003 -0.315,0.031 -0.533,0.082c-0.433,0.105 -0.996,0.361 -1.416,0.79c-0.437,0.411 -0.709,0.965 -0.823,1.396c-0.057,0.216 -0.089,0.402 -0.095,0.532c-0.01,0.13 -0.015,0.205 -0.015,0.205l0.009,0.33l0.001,0.007l2.471,29.714l0.001,0.008c0,0 0.01,0.075 0.027,0.208c0.018,0.131 0.055,0.32 0.128,0.537c0.065,0.22 0.184,0.462 0.328,0.709c0.154,0.242 0.348,0.479 0.571,0.689c0.227,0.204 0.481,0.376 0.734,0.51c0.259,0.122 0.509,0.22 0.734,0.266c0.223,0.053 0.414,0.076 0.547,0.081c0.133,0.007 0.209,0.01 0.209,0.01l0.007,0l13.177,0l0.009,0c0,0 0.116,0.002 0.289,-0.021c0.173,-0.021 0.4,-0.079 0.611,-0.175c0.212,-0.095 0.405,-0.227 0.536,-0.342c0.131,-0.114 0.206,-0.204 0.206,-0.204l0.005,-0.005l1.007,-1.136l0.004,-0.005c0,0 0.248,-0.289 0.596,-0.438c0.342,-0.162 0.723,-0.155 0.723,-0.155l3.978,0l0,-0.422c-0.141,0.141 -0.281,0.281 -0.422,0.422l3.55,0l0.006,0c0,0 0.382,-0.007 0.723,0.155c0.349,0.149 0.597,0.438 0.597,0.438l0.004,0.005l1.006,1.136l0.005,0.005c0,0 0.076,0.09 0.207,0.204c0.13,0.115 0.324,0.247 0.536,0.342c0.211,0.096 0.438,0.154 0.611,0.175c0.172,0.023 0.289,0.021 0.289,0.021l13.192,0c0,0 0.076,-0.004 0.21,-0.01c0.133,-0.005 0.324,-0.028 0.546,-0.081c0.226,-0.046 0.476,-0.144 0.734,-0.266c0.254,-0.134 0.508,-0.306 0.735,-0.511c0.223,-0.209 0.417,-0.446 0.571,-0.688c0.144,-0.247 0.262,-0.489 0.327,-0.709c0.074,-0.217 0.111,-0.406 0.128,-0.537c0.017,-0.133 0.027,-0.208 0.027,-0.208l0.001,-0.008l2.472,-29.714l0,-0.007l0.01,-0.331c-0.023,0.008 0.052,-0.418 -0.259,-1.159c-0.16,-0.362 -0.429,-0.8 -0.899,-1.172c-0.456,-0.38 -1.136,-0.676 -1.933,-0.684l0,0.842c0.582,0.009 1.073,0.219 1.405,0.498c0.344,0.271 0.539,0.591 0.655,0.854c0.228,0.537 0.171,0.847 0.189,0.841l-0.007,0.242l-0.001,0.006l-2.471,29.714l-0.001,0.005c0,0 -0.008,0.057 -0.021,0.155c-0.012,0.099 -0.04,0.239 -0.095,0.4c-0.046,0.165 -0.137,0.343 -0.243,0.527c-0.115,0.179 -0.259,0.356 -0.425,0.513c-0.169,0.152 -0.359,0.28 -0.547,0.38c-0.193,0.089 -0.378,0.165 -0.546,0.197c-0.165,0.04 -0.307,0.058 -0.406,0.061c-0.099,0.005 -0.156,0.008 -0.156,0.008l-0.007,0l-13.177,0l-0.005,0c0,0 -0.294,0.004 -0.557,-0.121c-0.268,-0.115 -0.459,-0.338 -0.459,-0.338l-0.004,-0.005l-1.007,-1.136l-0.005,-0.005c0,0 -0.089,-0.106 -0.245,-0.241c-0.155,-0.136 -0.384,-0.293 -0.635,-0.406c-0.251,-0.113 -0.52,-0.181 -0.725,-0.206c-0.204,-0.027 -0.342,-0.024 -0.342,-0.024l-3.979,0l0,0.421c0.141,-0.14 0.281,-0.28 0.421,-0.421l-3.549,0l-0.008,0.001c0,0 -0.138,-0.004 -0.343,0.023c-0.204,0.025 -0.473,0.093 -0.724,0.206c-0.251,0.113 -0.481,0.27 -0.635,0.406c-0.156,0.135 -0.245,0.241 -0.245,0.241l-0.006,0.005l-1.006,1.136l-0.004,0.005c0,0 -0.191,0.224 -0.459,0.338c-0.264,0.125 -0.557,0.121 -0.557,0.121l-13.189,0c0,0 -0.057,-0.003 -0.156,-0.008c-0.1,-0.003 -0.242,-0.021 -0.407,-0.061c-0.168,-0.032 -0.352,-0.108 -0.546,-0.197c-0.188,-0.1 -0.377,-0.228 -0.547,-0.38c-0.165,-0.156 -0.309,-0.333 -0.425,-0.513c-0.105,-0.184 -0.196,-0.362 -0.243,-0.527c-0.054,-0.161 -0.082,-0.301 -0.095,-0.399c-0.013,-0.099 -0.021,-0.155 -0.021,-0.155l0,-0.006l-2.472,-29.714l0,-0.006l-0.007,-0.241c0,0 0.004,-0.055 0.011,-0.149c0.004,-0.095 0.029,-0.229 0.069,-0.386c0.084,-0.312 0.28,-0.717 0.6,-1.016c0.305,-0.314 0.716,-0.497 1.029,-0.574c0.157,-0.036 0.292,-0.059 0.388,-0.06c0.095,-0.005 0.149,-0.008 0.149,-0.008l0.006,-0.001l15.589,0l0.005,0.001c0,0 0.309,-0.005 0.594,0.108c0.288,0.103 0.517,0.31 0.517,0.31l0.004,0.004l1.566,1.369l0.006,0.006c0,0 0.313,0.282 0.709,0.422c0.39,0.155 0.812,0.149 0.812,0.149l0.008,0l4.004,0l0,-0.421c-0.141,0.14 -0.281,0.28 -0.422,0.421l3.591,0c0,0 0.422,0.006 0.812,-0.149c0.395,-0.14 0.709,-0.423 0.709,-0.423l0.006,-0.005l1.565,-1.369l0.005,-0.004c0,0 0.229,-0.207 0.517,-0.31c0.285,-0.113 0.593,-0.109 0.593,-0.109l15.598,0Z" style="fill-rule:nonzero;"/></g></g></g><g><path d="M55.583,39.406c-0.125,1.502 -1.38,2.658 -2.888,2.658l-13.301,0c-0.516,0 -1.007,-0.221 -1.349,-0.607l-1.02,-1.152c-0.42,-0.473 -1.023,-0.744 -1.656,-0.744l-7.169,0c-0.633,0 -1.236,0.271 -1.656,0.744l-1.02,1.152c-0.342,0.386 -0.833,0.607 -1.349,0.607l-13.302,0c-1.507,0 -2.762,-1.155 -2.887,-2.657l-2.495,-29.985c-0.13,-1.572 1.11,-2.919 2.687,-2.919l15.733,0c0.518,0 1.017,0.188 1.407,0.529l1.584,1.386c0.35,0.306 0.799,0.475 1.264,0.475l7.236,0c0.465,0 0.915,-0.169 1.264,-0.475l1.585,-1.386c0.389,-0.341 0.889,-0.529 1.406,-0.529l15.734,0c1.577,0 2.817,1.347 2.686,2.919l-2.494,29.984Zm0.439,-34.269l-48.475,0c-2.036,0 -3.637,1.74 -3.468,3.77l2.569,30.891c0.17,2.053 1.886,3.632 3.946,3.632l42.38,0c2.06,0 3.777,-1.58 3.947,-3.632l2.569,-30.891c0.169,-2.03 -1.433,-3.77 -3.468,-3.77" style="fill:#2e1052;fill-rule:nonzero;"/></g><g><g><path d="M17.085,59.96c-0.644,0 -1.2,-0.136 -1.67,-0.433c-0.47,-0.284 -0.829,-0.692 -1.076,-1.224c-0.26,-0.532 -0.383,-1.162 -0.383,-1.88c0,-0.729 0.123,-1.36 0.383,-1.892c0.26,-0.532 0.618,-0.94 1.088,-1.237c0.47,-0.284 1.039,-0.433 1.682,-0.433c0.643,0 1.2,0.137 1.657,0.421c0.458,0.284 0.817,0.693 1.076,1.224c0.248,0.52 0.371,1.15 0.371,1.88c0,0.73 -0.123,1.373 -0.383,1.905c-0.247,0.532 -0.618,0.952 -1.076,1.236c-0.47,0.285 -1.026,0.433 -1.669,0.433Zm0,-1.434c0.42,0 0.742,-0.186 0.989,-0.569c0.247,-0.384 0.371,-0.903 0.371,-1.546c0,-0.656 -0.124,-1.163 -0.371,-1.546c-0.247,-0.383 -0.569,-0.569 -0.989,-0.569c-0.421,0 -0.743,0.198 -0.99,0.569c-0.247,0.383 -0.371,0.903 -0.371,1.546c0,0.643 0.124,1.162 0.371,1.546c0.247,0.383 0.569,0.569 0.99,0.569Z" style="fill:#0d0d0d;fill-rule:nonzero;"/></g><g><path d="M22.267,53.022l1.595,0l0.174,1.051c0.173,-0.383 0.432,-0.68 0.791,-0.89c0.359,-0.21 0.779,-0.322 1.249,-0.322c0.495,0 0.952,0.112 1.385,0.347l0,1.682c-0.395,-0.359 -0.902,-0.532 -1.533,-0.532c-0.52,0 -0.928,0.111 -1.249,0.346c-0.322,0.235 -0.52,0.569 -0.594,1.014c-0.012,0.099 -0.037,0.235 -0.037,0.384c-0.012,0.148 -0.012,0.334 -0.012,0.569l0,3.116l-1.769,0l0,-6.765Z" style="fill:#0d0d0d;fill-rule:nonzero;"/></g><g><path d="M30.974,52.218c-0.124,0 -0.173,-0.061 -0.173,-0.173l0,-1.706c0,-0.124 0.049,-0.186 0.173,-0.186l1.41,0c0.124,0 0.186,0.062 0.186,0.186l0,1.706c0,0.112 -0.062,0.173 -0.186,0.173l-1.41,0Zm2.177,7.643c-0.829,0 -1.435,-0.222 -1.806,-0.667c-0.371,-0.433 -0.544,-1.151 -0.544,-2.152l0,-2.659l-1.435,0l0,-1.361l3.204,0l0,4.02c0,0.519 0.074,0.89 0.247,1.125c0.161,0.223 0.445,0.334 0.841,0.334l1.41,0l0,1.36l-1.917,0Z" style="fill:#0d0d0d;fill-rule:nonzero;"/></g><g><path d="M39.422,59.96c-0.643,0 -1.2,-0.136 -1.67,-0.433c-0.469,-0.284 -0.828,-0.692 -1.075,-1.224c-0.26,-0.532 -0.384,-1.162 -0.384,-1.88c0,-0.729 0.124,-1.36 0.384,-1.892c0.259,-0.532 0.618,-0.94 1.088,-1.237c0.47,-0.284 1.039,-0.433 1.682,-0.433c0.643,0 1.199,0.137 1.657,0.421c0.458,0.284 0.816,0.693 1.076,1.224c0.247,0.52 0.371,1.15 0.371,1.88c0,0.73 -0.124,1.373 -0.383,1.905c-0.248,0.532 -0.619,0.952 -1.076,1.236c-0.47,0.285 -1.027,0.433 -1.67,0.433Zm0,-1.434c0.421,0 0.742,-0.186 0.989,-0.569c0.248,-0.384 0.371,-0.903 0.371,-1.546c0,-0.656 -0.123,-1.163 -0.371,-1.546c-0.247,-0.383 -0.568,-0.569 -0.989,-0.569c-0.42,0 -0.742,0.198 -0.989,0.569c-0.248,0.383 -0.371,0.903 -0.371,1.546c0,0.643 0.123,1.162 0.371,1.546c0.247,0.383 0.569,0.569 0.989,0.569Z" style="fill:#0d0d0d;fill-rule:nonzero;"/></g><g><path d="M44.184,53.022l1.583,0l0.173,1.014c0.123,-0.371 0.334,-0.667 0.643,-0.865c0.309,-0.211 0.68,-0.31 1.113,-0.31c0.618,0 1.101,0.211 1.422,0.644c0.334,0.432 0.495,1.063 0.495,1.892l0,4.39l-1.756,0l0,-4.118c0,-0.47 -0.075,-0.816 -0.198,-1.039c-0.136,-0.223 -0.347,-0.334 -0.631,-0.334c-0.346,0 -0.606,0.148 -0.804,0.433c-0.185,0.297 -0.284,0.693 -0.284,1.187l0,3.871l-1.756,0l0,-6.765Z" style="fill:#0d0d0d;fill-rule:nonzero;"/></g></g></g><g id="Text"></g></svg>" 8 | ) 9 | end 10 | end 11 | -------------------------------------------------------------------------------- /src/orion/handler.cr: -------------------------------------------------------------------------------- 1 | module Orion::Handler 2 | include HTTP::Handler 3 | alias HandlerProc = Server::Context -> 4 | 5 | abstract def call(context : Server::Context) 6 | 7 | def call(context : HTTP::Server::Context) 8 | raise "Cannot use an orion handler with a standard HTTP router." 9 | end 10 | end 11 | -------------------------------------------------------------------------------- /src/orion/handlers.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | require "./helpers/*" 3 | require "./handlers/*" 4 | -------------------------------------------------------------------------------- /src/orion/handlers/auto_close.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | class Orion::Handlers::AutoClose 3 | include Handler 4 | 5 | def call(cxt : Server::Context) 6 | call_next cxt 7 | cxt.response.close unless cxt.response.closed? 8 | rescue 9 | # everything is fine, dont raise an error 10 | end 11 | end 12 | -------------------------------------------------------------------------------- /src/orion/handlers/auto_mime.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | class Orion::Handlers::AutoMime 3 | include Handler 4 | include MIMEHelper 5 | 6 | def call(cxt : Server::Context) 7 | cxt.request.headers["Accept"] ||= type_from_path?(cxt.request) || "*/*" 8 | call_next(cxt) 9 | if (content_type = request_mime_types(cxt.request).first?) 10 | cxt.response.headers["Content-Type"] ||= content_type 11 | end 12 | end 13 | end 14 | -------------------------------------------------------------------------------- /src/orion/handlers/config.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | class Orion::Handlers::Config 3 | include Handler 4 | @config : Orion::Config 5 | 6 | def initialize(@config : Orion::Config) 7 | end 8 | 9 | def call(cxt : Server::Context) 10 | cxt.config = @config.readonly 11 | call_next cxt 12 | end 13 | end 14 | -------------------------------------------------------------------------------- /src/orion/handlers/exceptions.cr: -------------------------------------------------------------------------------- 1 | require "ecr" 2 | 3 | class Orion::Handlers::Exceptions 4 | include Handler 5 | 6 | def call(cxt : Server::Context) 7 | begin 8 | call_next(cxt) 9 | rescue error 10 | Log.for(Orion).error(exception: error) { error.class.name } 11 | cxt.response.reset 12 | {% if flag?(:exceptionpage) || (flag?(:release) && !flag?(:noexceptionpage)) %} 13 | release_response cxt, error 14 | {% else %} 15 | dev_response cxt, error 16 | {% end %} 17 | end 18 | end 19 | 20 | private def release_response(cxt : Orion::Server::Context, error : Exception) 21 | status_code, message, subtext = response_for(error) 22 | cxt.response.status_code = status_code 23 | page_title = "#{message} (#{cxt.response.status_code})" 24 | cxt.response.headers["Content-Type"] = "text/html" 25 | ECR.embed "#{__DIR__}/../error_page.html.ecr", cxt.response 26 | end 27 | 28 | private def dev_response(cxt : Orion::Server::Context, error : Exception) 29 | status_code, message, subtext = response_for(error) 30 | cxt.response.status_code = status_code 31 | cxt.response.print ExceptionPage.for_runtime_exception(cxt, error).to_s 32 | end 33 | 34 | private def response_for(error : RoutingError) 35 | {404, "The page you were looking for doesn't exist.", "You may have mistyped the address or the page may have moved."} 36 | end 37 | 38 | private def response_for(error : Exception) 39 | {500, "We're sorry, but something went wrong.", "Please report this error to the application owner for assistance."} 40 | end 41 | end 42 | -------------------------------------------------------------------------------- /src/orion/handlers/logger.cr: -------------------------------------------------------------------------------- 1 | require "uuid" 2 | 3 | class Orion::Handlers::Logger 4 | include Handler 5 | 6 | def initialize(@log = Log.for("http.server")) 7 | end 8 | 9 | def call(context) 10 | Log.with_context do 11 | start = Time.monotonic 12 | request_id = UUID.random.to_s 13 | Log.context.set(operation: {id: request_id}) 14 | begin 15 | call_next(context) 16 | ensure 17 | elapsed = Time.monotonic - start 18 | elapsed_text = elapsed_text(elapsed) 19 | 20 | req = context.request 21 | res = context.response 22 | 23 | addr = 24 | {% begin %} 25 | case remote_address = req.remote_address 26 | when nil 27 | "-" 28 | {% unless flag?(:win32) %} 29 | when Socket::IPAddress 30 | remote_address.address 31 | {% end %} 32 | else 33 | remote_address 34 | end 35 | {% end %} 36 | @log.with_context do 37 | @log.context.set( 38 | http_request: { 39 | "requestMethod" => req.method, 40 | "requestUrl" => URI.new(host: req.headers["Host"], path: req.resource, query: req.query_params).to_s, 41 | "userAgent" => req.headers["User-Agent"], 42 | "remoteIp" => req.remote_address.as?(Socket::IPAddress).try(&.address), 43 | "status" => res.status_code, 44 | "latency" => "#{elapsed.total_seconds}s", 45 | }, 46 | ) 47 | @log.info { "#{addr} - #{req.method} #{req.resource} #{req.version} - #{res.status_code} (#{elapsed_text})" } 48 | end 49 | end 50 | end 51 | end 52 | 53 | private def elapsed_text(elapsed) 54 | minutes = elapsed.total_minutes 55 | return "#{minutes.round(2)}m" if minutes >= 1 56 | 57 | "#{elapsed.total_seconds.humanize(precision: 2, significant: false)}s" 58 | end 59 | end 60 | -------------------------------------------------------------------------------- /src/orion/handlers/method_override_header.cr: -------------------------------------------------------------------------------- 1 | require "http/server" 2 | 3 | # :nodoc: 4 | class Orion::Handlers::MethodOverrideHeader 5 | include Handler 6 | 7 | def call(cxt : Server::Context) 8 | override_method = 9 | cxt.request.headers["x-http-method-override"]? || 10 | cxt.request.headers["x-method-override"]? || 11 | cxt.request.headers["x-http-method"]? 12 | cxt.request.method = override_method if override_method 13 | call_next cxt 14 | end 15 | end 16 | -------------------------------------------------------------------------------- /src/orion/handlers/method_override_param.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | class Orion::Handlers::MethodOverrideParam 3 | include Handler 4 | 5 | def call(cxt : Server::Context) 6 | request = cxt.request 7 | override_method = param_method?(request) || form_method?(request) 8 | request.method = override_method if override_method 9 | call_next cxt 10 | end 11 | 12 | private def param_method?(req : HTTP::Request) 13 | req.query_params["_method"]? 14 | end 15 | 16 | private def form_method?(req : HTTP::Request) 17 | if type_for_request(req) == "multipart/form-data" 18 | HTTP::FormData.parse(req) do |part| 19 | if part.name == "_method" 20 | return part.body.gets_to_end 21 | end 22 | end 23 | nil 24 | end 25 | end 26 | 27 | def type_for_request(request : HTTP::Request) 28 | content_type = request.headers["content-type"]?.to_s.split(';').first?.to_s 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /src/orion/handlers/reset_path.cr: -------------------------------------------------------------------------------- 1 | class Orion::Handlers::ResetPath 2 | include Handler 3 | 4 | def call(cxt : Server::Context) 5 | cxt.request.path = cxt.request.path.sub(/^#{cxt.request.base_path}/, "") 6 | call_next(cxt) 7 | cxt.request.reset_path! 8 | end 9 | end 10 | -------------------------------------------------------------------------------- /src/orion/handlers/route_finder.cr: -------------------------------------------------------------------------------- 1 | class Orion::Handlers::RouteFinder 2 | include Handler 3 | 4 | @tree : DSL::Tree 5 | @strip_extension : Bool 6 | 7 | def initialize(@tree : DSL::Tree, *, @strip_extension = false) 8 | end 9 | 10 | def call(cxt : Server::Context) 11 | action = nil 12 | path = cxt.request.path 13 | @tree.search(@strip_extension ? path.rchop(File.extname(path)) : path) do |result| 14 | unless action 15 | cxt.request.path_params = result.params 16 | action = result.payloads.find &.matches_constraints? cxt.request 17 | action.try &.call(cxt) 18 | end 19 | end 20 | 21 | unless action 22 | raise RoutingError.new("No route matches [#{cxt.request.method}] \"#{cxt.request.path}\"") 23 | end 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /src/orion/handlers/scope_base_path.cr: -------------------------------------------------------------------------------- 1 | class Orion::Handlers::ScopeBasePath 2 | include Handler 3 | 4 | def initialize(@base_path : String) 5 | end 6 | 7 | def call(cxt : Orion::Server::Context) 8 | cxt.request.base_path = @base_path 9 | call_next cxt 10 | end 11 | end 12 | -------------------------------------------------------------------------------- /src/orion/helpers.cr: -------------------------------------------------------------------------------- 1 | require "./helpers/*" 2 | -------------------------------------------------------------------------------- /src/orion/helpers/mime_helper.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | module Orion::MIMEHelper 3 | extend self 4 | 5 | def request_mime_types(req : HTTP::Request) : Set(String) 6 | path_type = type_from_path?(req) 7 | accept_types = types_from_accept(req) 8 | path_type ? [path_type].to_set + accept_types : accept_types 9 | end 10 | 11 | def request_extensions(req : HTTP::Request) : Set(String) 12 | extensions = request_mime_types(req).reduce([] of String) do |exts, mime_type| 13 | exts.concat MIME.extensions(mime_type) 14 | end 15 | (extensions.empty? ? MIME.extensions("text/html") : extensions).to_set 16 | end 17 | 18 | private def types_from_accept(req : HTTP::Request) : Set(String) 19 | if (req.headers["Accept"]?) 20 | req.headers["Accept"]?.to_s.split(",").map do |type| 21 | parts = type.split(";") 22 | type = parts.shift 23 | weight = parts.find(&.starts_with?("q=")).try(&.sub(/^q=/, "").to_f?) || 1.0 24 | {type, weight} 25 | end.sort do |l, r| 26 | r[1] <=> l[1] 27 | end.map(&.first).to_set 28 | else 29 | Set(String).new 30 | end 31 | end 32 | 33 | private def type_accepted?(req, type : String) : Bool 34 | types_from_accept?(req).any? do |req_type| 35 | req_type, req_subtype = req_type.split("/") 36 | match_type, match_subtype = type.split("/") 37 | case {req_type, req_subtype} 38 | when {"*", "*"} 39 | true 40 | when {match_type, "*"} 41 | true 42 | when {match_type, match_subtype} 43 | true 44 | else 45 | false 46 | end 47 | end 48 | end 49 | 50 | private def type_from_path?(req : HTTP::Request) : String? 51 | return if File.extname(req.path).empty? 52 | mime_type = MIME.from_filename(req.path.not_nil!) 53 | mime_type.to_s if mime_type 54 | rescue 55 | nil 56 | end 57 | end 58 | -------------------------------------------------------------------------------- /src/orion/inflector/controllerize.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | 3 | if ARGV[0][0].ascii_uppercase? 4 | print ARGV[0] + "Controller" 5 | else 6 | print Inflector.camelize(ARGV[0]) + "Controller" 7 | end 8 | -------------------------------------------------------------------------------- /src/orion/inflector/decontrollerize.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | Inflector.underscore(ARGV[0]).rstrip("_controller") 3 | -------------------------------------------------------------------------------- /src/orion/inflector/path_joiner.cr: -------------------------------------------------------------------------------- 1 | base = ARGV[0] 2 | path = ARGV[1] 3 | parts = [base, path].map(&.to_s) 4 | joined_path = String.build do |str| 5 | parts.each_with_index do |part, index| 6 | part.check_no_null_byte 7 | 8 | str << "/" if index > 0 9 | 10 | byte_start = 0 11 | byte_count = part.bytesize 12 | 13 | if index > 0 && part.starts_with?("/") 14 | byte_start += 1 15 | byte_count -= 1 16 | end 17 | 18 | if index != parts.size - 1 && part.ends_with?("/") 19 | byte_count -= 1 20 | end 21 | 22 | str.write part.unsafe_byte_slice(byte_start, byte_count) 23 | end 24 | end 25 | puts joined_path 26 | -------------------------------------------------------------------------------- /src/orion/inflector/pluralize.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | 3 | print Inflector.pluralize(ARGV[0]) 4 | -------------------------------------------------------------------------------- /src/orion/inflector/random_const.cr: -------------------------------------------------------------------------------- 1 | require "random/secure" 2 | require "inflector" 3 | 4 | print "#{ARGV[0]}_#{Random::Secure.hex}" 5 | -------------------------------------------------------------------------------- /src/orion/inflector/singularize.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | 3 | print Inflector.singularize(ARGV[0]) 4 | -------------------------------------------------------------------------------- /src/orion/inflector/underscore.cr: -------------------------------------------------------------------------------- 1 | print ARGV[0].underscore.gsub('-', '_') 2 | -------------------------------------------------------------------------------- /src/orion/pipeline.cr: -------------------------------------------------------------------------------- 1 | require "digest" 2 | 3 | # :nodoc: 4 | struct Orion::Pipeline 5 | CACHE = {} of String => Pipeline 6 | ROUTE_HANDLER = ->(http_context : HTTP::Server::Context) { 7 | context = http_context.as(Server::Context) 8 | context.request.action.try &.invoke(context) 9 | } 10 | 11 | @pipeline : ::HTTP::Handler | ::HTTP::Handler::HandlerProc 12 | @cache_key : String 13 | 14 | def self.new(handlers) 15 | key = cache_key(handlers) 16 | CACHE[key]? || Pipeline.new(handlers, key) 17 | end 18 | 19 | private def self.cache_key(handlers : Array(::HTTP::Handler)) 20 | Digest::MD5.hexdigest do |ctx| 21 | handlers.each do |handler| 22 | ctx.update handler.object_id.to_s 23 | end 24 | end 25 | end 26 | 27 | def initialize(handlers : Array(::HTTP::Handler), @cache_key) 28 | handlers = handlers.map(&.dup) 29 | @pipeline = handlers.empty? ? ROUTE_HANDLER : Server.build_middleware(handlers, ROUTE_HANDLER) 30 | CACHE[cache_key] = self 31 | end 32 | 33 | def call(c : ::HTTP::Server::Context) : Nil 34 | @pipeline.call(c) 35 | end 36 | end 37 | -------------------------------------------------------------------------------- /src/orion/router.cr: -------------------------------------------------------------------------------- 1 | # The `Orion::Router` is the workhorse that does the work when a request comes 2 | # into your application. It will take all of your defined routes and builds you 3 | # an application that can serve HTTP traffic. You can configure the router using 4 | # the `config` in a single file router. Or by calling the `new` or `start` 5 | # method within your app. 6 | struct Orion::Router 7 | @stack : HTTP::Handler 8 | getter handlers = [] of HTTP::Handler 9 | delegate processor, bind, listen, to: @server 10 | delegate call, to: @stack 11 | 12 | def self.start(tree : DSL::Tree, *, config : Config) 13 | new(tree, auto_close: config.autoclose, strip_extension: config.strip_extension).tap do |server| 14 | server.bind(config: config) 15 | server.listen(workers: config.workers) 16 | ::Orion::FLAGS["started"] = true 17 | end 18 | end 19 | 20 | def self.start(tree : DSL::Tree, *, autoclose : Bool = true, strip_extension : Bool = false, workers = nil, **bind_opts) 21 | new(tree, autoclose: autoclose, strip_extension: strip_extension).tap do |server| 22 | server.bind(**bind_opts) 23 | server.listen(workers: workers) 24 | ::Orion::FLAGS["started"] = true 25 | end 26 | end 27 | 28 | def initialize(tree : DSL::Tree, *, autoclose : Bool = true, strip_extension : Bool = false) 29 | use Handlers::AutoClose if autoclose 30 | use Handlers::Exceptions.new 31 | use Handlers::MethodOverrideHeader 32 | use Handlers::AutoMime 33 | use Handlers::RouteFinder.new(tree, strip_extension: strip_extension) 34 | @stack = Server.build_middleware handlers 35 | @server = Server.new(handler: @stack) 36 | end 37 | 38 | # Visualize the route tree 39 | def visualize 40 | tree.visualize 41 | end 42 | 43 | def use(handler : HTTP::Handler) 44 | handlers << handler 45 | end 46 | 47 | def use(handler) 48 | use handler.new 49 | end 50 | end 51 | -------------------------------------------------------------------------------- /src/orion/server.cr: -------------------------------------------------------------------------------- 1 | class Orion::Server < HTTP::Server 2 | @name : String = File.basename Dir.current 3 | getter processor : ::HTTP::Server::RequestProcessor 4 | 5 | # Creates a new Orion server with the given *handler*. 6 | def initialize(handler : HTTP::Handler | HTTP::Handler::HandlerProc) 7 | @processor = RequestProcessor.new(handler) 8 | end 9 | 10 | # Bind using a URI 11 | def bind(*, tls : Nil = nil, uri) 12 | bind(uri: uri) 13 | end 14 | 15 | # Bind TLS with an address 16 | def bind(*, tls : OpenSSL::SSL::Context::Server, address : ::Socket::IPAddress) 17 | bind_tls(address: address, context: tls) 18 | end 19 | 20 | # Bind TLS with a host and port 21 | def bind(*, tls : OpenSSL::SSL::Context::Server, host = ::Socket::IPAddress::LOOPBACK, port = nil, reuse_port = false) 22 | if port 23 | bind_tls(host: host, port: port, context: tls, reuse_port: reuse_port) 24 | else 25 | bind_tls(host: host, context: tls) 26 | end 27 | end 28 | 29 | # Bind TCP to a host and port 30 | def bind(*, tls : Nil = nil, host = ::Socket::IPAddress::LOOPBACK, port = nil, reuse_port = false) 31 | if port 32 | bind_tcp(host: host, port: port.to_i, reuse_port: reuse_port) 33 | else 34 | bind_unused_port(host: host, reuse_port: reuse_port) 35 | end 36 | end 37 | 38 | # Bind TCP to a Socket::IPAddress 39 | def bind(*, tls : Nil = nil, address : ::Socket::IPAddress, reuse_port = false) 40 | bind_tcp(address: address, reuse_port: reuse_port) 41 | end 42 | 43 | # Bind to a Socket::UnixAddress 44 | def bind(*, tls = nil, address : ::Socket::UNIXAddress) 45 | bind_unix(address: address) 46 | end 47 | 48 | def bind(*, tls = nil, path) 49 | bind_unix(path: path) 50 | end 51 | 52 | # Bind using a config 53 | def bind(*, config : ::Orion::Config) 54 | @name = config.name 55 | case config 56 | when .path 57 | bind(path: config.path.not_nil!) 58 | when .address 59 | bind(tls: config.tls, address: config.address.not_nil!) 60 | else 61 | bind(tls: config.tls, host: config.host.not_nil!, port: config.port, reuse_port: config.reuse_port) 62 | end 63 | end 64 | 65 | # Listen clients using multiple workers 66 | # A good suggestion is to use System.cpu_count 67 | def listen(*args, workers, **opts) 68 | if (workers.nil? || workers <= 1) 69 | listen(*args, **opts) 70 | else 71 | workers.times do |i| 72 | Process.fork do 73 | listen(*args, **opts, worker: i) 74 | end 75 | end 76 | sleep 77 | end 78 | end 79 | 80 | # Listen for clients 81 | private def listen(*args, worker = nil, **opts) 82 | each_address do |address| 83 | listen_message(address, worker ? "#{@name}.#{worker}" : @name) 84 | end 85 | super(*args, **opts) 86 | end 87 | 88 | private def listen_message(socket : ::Socket::UNIXAddress, prefix) 89 | Log.info { "listening on #{socket.path}" } 90 | end 91 | 92 | private def listen_message(socket : ::Socket::IPAddress, prefix) 93 | Log.info { "listening on #{socket.address}:#{socket.port}" } 94 | end 95 | end 96 | 97 | require "./server/*" 98 | -------------------------------------------------------------------------------- /src/orion/server/context.cr: -------------------------------------------------------------------------------- 1 | class Orion::Server::Context < HTTP::Server::Context 2 | getter! config : Orion::Config::ReadOnly? 3 | 4 | # :nodoc: 5 | def initialize(@request : Request, @response : Response) 6 | end 7 | 8 | def config=(config : Orion::Config::ReadOnly) 9 | raise Exception.new("Cannot change the config during a request") if @config 10 | @config = config 11 | end 12 | 13 | def request : Request 14 | @request.as(Request) 15 | end 16 | 17 | def response : Response 18 | @response.as(Response) 19 | end 20 | end 21 | -------------------------------------------------------------------------------- /src/orion/server/request.cr: -------------------------------------------------------------------------------- 1 | class Orion::Server::Request < HTTP::Request 2 | @original_path : String? 3 | 4 | setter path_params : Hash(String, String)? 5 | property base_path : String = "/" 6 | property action : Orion::Action? 7 | 8 | # Returns the list of path params set by an Orion route. 9 | def path_params 10 | @path_params ||= {} of String => String 11 | end 12 | 13 | # The original path of the request 14 | def reset_path! 15 | if (original_path = @original_path) 16 | self.path = original_path 17 | @original_path = nil 18 | end 19 | end 20 | 21 | def path=(new_path) 22 | @original_path = path 23 | super(new_path) 24 | end 25 | 26 | # The format of the http request 27 | def format 28 | formats.first 29 | end 30 | 31 | # The formats of the http request 32 | def formats 33 | MIMEHelper.request_extensions(self).tap do |set| 34 | set << File.extname(resource) 35 | end 36 | end 37 | end 38 | -------------------------------------------------------------------------------- /src/orion/server/request_processor.cr: -------------------------------------------------------------------------------- 1 | require "http" 2 | 3 | class Orion::Server::RequestProcessor < HTTP::Server::RequestProcessor 4 | include HTTP 5 | # Some magic to ensure support for all versions of crystal 6 | {{ HTTP::Server::RequestProcessor.methods.map(&.id.gsub(/HTTP::(Server::)?(Request|Response|Context)/, "::Orion::Server::\\2")).join("\n").id }} 7 | end 8 | -------------------------------------------------------------------------------- /src/orion/server/response.cr: -------------------------------------------------------------------------------- 1 | class Orion::Server::Response < HTTP::Server::Response 2 | end 3 | -------------------------------------------------------------------------------- /src/orion/view.cr: -------------------------------------------------------------------------------- 1 | require "./view/*" 2 | 3 | module Orion::View 4 | @rendered = false 5 | 6 | private macro setup_hooks! 7 | {% if @type.class? || @type.struct? %} 8 | alias ParentRenderer = ::Orion::View::Renderer 9 | class Renderer < ParentRenderer ; end 10 | 11 | private def __renderer__ 12 | Renderer.new(self) 13 | end 14 | 15 | macro inherited 16 | {% verbatim do %} 17 | alias ParentRenderer = {{ @type.superclass }}::Renderer 18 | class Renderer < ParentRenderer ; end 19 | private def __renderer__ 20 | Renderer.new(self) 21 | end 22 | {% end %} 23 | end 24 | {% else %} 25 | macro included 26 | setup_hooks! 27 | end 28 | {% end %} 29 | end 30 | 31 | setup_hooks! 32 | 33 | # Include a helper module in the view 34 | # Use this to add helpers to a view from a module 35 | macro view_helper(mod) 36 | class Renderer < ParentRenderer 37 | include {{ mod }} 38 | end 39 | end 40 | 41 | # A block that can be read by the view. 42 | # Use this to define methods that can be accessed by the view 43 | macro view_helper(&block) 44 | class Renderer < ParentRenderer 45 | {{ yield }} 46 | end 47 | end 48 | 49 | # Define a layout to be used within the controller 50 | macro layout(filename, *, locals = NamedTuple.new) 51 | {% raise "Cannot call layout within a def" if @def %} 52 | {% if filename == false %} 53 | {% layout_token = nil %} 54 | {% else %} 55 | {% layout_file = run("./view/renderer/layout_finder.cr", filename) %} 56 | {% layout_token = run("./view/renderer/tokenize.cr", layout_file) %} 57 | {% end %} 58 | 59 | # Render a view 60 | macro render(*, view = @def.name, layout = true, locals = NamedTuple.new, layout_locals = nil) 61 | \{% raise "Cannot call render outside a def" unless @def %} 62 | render_with_layout({{ layout_token }}, \{{ layout }}, \{{ view }}, {{ locals }}, \{{ layout_locals }}, \{{ locals }}) 63 | end 64 | end 65 | 66 | # No layout by default 67 | layout false 68 | 69 | # :nodoc: 70 | private macro render_with_layout(layout_token, layout_option, view, layout_locals, layout_local_overrides, locals) 71 | raise ::Orion::DoubleRenderError.new("Already rendered, check #{self.class.name}") if @rendered 72 | 73 | # Render the view without a layout 74 | {% if layout_token == nil || layout_option == false || layout_option == nil %} 75 | {% view_file = run("./view/renderer/view_finder.cr", @type.name, view) %} 76 | {% view_token = run("./view/renderer/tokenize.cr", view_file) %} 77 | __renderer__.__template_{{ view_token }}__("", false, {{ locals }}) 78 | @rendered = true 79 | 80 | # Render in a layout with the provided layout token 81 | {% elsif layout_option == true %} 82 | {% view_file = run("./view/renderer/view_finder.cr", @type.name, view) %} 83 | {% view_token = run("./view/renderer/tokenize.cr", view_file) %} 84 | __renderer__.__template_{{ layout_token }}__("", {{ layout_locals }}, {{ locals }}) do 85 | __renderer__.__template_string_{{ view_token }}__("", {{ locals }}, {{ layout_local_overrides }}, {{ layout_locals }}) 86 | end 87 | @rendered = true 88 | 89 | # Generate a new layout token and 90 | {% elsif layout_option.is_a? StringLiteral %} 91 | {% layout_file = run("./view/renderer/layout_finder.cr", filename) %} 92 | {% layout_token = run("./view/renderer/tokenize.cr", layout_file) %} 93 | render_with_layout({{ layout_token }}, true, {{ view }}, {{ layout_locals }}, {{ layout_local_overrides }}, {{ locals }}) 94 | 95 | # Raise if the expected shape is wrong 96 | {% else %} 97 | {% raise "layout must be of type `String | Nil | Bool`" %} 98 | {% end %} 99 | end 100 | end 101 | -------------------------------------------------------------------------------- /src/orion/view/asset_tag_helpers.cr: -------------------------------------------------------------------------------- 1 | require "html_builder" 2 | 3 | # Patch HTML escape function 4 | def HTML.escape(stringable : Bool | Int | Float, *args) 5 | HTML.escape(stringable.to_s, *args) 6 | end 7 | 8 | module Orion::View::AssetTagHelpers 9 | # Returns an HTML image tag for the source. The source can be a full path or a 10 | # file that exists in your assets/images directory. 11 | def image_tag(src : String, **attrs) 12 | HTML.build do 13 | img(**attrs, src: assets_local? ? image_path(src) : image_url(src)) 14 | end 15 | end 16 | 17 | # Computes the path to an image asset in the assets/images directory. 18 | # Full paths from the document root will be passed through. Used internally 19 | # by image_tag to build the image path. 20 | def image_path(src : String) 21 | asset_path(File.expand_path(src, "/images")) 22 | end 23 | 24 | # Computes the URL to an image asset in the assets/images directory. 25 | # This will call image_path internally and merge with your current host or 26 | # your asset host. 27 | def image_url(src : String) 28 | asset_url(File.expand_path(src, "/images")) 29 | end 30 | 31 | # Returns an HTML script tag for each of the sources provided. You can pass in 32 | # the filename (.js extension is optional) of JavaScript files that exist in 33 | # your assets/javascripts directory for inclusion into the current page or 34 | # you can pass the full path relative to your document root. 35 | def javascript_include_tag(src, **attrs) 36 | HTML.build do 37 | script(**attrs, src: assets_local? ? javascript_path(src) : javascript_url(src)) { } 38 | end 39 | end 40 | 41 | # Computes the path to a JavaScript asset in the assets/javascripts 42 | # directory. If the source filename has no extension, .js will be appended. 43 | # Full paths from the document root will be passed through. Used internally 44 | # by javascript_include_tag to build the script path. 45 | def javascript_path(file) 46 | asset_path(File.expand_path(file, "/javascripts"), extname: ".js") 47 | end 48 | 49 | # Computes the URL to a JavaScript asset in the assets/javascripts 50 | # directory. This will call javascript_path internally and merge with your 51 | # current host or your asset host. 52 | def javascript_url(file : String) 53 | asset_url(File.expand_path(file, "/javascripts"), extname: ".js") 54 | end 55 | 56 | # Returns a stylesheet link tag for the sources specified as arguments. If 57 | # you don't specify an extension, .css will be appended automatically. 58 | def stylesheet_link_tag(href, **attrs) 59 | HTML.build do 60 | link(**attrs, rel: "stylesheet", href: assets_local? ? stylesheet_path(href) : stylesheet_url(href)) 61 | end 62 | end 63 | 64 | # Computes the path to a stylesheet asset in the assets/stylesheets 65 | # directory. If the source filename has no extension, .css will be appended. 66 | # Full paths from the document root will be passed through. Used internally by 67 | # stylesheet_link_tag to build the stylesheet path. 68 | def stylesheet_path(file) 69 | asset_path(File.expand_path(file, "/stylesheets"), extname: ".css") 70 | end 71 | 72 | # Computes the URL to a stylesheet asset in the assets/stylesheets 73 | # directory. This will call stylesheet_path internally and merge with your 74 | # current host or your asset host. 75 | def stylesheet_url(file : String) 76 | asset_url(File.expand_path(file, "/javascripts"), extname: ".css") 77 | end 78 | 79 | # Computes the path to an asset in the assets directory. If the source 80 | # filename has no extension, the provided extnam will be appended. 81 | # Full paths from the document root will be passed through. 82 | def asset_path(file, *, extname : String? = nil) 83 | file = extname ? "#{file}#{extname}" : file 84 | File.join("/assets", file) 85 | end 86 | 87 | # Computes the URL to an asset in the assets directory. This will call 88 | # asset_path internally and merge with your current host or your asset host. 89 | def asset_url(file : String, *, extname : String? = nil) 90 | "//#{config.asset_host || request.headers["Host"]?}#{asset_path(file, extname: extname)}" 91 | end 92 | 93 | # Returns a link tag that browsers and feed readers can use to auto-detect an 94 | # RSS, Atom, or JSON feed. 95 | def auto_discovery_link_tag(type : String, href, **attrs) 96 | HTML.build do 97 | link(**attrs, type: MIME.from_extension(".#{type}") { type }, href: href, rel: "alternate") 98 | end 99 | end 100 | 101 | private def assets_local? 102 | config.asset_host.nil? || config.asset_host == request.headers["Host"]? 103 | end 104 | end 105 | -------------------------------------------------------------------------------- /src/orion/view/cache_helpers.cr: -------------------------------------------------------------------------------- 1 | module Orion::View::CacheHelpers 2 | # Cache the block, using the object as the key 3 | macro cache(object, &block) 4 | %orig_cache_key = __cache_key__ 5 | __cache_key__ = extend_cache_key(__cache_key__, {{ object }}) 6 | config.cache.fetch(__cache_key__) do 7 | String.build do |__kilt_io__| 8 | {{ yield }} 9 | end 10 | end.to_s(__kilt_io__) 11 | __cache_key__ = %orig_cache_key 12 | end 13 | 14 | # Cache the block, if the condition is true, using the object as the key 15 | macro cache_if(condition, object, &block) 16 | %orig_cache_key = __cache_key__ 17 | __cache_key__ = extend_cache_key(__cache_key__, {{ object }}) 18 | config.cache.fetch_if({{ condition }}, __cache_key__) do 19 | String.build do |__kilt_io__| 20 | {{ yield }} 21 | end.to_s(__kilt_io__) 22 | end 23 | __cache_key__ = %orig_cache_key 24 | end 25 | 26 | # 27 | private def extend_cache_key(prev_key : String, next_key : String) 28 | "#{prev_key}/#{next_key}" 29 | end 30 | 31 | private def extend_cache_key(prev_key : String, next_key : Cache::Keyable) 32 | "#{prev_key}/#{next_key.cache_key}" 33 | end 34 | end 35 | -------------------------------------------------------------------------------- /src/orion/view/capture_helper.cr: -------------------------------------------------------------------------------- 1 | module Orion::View::CaptureHelper 2 | @content_fors : Hash(Symbol, String) 3 | 4 | # The capture macro allows you to extract part of a template into a variable. 5 | # You can then use this variable anywhere in your templates or layout. 6 | macro capture(&block) 7 | String.build do |__kilt_io__| 8 | {{ yield }} 9 | end 10 | end 11 | 12 | macro content_for(name, &block) 13 | @content_fors[{{ name }}] = capture do 14 | {{ yield }} 15 | end 16 | end 17 | end 18 | -------------------------------------------------------------------------------- /src/orion/view/partial_helpers.cr: -------------------------------------------------------------------------------- 1 | module Orion::View::PartialHelpers 2 | # Render a view partial 3 | macro render(*, partial, locals = NamedTuple.new) 4 | {% raise "Cannot call render outside a def" unless @def %} 5 | {% partial_file = run("./renderer/partial_finder.cr", @type.name, partial) %} 6 | {% partial_token = run("./renderer/tokenize.cr", partial_file) %} 7 | __template_string_{{ partial_token }}__(__cache_key__, {{ locals }}, __locals__) 8 | end 9 | 10 | # Render a collection into a partial 11 | macro render(*, partial, collection, cached = false) 12 | {% raise "Cannot call render outside a def" unless @def %} 13 | @collection.each do |item| 14 | cache_if({{ cached }}, item) do 15 | render(partial: {{ partial }}, locals: { item: {{ item }} }) 16 | end 17 | end 18 | end 19 | end 20 | -------------------------------------------------------------------------------- /src/orion/view/registry.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | module Orion::View::Registry 3 | {{ run "./renderer/defs.cr", `date +%s%N` }} 4 | 5 | private def combine_locals(left : Nil, right : NamedTuple) 6 | right 7 | end 8 | 9 | private def combine_locals(left : NamedTuple, right : Nil) 10 | left 11 | end 12 | 13 | private def combine_locals(left : NamedTuple, right : NamedTuple) 14 | right.merge(left) 15 | end 16 | 17 | private def combine_locals(l1, l2, l3) 18 | combine_locals(l1, combine_locals(l2, l3)) 19 | end 20 | end 21 | -------------------------------------------------------------------------------- /src/orion/view/renderer.cr: -------------------------------------------------------------------------------- 1 | require "../cache" 2 | require "./*" 3 | 4 | class Orion::View::Renderer 5 | include Controller::RequestHelpers 6 | include Registry 7 | include AssetTagHelpers 8 | include PartialHelpers 9 | include CacheHelpers 10 | 11 | getter config : Orion::Config::ReadOnly 12 | getter controller_name : String 13 | getter request : Orion::Server::Request 14 | getter __kilt_io__ : IO 15 | 16 | def initialize(controller : Orion::Controller) 17 | @__kilt_io__ = IO::MultiWriter.new controller.response 18 | @request = controller.request 19 | @config = controller.context.config 20 | @controller_name = controller.__name__ 21 | end 22 | end 23 | -------------------------------------------------------------------------------- /src/orion/view/renderer/defs.cr: -------------------------------------------------------------------------------- 1 | def tokenize(string) 2 | string.sub(/^\.\/src\/views\//, "").gsub(/[^A-Za-z0-9_]/, "_") 3 | end 4 | 5 | Dir.glob("./src/views/**/*").each do |view| 6 | token = tokenize(view) 7 | puts <<-crystal 8 | 9 | # :nodoc: 10 | def __template_#{token}__(__cache_key__ : String, *locals, &block) 11 | __locals__ = locals = combine_locals(*locals) 12 | Kilt.embed "#{view}" 13 | end 14 | 15 | # :nodoc: 16 | def __template_#{token}__(__cache_key__ : String, *locals) 17 | __locals__ = locals = combine_locals(*locals) 18 | Kilt.embed "#{view}" 19 | end 20 | 21 | # :nodoc: 22 | def __template_string_#{token}__(__cache_key__ : String, *locals) 23 | __locals__ = locals = combine_locals(*locals) 24 | Kilt.render "#{view}" 25 | end 26 | 27 | # :nodoc: 28 | def __template_string_#{token}__(__cache_key__ : String, *locals, &block : Symbol -> String) 29 | __locals__ = locals = combine_locals(*locals) 30 | Kilt.render "#{view}" 31 | end 32 | 33 | crystal 34 | end 35 | -------------------------------------------------------------------------------- /src/orion/view/renderer/layout_finder.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | layout_dir = "src/views/layouts" 3 | filename = ARGV[0] 4 | layout_file = File.join(layout_dir, filename) 5 | 6 | if File.exists? layout_file 7 | print layout_file 8 | else 9 | STDERR.puts "could not find layout: #{layout_file} in (#{layout_dir})" 10 | Process.exit 1 11 | end 12 | -------------------------------------------------------------------------------- /src/orion/view/renderer/partial_finder.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | view_dir = "src/views" 3 | controller_name = ARGV[0] 4 | partial_name = ARGV[1] 5 | 6 | parts = partial_name.split("/") 7 | parts << "_" + parts.pop 8 | filename = parts.join("/") 9 | controller_prefix = Inflector.underscore(controller_name.gsub(/Controller::Renderer$/, "")) 10 | controller_dir = File.join(view_dir, controller_prefix) 11 | controller_file = File.join(controller_dir, filename) 12 | view_file = File.join(view_dir, filename) 13 | 14 | if File.exists? controller_file 15 | print controller_file 16 | elsif File.exists? view_file 17 | print view_file 18 | else 19 | STDERR.puts "could not find partial: #{partial_name} in (#{controller_dir}, #{view_dir}), partial filenames must begin with underscore." 20 | Process.exit 1 21 | end 22 | -------------------------------------------------------------------------------- /src/orion/view/renderer/tokenize.cr: -------------------------------------------------------------------------------- 1 | file = File.expand_path(ARGV[0]) 2 | print "#{file.sub(/^#{Dir.current}\/src\/views\//, "").gsub(/[^A-Za-z0-9_]/, "_")}" 3 | -------------------------------------------------------------------------------- /src/orion/view/renderer/view_finder.cr: -------------------------------------------------------------------------------- 1 | require "inflector" 2 | view_dir = "src/views" 3 | controller_name = ARGV[0] 4 | filename = ARGV[1] 5 | 6 | controller_prefix = Inflector.underscore(controller_name).gsub(/_controller$/, "") 7 | controller_dir = File.join(view_dir, controller_prefix) 8 | controller_file = File.join(controller_dir, filename) 9 | view_file = File.join(view_dir, filename) 10 | 11 | if File.exists? controller_file 12 | print controller_file 13 | elsif File.exists? view_file 14 | print view_file 15 | else 16 | STDERR.puts "could not find view: #{filename} in (#{controller_dir}, #{view_dir})" 17 | Process.exit 1 18 | end 19 | -------------------------------------------------------------------------------- /src/orion/write_tracker.cr: -------------------------------------------------------------------------------- 1 | # :nodoc: 2 | class Orion::WriteTracker < IO 3 | getter written : Bool = false 4 | 5 | def read(slice : Bytes) 6 | raise "Cannot read from write tracker" 7 | end 8 | 9 | def write(slice : Bytes) : Nil 10 | return 0i64 if slice.empty? 11 | @written = true 12 | slice.size.to_i64 13 | end 14 | end 15 | -------------------------------------------------------------------------------- /src/parse_version.cr: -------------------------------------------------------------------------------- 1 | require "yaml" 2 | version = YAML.parse(File.read "shard.yml")["version"].to_s 3 | puts <<-crystal 4 | VERSION = #{version.inspect} 5 | crystal 6 | --------------------------------------------------------------------------------