equipment 0.1.0

data/lib/ext/app_util.rb

@@ -0,0 +1,28 @@
+require 'equipment'
+
+module Ext
+
+  # Provides the Base#app method. It's used in extensions to get the
+  # application's module.
+  #
+  # == Dependency
+  #
+  # * Equipment
+  #
+  module AppUtil
+    extend Equipment
+
+    module Helpers
+      # this is a curious method that's needed because I can't access MyApp::C
+      # in extensions. I think this is because of how constants are resolved in ruby.
+      # I've seen that Rite will change that. Mabye it will be not needed then.
+      #
+      # In the meanwhile, you can use app::Controllers, app::Views, ...
+      def app
+        @__app ||= Kernel.const_get(/^\w+/.match(self.class.name).to_a.first)
+      end
+    end
+
+  end
+end
+

data/lib/ext/basic_auth.rb

@@ -0,0 +1,71 @@
+require 'equipment'
+require 'ext/security'
+
+module Ext
+
+  # Basic Http Authentication.
+  # 
+  # Inspired by Manfred Stienstra (http://www.fngtps.com/2006/05/basic-authentication-for-camping).
+  # 
+  # == Dependencies
+  #
+  # * Equipment
+  # * Security
+  #
+  # == TODO
+  # * More docs
+  #
+  module BasicAuth
+    extend Equipment
+    depends_on Security
+
+    def self.equip(app)
+      super
+      app::Controllers::Unauthenticated.send :include, app::Base
+    end
+
+    module Base
+
+      # Gets HTTP_Basic credendials from a request. It consists in an array
+      # of user and password.
+      def basic_credentials
+        puts "Authenticate"
+        if d = %w{X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION}.inject([]) \
+          { |d,h| env.has_key?(h) ? env[h].to_s.split : [] }
+          return Base64.decode64(d[1]).split(':')[0..1] if d[0] == 'Basic'
+        end; [nil, nil]
+      end
+      alias :authenticate :basic_credentials
+
+      def authorize(user, pass, force=false)
+        puts "Authorize"
+        return super unless force
+        forward(app::Controller::BasicAuth)
+      end
+
+    end
+
+    module Controllers
+
+      # Called when an url is not authorized. You can override this is your app.
+      class Unauthenticated < Security::Controllers::Unauthenticated
+        class << self
+          attr_accessor :realm
+        end
+        self.realm = 'Camping'
+
+        def get
+          @status = 401
+          @headers['Status'] = 'Unauthorized'
+          @headers['WWW-Authenticate'] = "Basic realm=\"#{self.class.realm}\""
+          super
+        end
+      end
+
+      class Unauthorized < Unauthenticated
+      end
+
+    end
+  end
+end
+

data/lib/ext/controls.rb

@@ -0,0 +1,26 @@
+require 'equipment'
+
+module Ext
+  # Not implemented yet
+  module Controls
+    extend Equipment
+
+    class Control
+      attr_reader :opts
+      def initialize(opts={})
+        @opts = opts
+      end
+
+      def render
+      end
+      alias :to_s :render
+    end
+
+    module Helpers
+      def control(*args)
+        Control.new(*args)
+      end
+    end
+  end
+end
+

data/lib/ext/eruby_view.rb

@@ -0,0 +1,83 @@
+require 'equipment'
+require 'ext/template_view'
+
+begin
+  require 'erubis' # faster eruby parser
+  ERB = Erubis::Eruby
+rescue LoadError
+  require 'erb'
+end
+
+module Ext
+
+  # Gives eruby templating capabilities to your app.
+  #
+  # == Dependencies
+  # 
+  # * Equipment
+  # * TemplateView
+  # * `erubis` package. Available as a gem. If not available, it will use `erb`
+  #
+  # == Usage
+  #
+  # define the template_root to your views :
+  #
+  #  YourApp::Views.template_root = 'tpl/'
+  #
+  # Then put your templates as tpl/xy.erb
+  #
+  # rendering occurs as usual.
+  # 
+  # == Issues
+  #
+  # Rendering only occurs on regular views. Vars and blocks are not really
+  # integrated. You can still use them. Vars as *a and blocks as &b. Like
+  # <%= v[1] %> in your template.
+  #
+  module ErubyView
+    extend Equipment
+    depends_on TemplateView
+
+    module Base
+
+      # Generic wrapper. Forwards to #eruby_view? or ask parent.
+      def has_view?(view)
+        return true if eruby_view?(view)
+        super
+      end
+
+      # Checks if the view exists as an eruby template
+      def eruby_view?(view)
+        if /text\/html|\*\/\*/ =~ (env.HTTP_ACCEPT || '*/*')
+          return true if eruby_template(view)
+        end
+      end
+
+      # Returns the path or nil from a view name. Template extensions are .erb.
+      def eruby_template(view)
+        file = File.join(template_root, "#{view}.erb")
+        File.exists?(file) ? file : nil
+      end
+
+      # Generic wrapper. Forwards to #eruby_view or ask parent.
+      def view(m, *a, &b)
+        if eruby_view?(m)
+          return eruby_view(m, *a, &b)
+        end
+        super
+      end
+
+      # Compiles an eruby template from current instance variables, helpers
+      # and the template
+      #
+      # TODO : Support splat and block
+      # TODO : Implement parse caching here
+      # NOTE : Override @headers['Content-Type'] if necessary here
+      def eruby_view(m, *a, &b)
+        e = ::ERB.new(File.read(eruby_template(m)))
+        e.result(ivs_send(app::V.new).bind(m,*a,&b)) # instance variables are wrapped in V
+      end
+    end
+  end
+end
+

data/lib/ext/flash.rb

@@ -0,0 +1,81 @@
+require 'equipment'
+
+module Ext
+  # Hilight some things for a short time. It's very convenient to have some
+  # look over things in the night. See Helpers#flash for more options.
+  #
+  # == Look :
+  #
+  # in your controller :
+  #
+  #  def get
+  #    flash.error = 'hey !'
+  #    redirect R(Index)
+  #  end
+  #
+  # in your view :
+  #
+  #   def index
+  #     div.error(flash.error) if flash.error
+  #     # ...
+  #   end
+  #
+  # or in your layout.. like you want. The flashed data will then disappear
+  # on the next request.
+  # 
+  # == Dependency
+  #
+  # * Equipment
+  #
+  # == Issues 
+  #
+  # The cookies are not deleted until the end of the session. This is because
+  # Camping does not provide this facility and I didn't implement it. I think
+  # it is okay altrough.
+  # 
+  module Flash
+    extend Equipment
+
+    module Helpers
+      # The flash helper. Use in your controller or view. Retuns
+      # a Flasher.
+      def flash
+        @__flash ||= Flasher.new(cookies)
+      end
+    end
+
+    # The flash class. Stores the data temporarily in the cookies.
+    # Only store Strings.
+    class Flasher
+      def initialize(cookies)
+        @cookies = cookies
+        @data = cookies.dup
+      end
+
+      def [](key)
+        key = to_key(key)
+        @cookies[key] = '' if @cookies.has_key? key
+        return (not @data[key].nil? and not @data[key].empty?) ? @data[key] : nil
+      end
+
+      def []=(key, value)
+        unless value.nil? or value.empty?
+          key = to_key(key)
+          @cookies[key] = value
+          return @data[key] = value
+        end
+      end
+
+      # Allows fancy flash.xy or flash.xy = 'sdsd'
+      def method_missing(m, val='')
+        /=$/ =~ m.to_s ? send(:[]=, m.to_s.sub(/=$/,''), val) : send(:[], m)
+      end
+
+    private
+      def to_key(key)
+       "__flash__#{key}".to_sym
+      end
+    end
+  end
+end
+

data/lib/ext/forms.rb

@@ -0,0 +1,22 @@
+require 'equipment'
+require 'ext/controls'
+
+module Ext 
+  # Not implemented yet
+  module Forms
+    extend Equipment
+    depends_on Controls
+    
+    module Helpers
+      def form_for(xy)
+      end
+    end
+
+    module Mab
+      def form(*a, &b)
+        super
+      end
+    end
+
+  end
+end

data/lib/ext/forward.rb

@@ -0,0 +1,70 @@
+require 'equipment'
+
+module Ext
+
+  # Forwarding is like redirecting but internally. This won't send another
+  # request to the browser. See Base#forward for options.
+  #
+  # *HINT* : forwarding should be used rarely and only on GET. Use redirect on
+  # POST.
+  #
+  # == Workflows
+  #
+  # these are simplified workflows that illustrate the difference between
+  # redirecting and forwarding.
+  # 
+  # === Workflow with redirect
+  # 
+  # Http client -> YourApp::Controller1 -> Http client -> YourApp::Controller2
+  # -> Http client
+  #
+  # === Workflow with forwarding
+  # 
+  # Http client -> YourApp::Controller1 -> YourApp::Controller2 -> Http client
+  #
+  # == Dependency
+  #
+  # * Equipment
+  #
+  # == TODO
+  #
+  # * Allow more options in forwarding
+  module Forward
+    extend Equipment
+
+    def self.equip(app) # :nodoc:
+      super
+      app.module_eval do
+        def self.run(r=$stdin,e=ENV)
+          k, a = self::Controllers.D un("/#{e['PATH_INFO']}".gsub(%r!/+!,'/'))
+          k.send :include, self, self::Base, self::Models
+          k.new(r,e,(m=e['REQUEST_METHOD']||"GET")).service(*a)
+        rescue Forwarder => fw
+          fw.controller.new(nil,H['HTTP_HOST','','SCRIPT_NAME','','HTTP_COOKIE',''],m.to_s).service(*fw.args)
+        rescue Exception => x
+          self::Controllers::ServerError.new(r,e,'get').service(k,m,x)
+        end
+      end
+    end
+
+    class Forwarder < Exception # :nodoc:
+      attr_accessor :controller, :args
+
+      def initialize(controller, *args)
+        @controller, @args = controller, args
+      end
+    end
+
+    module Base
+      # Forwards to another controller
+      #
+      # * controller : the other controller
+      # * *a : only for ruby hackers ;-)
+      #
+      # TODO : make *a accessible for non hackers
+      def forward(controller, *a)
+        raise Forwarder.new(controller, *a)
+      end
+    end
+  end
+end

data/lib/ext/js_helpers.rb

@@ -0,0 +1,50 @@
+require 'equipment'
+require 'ext/app_util'
+require 'ext/use_helper'
+
+
+module Ext
+  module JsHelpers
+    extend Equipment
+    depends_on AppUtil
+    depends_on UseHelper
+
+    module Helpers
+      def join_scripts
+        if javascripts.size > 0
+          link = R(app::Controllers::JoinScripts, javascripts.map{|js| File.basename(js, '.js')}.join(';'))
+          app::Mab.new do
+            script :type=>'text/javascript', :src=>link
+          end.to_s
+        else "" end
+      end
+    end
+
+    module Controllers
+      class JoinScripts
+        class << self
+          attr_accessor :root
+          def urls; ['/scripts/(.*).js'] end
+        end
+
+        self.root = '.'
+
+        def get(scripts)
+          scripts = scripts.split(';').uniq
+          data = ""
+          scripts.each do |script|
+            path = File.join(self.class.root, "#{script}.js")
+            begin
+              data << File.open(path).read
+            rescue Errno::ENOENT => ex
+              data << "// ERROR : #{ex}\n"
+            end
+          end
+
+          data
+        end
+      end
+    end
+  end
+end
+

data/lib/ext/mount.rb

@@ -0,0 +1,152 @@
+require 'equipment'
+require 'ext/sendfile'
+require 'ext/patches'
+
+module Ext
+  # That equipment allows you to mount whole directories as a camping
+  # controller. See ControllersClassMethods#mount for options.
+  #
+  # == Features
+  # 
+  # * Easy to use
+  # * Directory listing (skinnable)
+  # * Resolving Content-Type on file extensions
+  #
+  # == Dependencies
+  #
+  # * Equipment
+  # * Sendfile
+  # * Patches
+  # * `mime-types` package
+  #
+  # == Example
+  #
+  #  Camping.goes :YourApp
+  #
+  #  module YourApp::Controllers
+  #    mount File.dirname(File.expand_path(__FILE__)) #=> YourApp::Controllers::Somefolder
+  #  end
+  # 
+  # that will be available under the url : "/your_app/somefolder"
+  #
+  # Check the mount method in ControllersClassMethod for more informations.
+  # You can also redefine the dir listing template by redefining `mount_listing`
+  # or `yourcontroller_listing`
+  #
+  # eg.
+  #
+  #  module YourApp::Views
+  #
+  #    def mount_listing
+  #      ul do 
+  #        @files.each { |f| li f }
+  #        nil # array bug in markaby
+  #      end
+  #    end
+  #    
+  #    def somefolder_listing # default
+  #    end
+  #
+  #  end
+  #
+  # Controller assignation by hand :
+  #
+  #  module YourApp::Controllers
+  #    class Stylesheets < M File.dirname('../public/css'), :name => false, :listing => false
+  #    end
+  #  end
+  #
+  # == Known bug
+  #
+  # There is a known bug where issued controllers appears as NilClass in the
+  # view. I really don't know why...
+  #
+  module Mount
+    extend Equipment
+    depends_on Patches
+    depends_on Sendfile
+
+    module ControllersClassMethods
+      # Mounts the path given by 'path'
+      #
+      # Options :
+      #   * urls : list of accessible
+      #   * name : name of the controller, false sets no controller
+      #   * listing : set to false if you don't want directory listing.
+      #
+      # Option defaults for '/var/my_path' :
+      #   * urls : /my_path(|/.*)
+      #   * name : MyPath
+      #
+      # Renders the view Views#mount_listing if dir listing is enabled.
+
+      def mount(path, opts={})
+        defaults = {
+          :name    => File.basename(path).gsub(/(^|_)(.)/){ $2.upcase },
+          :url     => "/#{File.basename(path)}",
+          :listing => true
+        } 
+        opts = defaults.merge(opts)
+
+        urls = ["#{opts[:url]}(|/.*)"]
+
+        klass = Class.new() do
+          meta_def(:urls) { urls }
+          meta_def(:path) { path }
+          meta_def(:listing?) { opts[:listing] }
+        end
+        klass.class_eval do
+          def get(file='') # :nodoc:
+            @path = File.join(self.class.path, file)
+            if File.directory?(@path) and self.class.listing?
+              @files = Dir[File.join(@path, '*')].map{|f| File.basename(f)}
+              if has_view?("#{self.class.name.downcase}_listing")
+                render("#{self.class.name.downcase}_listing")
+              else
+                render(:mount_listing)
+              end
+            else
+              sendfile(@path)
+            end
+          end
+        end
+        const_set(opts[:name], klass) if opts[:name]
+
+        if $DBG
+          puts "** mounted #{path}"
+          puts "Controller : #{klass}"
+          puts "Options    : #{opts.inspect}"
+        end
+
+        klass
+      end
+      alias :M :mount
+    end
+
+    module Views
+      # Default dir listing. @files contains all the files.
+      def mount_listing
+        path_info = @env.PATH_INFO.sub /\/$/, ''
+        h1 "Dir listing of #{path_info}"
+        ul do
+          li { a '..', :href => path_info.sub(/\w*$/,'') }
+          @files.each do |file|
+            li { a file, :href => "#{path_info}/#{file}" }
+          end
+          nil
+        end
+      end
+    end
+
+  end
+end
+
+### Mime-types extensions
+
+js_type = MIME::Type.from_hash(
+  'Content-Type' => 'text/javascript',
+  'Extensions'   => ['js']
+)
+
+MIME::Types.add(js_type)
+