# class Camping::Server

### Public Class Methods

logging_middleware() click to toggle source

    # File lib/camping/server.rb, line 113
    def logging_middleware
      lambda { |server|
        /CGI/.match?(server.server.name) || server.options[:quiet] ?  nil : [Camping::Firewatch, $stderr]
      }
    end

new(*) click to toggle source
Calls superclass method

    # File lib/camping/server.rb, line 88
    def initialize(*)
      super
      @reloader = Camping::Reloader.new(options[:script]) do |app|
        if !app.options.has_key?(:dynamic_templates)
                      app.options[:dynamic_templates] = true
              end
      end
    end

### Public Instance Methods

app() click to toggle source

add the public directory as a Rack app serving files first, then the current value of self, which is our camping apps, as an app.

    # File lib/camping/server.rb, line 179
    def app
      Rack::Cascade.new([Rack::Files.new(public_dir), self], [405, 404, 403])
    end

call(env) click to toggle source

call(env) res

## How routing works¶ ↑

The first app added using Camping.goes is set at the root, we walk through the defined routes of the first app to see if there is a match. With no match we then walk through every other defined app. When we reach a matching route we call that app and Camping’s router handles the rest.

Mounting apps at different directories is now explicit by setting the url_prefix option:

    camping.goes :Nuts          # Mounts Nuts at /
    module Auth
       set :url_prefix, "auth/"
    end
    camping.goes :Auth          # Mounts Auth at /auth/
    camping.goes :Blog          # Mounts Blog at /

Note that routes that you set explicitly with R are not prefixed. This us explicit control over routes:

    module Auth::Controllers
       class Whatever < R '/thing/' # Mounts at /thing/
          def get
             render :some_view
          end
       end
    end

    # File lib/camping/server.rb, line 229
    def call(env)
      if ENV['environment'] == 'development'
        @reloader.reload
      end

      # our switch statement iterates through possible app outcomes, no apps
      # loaded, one app loaded, or multiple apps loaded.
      case @reloader.apps.length
      when 0
        [200, {'content-type' => 'text/html'}, ["I'm sorry but no apps were found."]]
      when 1
        @reloader.apps.values.first.call(env) # When we have one
      else
        # 2 and up get special treatment
        @reloader.apps.each do |name, app|
          app.routes.each do |r|
            if (path_matches?(env['PATH_INFO'], r))
              return app.call(env)
              next
            end
          end
        end

        # Just return the first app if we didn't find a match.
        @reloader.apps.values.first.call(env)
      end
    end

default_options() click to toggle source
Calls superclass method

    # File lib/camping/server.rb, line 105
    def default_options
      super.merge({
        :Port => 3301
      })
    end

loader() click to toggle source

    # File lib/camping/server.rb, line 97
    def loader
      @reloader || nil
    end

middleware() click to toggle source
Calls superclass method

    # File lib/camping/server.rb, line 120
    def middleware
      h = super
      h["development"] << [XSendfile]
      h["deployment"] << [XSendfile]
      h
    end

opt_parser() click to toggle source

    # File lib/camping/server.rb, line 101
    def opt_parser
      Options.new
    end

path_matches?(path, *reg) click to toggle source

path_matches? accepts a regular expression string in our case our apps and controllers

    # File lib/camping/server.rb, line 186
    def path_matches?(path, *reg)
      p = T.(path)
      reg.each do |r|
        return true if Regexp.new(T.(r)).match?(p) && p == T.(r)
      end
      false
    end

public_dir() click to toggle source

defines the public directory to be /public

    # File lib/camping/server.rb, line 173
    def public_dir
      File.expand_path('../public', @reloader.file)
    end

start(file = nil) click to toggle source

Starts the `Camping` `Server`. `Camping` server inherits from Rack::Server so referencing their documentation would be a good idea. @file: String, file location for a camp.rb file.

Calls superclass method

    # File lib/camping/server.rb, line 130
    def start(file = nil)
      commands = ARGV

      # Parse commands
      case commands[0]
      when "new"
        Camping::Commands.new_cmd(commands[1])
        exit
      end

      if options[:version] == true
        puts "Camping v#{Camping::VERSION}"
        exit
      end

      Dir['kindling/*.rb'].each do |kindling|
        require_relative File.expand_path(kindling)
      end

      @reloader.reload!
      r = @reloader

      if options[:routes] == true
        eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { r.reload!; nil }
        ARGV.clear
        Camping::Commands.routes
        exit
      end

      if options[:server] == "console"
        puts "** Starting console"
        eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { r.reload!; nil }
        ARGV.clear
        IRB.start
        exit
      else
        name = server.name[/\w+$/]
        puts "** Starting #{name} on #{options[:Host]}:#{options[:Port]}"
        super()
      end
    end