# module Gear::Nancy

`Nancy`

`Nancy` is `Camping` gear that adds Sinatra style routing shortcuts to the `Object` namespace and to camping controllers themselves:

    get '/' {
      "Hello World"
    }

Calling the get method creates a controller, and in the event of no default app yet, creates an app named Frank.

### Public Class Methods

controller_script(name:, routes:) click to toggle source

returns a formatted string for making a controller class in the Controllers module

    # File lib/gear/nancy.rb, line 128
    def controller_script(name:, routes:)
            %Q[
                    class #{name} < R #{routes}
                    end
            ]
    end

ensure_app(app) click to toggle source

ensures an app exists for the controllers.

    # File lib/gear/nancy.rb, line 39
    def ensure_app(app)
            if Camping::Apps.count == 0
                    # In the case of a naked sinatra style invokation
                    Camping.goes :Frank
                    m = Camping::Apps.first
            else
                    m = app
            end
            m
    end

included(mod) click to toggle source

    # File lib/gear/nancy.rb, line 135
    def included(mod)
            mod.extend(ClassMethods)
            mod::Controllers.extend(ClassMethods)
    end

make_camping_route(method, routes, app=nil, &block) click to toggle source

Make a camping route provided with a method type, a route, an optional app, and a required block:

    get '/another/thing' do
      render :another_view
    end

Calling the shorthand make route helper methods inside of an app module, adds The route to that App. If you don’t have any apps yet, then an app named Frank will be made for you.

    # File lib/gear/nancy.rb, line 60
    def make_camping_route(method, routes, app=nil, &block)

            inf = caller.first.split(":")
            file_name, line_number = inf[0], inf[1]

            meth = method.to_s

            self.normalize_routes(routes) => {rs:, symbol:}

            m = self.ensure_app app

            # Controller name
            cname = "#{meth.capitalize}#{symbol.to_s}"

            begin

                    # Find out which eval script to use.
                    eval_script = m.name.include?("Controllers") ? controller_script(name: cname,routes: rs) : module_script(name: cname,routes: rs)

                    m.module_eval(eval_script, file_name, line_number.to_i)
            rescue => error
                    if error.message.include? "superclass mismatch for class"
                            raise "You've probably tried to define the same route twice using the sinatra method. ['#{rs}']"
                    else
                            raise error
                    end
            end

            # This is an interesting block. At times we'll pass an App to a route
            # which will implicitly call it's `to_proc` method. In those cases, it's
            # that block that is set as the block here, and it returns a Rack response.
            # If we have a rack response instead of string, then we need to extract
            # the response then reassign the values. the r method  is a great helper
            # for that.
            constantine = m.name.include?("Controllers") ? m.const_get("#{cname}") : m::X.const_get("#{cname}")

            if block.arity == -1
                    constantine.send(:define_method, meth) { |*args|
                            block[*args]
                    }
            elsif block.arity == 1
                    constantine.send(:define_method, meth) {
                            res = block[@env] # if we're forwarding a response
                            status = res[0]
                            headers = res[1]
                            body = res[2].flatten.first
                            r(status, body, headers)
                    }
            else # assuming arity is 0
                    constantine.send(:define_method, meth) {
                            block[]
                    }
            end

            return nil
    end

module_script(name:, routes:) click to toggle source

returns a formatted string for making a controller class in the App module

    # File lib/gear/nancy.rb, line 118
    def module_script(name:, routes:)
            %Q[
            module Controllers
                    class #{name} < R #{routes}
                    end
            end
            ]
    end

normalize_routes(routes) click to toggle source

normalizes the routes provided to the controller, then returns some variables used in `make_camping_route`

    # File lib/gear/nancy.rb, line 20
    def normalize_routes(routes)
            s = ""
            rs = ""
            routes.each do |r|
                    rs += "'#{r}'" + ","
                    if r == '/'
                            r = 'Index'
                    end
                    r.split("/").each(&:capitalize!).each{|t|
                            s << t.gsub(/[^a-z0-9A-Z ]/, '')
                    }
            end
            rs.chop!

            symbol = s.to_sym
            {rs: rs, symbol: symbol}
    end

setup(app, *a, &block) click to toggle source

required for compliance reasons

    # File lib/gear/nancy.rb, line 141
    def setup(app, *a, &block) end