camping 2.1.532 → 3.0.0

data/lib/camping/gear/nancy.rb

@@ -0,0 +1,170 @@
+module Gear
+
+	# 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.
+	module Nancy
+
+		class << self
+
+
+			# normalizes the routes provided to the controller, then returns some variables
+			# used in make_camping_route
+			def normalize_routes(routes)
+				s = ""
+				rs = ""
+				routes.each do |r|
+					if r == '/'
+						r = 'Index'
+					end
+					rs += "'#{r}'" + ","
+					r.split("/").each(&:capitalize!).each{|t|
+						s << t.gsub(/[^a-z0-9A-Z ]/, '')
+					}
+					# s << r
+				end
+				rs.chop!
+
+				symbol = s.to_sym
+				{s: s, rs: rs, symbol: symbol}
+			end
+
+			# ensures an app exists for the controllers.
+			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
+
+			# 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.
+			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) => {s:, rs:, symbol:}
+
+				m = self.ensure_app app
+
+				# Controller name
+				cname = "#{meth.capitalize}#{symbol.to_s}"
+
+				begin
+					m.module_eval(%Q[
+					module Controllers
+						class #{cname} < R #{rs}
+						end
+					end
+					], 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::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
+
+			def included(mod)
+				mod.extend(ClassMethods)
+			end
+
+			# required for compliance reasons
+			def setup(app, *a, &block) end
+
+		end
+
+		module ClassMethods
+
+			# Helper methods added to your Camping app that facilitates
+			def get(*routes, &block)     Nancy.make_camping_route('get', routes, self, &block) end
+			def put(*routes, &block)     Nancy.make_camping_route('put', routes, self, &block) end
+			def post(*routes, &block)    Nancy.make_camping_route('post', routes, self, &block) end
+			def delete(*routes, &block)  Nancy.make_camping_route('delete', routes, self, &block) end
+			def head(*routes, &block)    Nancy.make_camping_route('head', routes, self, &block) end
+			def patch(*routes, &block)   Nancy.make_camping_route('patch', routes, self, &block) end
+			def link(*routes, &block)    Nancy.make_camping_route('link', routes, self, &block) end
+			def unlink(*routes, &block)  Nancy.make_camping_route('unlink', routes, self, &block) end
+
+			# Turns this App into a proc to be consumed by one of the block based route generators
+			# An easy way to forward requests to an app.
+			# a references self, that's then captured by the proc, which is a closure.
+			# because it's a closure, and because it captures self, we can then call
+			# this proc anywhere we want.
+			#
+			# The syntax: `a[e]` is an implicit call to the `#call` method. the brackets
+			# are syntatic sugar to get this to work. The following code is equivalent:
+			#
+			#	 e = [] # given e is a rack array.
+			#  a.call(e)
+			#  a.(e)
+			#  a[e]
+			#
+			# This code is defined in the Nancy Camping Gear. Specifically in it's
+			# ClassMethods module. ClassMethods is then extended onto our Camping app,
+			# Giving it the appearance of being a method of the module. In our cases
+			# Our modules are our Apps.
+			# The code:
+			#
+			#   def to_proc = method(:call).to_proc
+			#
+			# First gets a `Method` object from the app, then converts it to a proc.
+			# In our case we just want call, so this makes the whole api pretty simple.
+			# def to_proc = method(:call).to_proc
+			def to_proc = method(:call).to_proc
+
+		end
+
+	end
+end

data/lib/camping/loads.rb

@@ -0,0 +1,15 @@
+# Loads things into camping.rb
+
+# external dependencies
+require "uri"
+require "rack"
+require 'rubygems'
+require 'bundler/setup'
+
+# internal dependencies
+require 'camping/tools'
+require 'camping/gear/filters'
+require 'camping/gear/nancy'
+require 'camping/gear/inspection'
+require 'camping/gear/kuddly'
+

data/lib/camping/mab.rb

@@ -33,7 +33,7 @@ $MAB_CODE = %q{
   end
 }
 
-Camping::S.sub! /autoload\s*:Mab\s*,\s*['"]camping\/mab['"]/, $MAB_CODE
+Camping::S.sub!(/autoload\s*:Mab\s*,\s*['"]camping\/mab['"]/, $MAB_CODE)
 Camping::Apps.each do |c|
   c.module_eval $MAB_CODE
 end

data/lib/camping/reloader.rb

@@ -33,13 +33,14 @@ module Camping
   # You can also give Reloader more than one script.
   class Reloader
     attr_reader :file
-    
+
     def initialize(file, &blk)
       @file = file
       @mtime = Time.at(0)
       @requires = []
       @apps = {}
       @callback = blk
+
     end
 
     def name
@@ -50,8 +51,8 @@ module Camping
         File.basename(base).to_sym
       end
     end
-    
-    # Loads the apps availble in this script.  Use <tt>apps</tt> to get
+
+    # Loads the apps available in this script.  Use <tt>apps</tt> to get
     # the loaded apps.
     def load_apps(old_apps)
       all_requires = $LOADED_FEATURES.dup
@@ -62,7 +63,7 @@ module Camping
       @requires = []
       dirs = []
       new_apps = Camping::Apps - all_apps
-      
+
       @apps = new_apps.inject({}) do |hash, app|
         if file = app.options[:__FILE__]
           full = File.expand_path(file)
@@ -72,7 +73,7 @@ module Camping
 
         key = app.name.to_sym
         hash[key] = app
-        
+
         if !old_apps.include?(key)
           @callback.call(app) if @callback
           app.create if app.respond_to?(:create)
@@ -87,18 +88,22 @@ module Camping
       end
 
       @mtime = mtime
-      
+
       self
     end
 
+    # load_file
+    #
+    # Rack::Builder is mainly used to parse a config.ru file and to
+    # build a rack app with middleware from that.
     def load_file
       if @file =~ /\.ru$/
-        @app,_ = Rack::Builder.parse_file(@file)
+        @app = Rack::Builder.parse_file(@file)
       else
         load(@file)
       end
     end
-    
+
     # Removes all the apps defined in this script.
     def remove_apps
       @requires.each do |(path, full)|
@@ -112,7 +117,7 @@ module Camping
     ensure
       @apps.clear
     end
-    
+
     # Reloads the file if needed.  No harm is done by calling this multiple
     # times, so feel free call just to be sure.
     def reload
@@ -123,7 +128,7 @@ module Camping
     def reload!
       load_apps(remove_apps)
     end
-    
+
     # Checks if both scripts watches the same file.
     def ==(other)
       @file == other.file
@@ -136,20 +141,20 @@ module Camping
         @apps
       end
     end
-    
+
     private
-    
+
     def mtime
       @requires.map do |(path, full)|
         File.mtime(full)
       end.reject {|t| t > Time.now }.max || Time.now
     end
-    
-    # Figures out the full path of a required file. 
+
+    # Figures out the full path of a required file.
     def full_path(req)
-      return req if File.exists?(req)
-      dir = $LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) }
-      if dir 
+      return req if File.exist?(req)
+      dir = $LOAD_PATH.detect { |l| File.exist?(File.join(l, req)) }
+      if dir
         File.expand_path(req, File.expand_path(dir))
       else
         req

data/lib/camping/server.rb

@@ -1,15 +1,17 @@
 require 'irb'
 require 'erb'
 require 'rack'
+require 'rackup'
+require 'camping/version'
 require 'camping/reloader'
+require 'camping/commands'
 
 # == The Camping Server (for development)
 #
 # Camping includes a pretty nifty server which is built for development.
 # It follows these rules:
-# 
-# * Load all Camping apps in a directory or a file.
-# * Load new apps that appear in that directory or that file.
+#
+# * Load all Camping apps in a file.
 # * Mount those apps according to their name. (e.g. Blog is mounted at /blog.)
 # * Run each app's <tt>create</tt> method upon startup.
 # * Reload the app if its modification time changes.
@@ -19,109 +21,88 @@ require 'camping/reloader'
 #
 # Run it like this:
 #
-#   camping examples/        # Mounts all apps in that directory
 #   camping blog.rb          # Mounts Blog at /
 #
 # And visit http://localhost:3301/ in your browser.
 module Camping
-  class Server < Rack::Server
+  class Server < Rackup::Server
     class Options
-      if home = ENV['HOME'] # POSIX
-        DB = File.join(home, '.camping.db')
-        RC = File.join(home, '.campingrc')
-      elsif home = ENV['APPDATA'] # MSWIN
-        DB = File.join(home, 'Camping.db')
-        RC = File.join(home, 'Campingrc')
-      else
-        DB = nil
-        RC = nil
-      end
-      
-      HOME = File.expand_path(home) + '/'
-      
+
       def parse!(args)
         args = args.dup
         options = {}
-        
         opt_parser = OptionParser.new("", 24, '  ') do |opts|
-          opts.banner = "Usage: camping my-camping-app.rb"
-          opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+          opts.banner = "Usage: camping Or: camping my-camping-app.rb"
+
+          # opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+
           opts.separator ""
           opts.separator "Specific options:"
-          
+
           opts.on("-h", "--host HOSTNAME",
           "Host for web server to bind to (default is all IPs)") { |v| options[:Host] = v }
-          
+
           opts.on("-p", "--port NUM",
           "Port for web server (defaults to 3301)") { |v| options[:Port] = v }
-          
-          db = DB.sub(HOME, '~/') if DB
-          opts.on("-d", "--database FILE",
-          "SQLite3 database path (defaults to #{db ? db : '<none>'})") { |db_path| options[:database] = db_path }
-          
-          opts.on("-C", "--console",
+
+          opts.on("-c", "--console",
           "Run in console mode with IRB") { options[:server] = "console" }
-          
-          server_list = ["thin", "webrick", "console"]
+
+          opts.on("-e", "--env ENVIRONMENT",
+          "Sets the environment. (defaults: development)") { |v| options[:environment] = ENV['environment'] = v }
+
+          server_list = ["thin", "webrick", "console", "puma", "tipi", "falcon"]
           opts.on("-s", "--server NAME",
           "Server to force (#{server_list.join(', ')})") { |v| options[:server] = v }
 
           opts.separator ""
           opts.separator "Common options:"
-          
+
           # No argument, shows at tail.  This will print an options summary.
           # Try it and see!
-          opts.on_tail("-?", "--help", "Show this message") do
+          opts.on("-?", "--help", "Show this message") do
             puts opts
             exit
           end
 
           # Another typical switch to print the version.
-          opts.on_tail("-v", "--version", "Show version") do
-            puts Gem.loaded_specs['camping'].version
-            exit
-          end
+          opts.on("-v", "--version", "Show version") { options[:version] = true }
+
+          # Show Routes
+          opts.on("-r", "--routes", "Show Routes") { options[:routes] = true }
+
         end
-        
+
         opt_parser.parse!(args)
-        
+
         if args.empty?
-          puts opt_parser
-          exit
+          args << "camp.rb"
         end
-        
+
         options[:script] = args.shift
         options
       end
     end
-    
+
     def initialize(*)
       super
       @reloader = Camping::Reloader.new(options[:script]) do |app|
         if !app.options.has_key?(:dynamic_templates)
 		      app.options[:dynamic_templates] = true
 	      end
-	      
-        if !Camping::Models.autoload?(:Base) && options[:database]
-          Camping::Models::Base.establish_connection(
-            :adapter => 'sqlite3',
-            :database => options[:database]
-          )
-        end
       end
     end
-    
+
     def opt_parser
       Options.new
     end
 
     def default_options
       super.merge({
-        :Port => 3301,
-        :database => Options::DB
+        :Port => 3301
       })
     end
-    
+
     def middleware
       h = super
       h["development"] << [XSendfile]
@@ -129,6 +110,33 @@ module Camping
     end
 
     def start
+
+      commands = []
+      ARGV.each do |cmd|
+        commands << cmd
+      end
+
+      # 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
+
+      if options[:routes] == true
+        @reloader.reload!
+        r = @reloader
+        eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { r.reload!; nil }
+        ARGV.clear
+        Camping::Commands.routes
+        exit
+      end
+
       if options[:server] == "console"
         puts "** Starting console"
         @reloader.reload!
@@ -138,52 +146,119 @@ module Camping
         IRB.start
         exit
       else
+        @reloader.reload!
+        r = @reloader
+        Camping.make_camp
         name = server.name[/\w+$/]
         puts "** Starting #{name} on #{options[:Host]}:#{options[:Port]}"
         super
       end
     end
 
+    # defines the public directory to be /public
     def public_dir
       File.expand_path('../public', @reloader.file)
     end
-    
+
+    # 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.
     def app
-      Rack::Cascade.new([Rack::File.new(public_dir), self], [405, 404, 403])
+      Rack::Cascade.new([Rack::Files.new(public_dir), self], [405, 404, 403])
     end
-    
-    def current_app
-      @reloader.reload
-      apps = @reloader.apps
-      return apps.values.first if apps.size == 1
-      if key = apps.keys.grep(/^#{@reloader.name}$/i)[0]
-        apps[key]
+
+    # path_matches?
+    # accepts a regular expression string
+    # in our case our apps and controllers
+    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
 
+    # Ensure trailing slash lambda
+    T ||= -> (u) {
+      u << "/" if u[-1] != "/"; u
+    }
+
+    # 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
+    #
     def call(env)
-      app = current_app || raise("Could not find an app called `#{@reloader.name}`")
-      app.call(env)
+      if ENV['environment'] == 'development'
+        @reloader.reload
+        Camping.make_camp
+      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
-    
+
     class XSendfile
       def initialize(app)
         @app = app
       end
-      
+
       def call(env)
         status, headers, body = @app.call(env)
-        
+
         if key = headers.keys.grep(/X-Sendfile/i).first
           filename = headers[key]
           content = open(filename,'rb') { | io | io.read}
           headers['Content-Length'] = size(content).to_s
           body = [content]
         end
-        
+
         return status, headers, body
       end
-      
+
       if "".respond_to?(:bytesize)
         def size(str)
           str.bytesize

data/lib/camping/session.rb

@@ -1,3 +1,6 @@
+require 'rack/session'
+class InsecureSecret < Exception #:nodoc: all
+end
 module Camping
   # == Getting Started
   #
@@ -9,7 +12,7 @@ module Camping
   #    to store your application's data.
   #
   #   require 'camping/session'    # 1
-  #   
+  #
   #   module Nuts
   #     set :secret, "Oh yeah!"    # 2
   #     include Camping::Session   # 3
@@ -27,9 +30,9 @@ module Camping
   module Session
     def self.included(app)
       key    = "#{app}.state".downcase
-      secret = app.options[:secret] || [__FILE__, File.mtime(__FILE__)].join(":")
-      
-      app.use Rack::Session::Cookie, :key => key, :secret => secret
+      secret = app.options[:secret] || ['camping-secret',__FILE__, File.mtime('Rakefile')].join(":")*2
+      raise InsecureSecret, "You're Session Secret is too short. Minimum length is 64." if secret.length < 64
+      app.use Rack::Session::Cookie, :key => key, :secrets => secret
     end
   end
-end
+end

data/lib/camping/template.rb

@@ -8,10 +8,9 @@ end
 
 $TILT_CODE = %{
   Template = Tilt
-  include Tilt::CompileSite unless self.options[:dynamic_templates]
 }
 
-Camping::S.sub! /autoload\s*:Template\s*,\s*['"]camping\/template['"]/, $TILT_CODE
+Camping::S.sub!(/autoload\s*:Template\s*,\s*['"]camping\/template['"]/, $TILT_CODE)
 Camping::Apps.each do |c|
   c.module_eval $TILT_CODE
 end