camping 2.0 → 2.1

data/lib/camping/mab.rb

@@ -11,6 +11,8 @@ $MAB_CODE = %{
   # and also to replace :href, :action and :src attributes in tags by prefixing the root
   # path.
   class Mab < Markaby::Builder
+    attr_reader :builder
+    
     include Views
     def tag!(*g,&b)
       h=g[-1]

data/lib/camping/reloader.rb

@@ -32,28 +32,7 @@ module Camping
   #
   # You can also give Reloader more than one script.
   class Reloader
-    attr_reader :scripts
-    
-    # This is a simple wrapper which causes the script to reload (if needed)
-    # on any method call.  Then the method call will be forwarded to the
-    # app.
-    class App < (defined?(BasicObject) ? BasicObject : Object) # :nodoc:
-      if superclass == ::Object
-        instance_methods.each { |m| undef_method m unless m =~ /^__/ }
-      end
-      
-      attr_accessor :app, :script
-      
-      def initialize(script)
-        @script = script
-      end
-      
-      # Reloads if needed, before calling the method on the app.
-      def method_missing(meth, *args, &blk)
-        @script.reload!
-        @app.send(meth, *args, &blk)
-      end
-    end
+    attr_reader :scripts, :apps
     
     # This class is doing all the hard work; however, it only works on
     # single files.  Reloader just wraps up support for multiple scripts
@@ -61,13 +40,14 @@ module Camping
     class Script # :nodoc:
       attr_reader :apps, :file, :dir, :extras
       
-      def initialize(file)
+      def initialize(file, callback = nil)
         @file = File.expand_path(file)
         @dir = File.dirname(@file)
         @extras = File.join(@dir, File.basename(@file, ".rb"))
         @mtime = Time.at(0)
         @requires = []
         @apps = {}
+        @callback = callback
       end
       
       # Loads the apps availble in this script.  Use <tt>apps</tt> to get
@@ -94,20 +74,25 @@ module Camping
         
         new_apps = (Camping::Apps - all_apps)
         old_apps = @apps.dup
+        
         @apps = new_apps.inject({}) do |hash, app|
           key = app.name.to_sym
-          hash[key] = (old = old_apps[key]) || App.new(self)
-          hash[key].app = app
-          app.create if app.respond_to?(:create) && !old
+          hash[key] = app
+          
+          if !old_apps.include?(key)
+            @callback.call(app) if @callback
+            app.create if app.respond_to?(:create)
+          end
           hash
         end
+        
         self
       end
       
       # Removes all the apps defined in this script.
       def remove_apps
         @apps.each do |name, app|
-          Camping::Apps.delete(app.app)
+          Camping::Apps.delete(app)
           Object.send :remove_const, name
         end
       end
@@ -149,42 +134,51 @@ module Camping
     # will be loaded relative to the current working directory.
     def initialize(*scripts)
       @scripts = []
+      @apps = {}
       update(*scripts)
     end
     
+    def on_reload(&blk)
+      @callback = blk
+    end
+    
     # Updates the reloader to only use the scripts provided:
     #
     #   reloader.update("examples/blog.rb", "examples/wiki.rb")
     def update(*scripts)
-      old = @scripts.dup
+      old_scripts = @scripts.dup
       clear
+      
       @scripts = scripts.map do |script|
-        s = Script.new(script)
-        if pos = old.index(s)
-          # We already got a script, so we use the old (which might got a mtime)
-          old[pos]
-        else
-          s.load_apps
-        end
+        file = File.expand_path(script)
+        old_scripts.detect { |s| s.file == file } or
+        Script.new(script, @callback)
       end
+      
+      reload!
     end
     
     # Removes all the scripts from the reloader.
     def clear
-      @scrips = []
+      @scripts = []
+      @apps = {}
     end
     
-    # Simply calls reload! on all the Script objects.
-    def reload!
-      @scripts.each { |script| script.reload! }
+    # Returns the script which provided the given app.
+    def script(app)
+      @scripts.each do |script|
+        return script if script.apps.values.include?(app)
+      end
+      
+      false
     end
     
-    # Returns a Hash of all the apps available in the scripts, where the key
-    # would be the name of the app (the one you gave to Camping.goes) and the
-    # value would be the app (wrapped inside App).
-    def apps
-      @scripts.inject({}) do |hash, script|
-        hash.merge(script.apps)
+    # Simply calls reload! on all the Script objects.
+    def reload!
+      @apps = {}
+      @scripts.each do |script|
+        script.reload!
+        @apps.update(script.apps)
       end
     end
   end

data/lib/camping/server.rb

@@ -1,4 +1,5 @@
 require 'irb'
+require 'erb'
 require 'rack'
 require 'camping/reloader'
 
@@ -22,41 +23,182 @@ require 'camping/reloader'
 #   camping blog.rb          # Mounts Blog at /
 #
 # And visit http://localhost:3301/ in your browser.
-class Camping::Server
-  attr_reader :reloader
-  attr_accessor :conf
+module Camping
+  class Server < Rack::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 app1.rb app2.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",
+          "Run in console mode with IRB") { options[:server] = "console" }
+          
+          server_list = ["mongrel", "webrick", "console"]
+          opts.on("-s", "--server NAME",
+          "Server to force (#{server_list.join(', ')})") { |v| options[:server] = v }
 
-  def initialize(conf, paths)
-    @conf = conf
-    @paths = paths
-    @reloader = Camping::Reloader.new
-    connect(@conf.database) if @conf.database
-  end
-  
-  def connect(db)
-    unless Camping.autoload?(:Models)
-      Camping::Models::Base.establish_connection(db)
+          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
+            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
+        end
+        
+        opt_parser.parse!(args)
+        
+        if args.empty?
+          puts opt_parser
+          exit
+        end
+        
+        options[:scripts] = args
+        options
+      end
     end
-  end
-  
-  def find_scripts
-    scripts = @paths.map do |path|
-      case
-      when File.file?(path)
-        path
-      when File.directory?(path)
-        Dir[File.join(path, '*.rb')]
+    
+    def initialize(*)
+      super
+      @reloader = Camping::Reloader.new
+      @reloader.on_reload 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.flatten.compact
-    @reloader.update(*scripts)
-  end
-  
-  def index_page(apps)
-    welcome = "You are Camping"
-    header = <<-HTML
+    end
+    
+    def opt_parser
+      Options.new
+    end
+
+    def default_options
+      super.merge({
+        :Port => 3301,
+        :database => Options::DB
+      })
+    end
+    
+    def middleware
+      h = super
+      h["development"].unshift [XSendfile]
+      h
+    end
+
+    def start
+      if options[:server] == "console"
+        puts "** Starting console"
+        reload!
+        this = self
+        eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { this.reload!; nil }
+        ARGV.clear
+        IRB.start
+        exit
+      else
+        name = server.name[/\w+$/]
+        puts "** Starting #{name} on #{options[:Host]}:#{options[:Port]}"
+        super
+      end
+    end
+    
+    def find_scripts
+      scripts = options[:scripts].map do |path|
+        if File.file?(path)
+          path
+        elsif File.directory?(path)
+          Dir[File.join(path, '*.rb')]
+        end
+      end.flatten.compact
+	  
+      @reloader.update(*scripts)
+    end
+    
+    def reload!
+      find_scripts
+    end
+    
+    def app
+      self
+    end
+    
+    def call(env)
+      reload!
+      apps = @reloader.apps
+
+      case apps.length
+      when 0
+        index_page(apps)
+      when 1
+        apps.values.first.call(env)
+      else
+        apps.each do |name, app|
+          mount = name.to_s.downcase
+          case env["PATH_INFO"]
+          when %r{^/#{mount}}
+            env["SCRIPT_NAME"] = env["SCRIPT_NAME"] + $&
+            env["PATH_INFO"] = $'
+            return app.call(env)
+          when %r{^/code/#{mount}}
+            return [200, {'Content-Type' => 'text/plain', 'X-Sendfile' => @reloader.script(app).file}, []]
+          end
+        end
+        
+        index_page(apps)
+      end
+    end
+    
+    def index_page(apps)
+      [200, {'Content-Type' => 'text/html'}, [TEMPLATE.result(binding)]]
+    end
+    
+    SOURCE = <<-HTML
 <html>
   <head>
-    <title>#{welcome}</title>
+    <title>You are Camping</title>
     <style type="text/css">
       body { 
         font-family: verdana, arial, sans-serif; 
@@ -66,113 +208,58 @@ class Camping::Server
       h1, h2, h3, h4, h5, h6 {
         font-family: utopia, georgia, serif;
       }
+      h3 { display: inline; }
     </style>
   </head>
   <body>
-    <h1>#{welcome}</h1>
+    <% if apps.empty? %>
+      <p>Good day.  I'm sorry, but I could not find any Camping apps.
+      You might want to take a look at the console to see if any errors
+      have been raised.</p>
+    <% else %>
+      <p>Good day.  These are the Camping apps you've mounted.</p>
+      <ul>
+      <% apps.each do |name, app| %>
+        <li>
+          <h3><a href="/<%= name.to_s.downcase %>"><%= app %></a></h3>
+          <small> / <a href="/code/<%= name.to_s.downcase %>">View source</a></small>
+        </li>
+      <% end %>
+      </ul>
+    <% end %>
+  </body>
+</html>
     HTML
-    footer = '</body></html>'
-    main = if apps.empty?
-      "<p>Good day.  I'm sorry, but I could not find any Camping apps. "\
-      "You might want to take a look at the console to see if any errors "\
-      "have been raised.</p>"
-    else
-      "<p>Good day.  These are the Camping apps you've mounted.</p><ul>" + 
-      apps.map do |mount, app|
-        "<li><h3 style=\"display: inline\"><a href=\"/#{mount}\">#{app}</a></h3><small> / <a href=\"/code/#{mount}\">View source</a></small></li>"
-      end.join("\n") + '</ul>'
-    end
     
-    header + main + footer
-  end
-  
-  def app
-    reload!
-    all_apps = apps
-    rapp = case all_apps.length
-    when 0
-      proc{|env|[200,{'Content-Type'=>'text/html'},index_page([])]}
-    when 1
-      apps.values.first
-    else
-      hash = {
-        "/" => proc {|env|[200,{'Content-Type'=>'text/html'},index_page(all_apps)]}
-      }
-      all_apps.each do |mount, wrapp|
-        # We're doing @reloader.reload! ourself, so we don't need the wrapper.
-        app = wrapp.app
-        hash["/#{mount}"] = app
-        hash["/code/#{mount}"] = proc do |env|
-          [200,{'Content-Type'=>'text/plain','X-Sendfile'=>wrapp.script.file},'']
+    TEMPLATE = ERB.new(SOURCE)
+    
+    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
-      Rack::URLMap.new(hash)
-    end
-    rapp = Rack::ContentLength.new(rapp)
-    rapp = Rack::Lint.new(rapp)
-    rapp = XSendfile.new(rapp)
-    rapp = Rack::ShowExceptions.new(rapp)
-  end
-  
-  def apps
-    @reloader.apps.inject({}) do |h, (mount, wrapp)|
-      h[mount.to_s.downcase] = wrapp
-      h
-    end
-  end
-  
-  def call(env)
-    app.call(env)
-  end
-  
-  def start
-    handler, conf = case @conf.server
-    when "console"
-      puts "** Starting console"
-      reload!
-      this = self; eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { this.reload!; nil }
-      ARGV.clear
-      IRB.start
-      exit
-    when "mongrel"
-      puts "** Starting Mongrel on #{@conf.host}:#{@conf.port}"
-      [Rack::Handler::Mongrel, {:Port => @conf.port, :Host => @conf.host}]
-    when "webrick"
-      puts "** Starting WEBrick on #{@conf.host}:#{@conf.port}"
-      [Rack::Handler::WEBrick, {:Port => @conf.port, :BindAddress => @conf.host}]
-    end
-    reload!
-    handler.run(self, conf) 
-  end
-  
-  def reload!
-    find_scripts
-    @reloader.reload!
-  end
-
-  # A Rack middleware for reading X-Sendfile. Should only be used in
-  # development.
-  class XSendfile
-  
-    HEADERS = [
-      "X-Sendfile",
-      "X-Accel-Redirect",
-      "X-LIGHTTPD-send-file"
-    ]
-  
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Rack::Utils::HeaderHash.new(headers)
-      if header = HEADERS.detect { |header| headers.include?(header) }
-        path = headers[header]
-        body = File.read(path)
-        headers['Content-Length'] = body.length.to_s
+      
+      if "".respond_to?(:bytesize)
+        def size(str)
+          str.bytesize
+        end
+      else
+        def size(str)
+          str.size
+        end
       end
-      [status, headers, body]
     end
-  end    
+  end
 end