equipment 0.1.0 → 1.4.84

data/lib/ext/basic_auth.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require 'equipment'
 require 'ext/security'
 
@@ -7,8 +8,11 @@ module Ext
   # 
   # Inspired by Manfred Stienstra (http://www.fngtps.com/2006/05/basic-authentication-for-camping).
   # 
+  # See Security for more informations.
+  # 
   # == Dependencies
   #
+  # * Base64
   # * Equipment
   # * Security
   #
@@ -19,28 +23,24 @@ module Ext
     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
+        [nil, nil]
       end
-      alias :authenticate :basic_credentials
 
-      def authorize(user, pass, force=false)
-        puts "Authorize"
-        return super unless force
-        forward(app::Controller::BasicAuth)
+      # This method won't be accessible if this module is on the roof of other
+      # all.
+      def authenticate
+        creds = basic_credentials
+        return super unless creds[0]
+        return *creds
       end
 
     end
@@ -52,7 +52,7 @@ module Ext
         class << self
           attr_accessor :realm
         end
-        self.realm = 'Camping'
+        @realm = 'Camping'
 
         def get
           @status = 401
@@ -62,8 +62,8 @@ module Ext
         end
       end
 
-      class Unauthorized < Unauthenticated
-      end
+#      class Unauthorized < Unauthenticated
+#      end
 
     end
   end

data/lib/ext/controls.rb

@@ -1,26 +1,28 @@
 require 'equipment'
 
 module Ext
-  # Not implemented yet
+  # A generic html control generation mechanism.
+  # 
+  # TODO : Finish this
   module Controls
     extend Equipment
 
-    class Control
-      attr_reader :opts
-      def initialize(opts={})
-        @opts = opts
+    module Views
+      def _control_for(thing, opts={})
+        thing.class.ancestors.each do |a|
+          m = '_' + a.name.gsub('::', '__').downcase + '_control'
+          if respond_to? m
+            return send(m, name, thing)
+          end
+        end
+        return "No control for #{thing}"
       end
 
-      def render
-      end
-      alias :to_s :render
-    end
-
-    module Helpers
-      def control(*args)
-        Control.new(*args)
+      def _text_control(str, opts={})
+        input {:type=>'text', :value=>str}.merge(opts)
       end
+      alias :_string_control :_text_control
+      alias :_numeric_control :_text_control
     end
   end
 end
-

data/lib/ext/flash.rb

@@ -4,7 +4,13 @@ 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 :
+  # == How it works
+  #
+  # For example, you set flash.info to "hey!". Next time it is accessed,
+  # it will be available until the end of the controller's execution. So
+  # on the next page, flash.info will be back to nil.
+  #
+  # == Example
   #
   # in your controller :
   #
@@ -36,44 +42,56 @@ module Ext
   module Flash
     extend Equipment
 
+    module Base
+      def initialize(r,e,m)
+        super
+        @flash = Flasher.new(@k, @cookies)
+      end
+    end
+
     module Helpers
       # The flash helper. Use in your controller or view. Retuns
       # a Flasher.
-      def flash
-        @__flash ||= Flasher.new(cookies)
-      end
+      attr_reader :flash
     end
 
     # The flash class. Stores the data temporarily in the cookies.
     # Only store Strings.
     class Flasher
-      def initialize(cookies)
-        @cookies = cookies
-        @data = cookies.dup
+      def initialize(cookies_in, cookies_out)
+        @in, @out = cookies_in, cookies_out
       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
+        key = convert_key(key)
+        if @in[key] and not @in[key].empty?
+          @out[key] = '' if @out.has_key? key
+          return @in[key]
+        else
+          return nil
+        end
       end
 
       def []=(key, value)
         unless value.nil? or value.empty?
-          key = to_key(key)
-          @cookies[key] = value
-          return @data[key] = value
+          key = convert_key(key)
+          @in[key] = @out[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)
+      def method_missing(m, *args)
+        if /=$/ =~ m.to_s
+          send(:[]=, m.to_s.sub(/=$/,''), *args)
+        else
+          raise NoMethodError, "Cannot pass arguments to #{m}, use = to assign data" unless args.empty?
+          send(:[], m)
+        end
       end
 
     private
-      def to_key(key)
-       "__flash__#{key}".to_sym
+      def convert_key(key)
+       "__flash__#{key}"
       end
     end
   end

data/lib/ext/form_helpers.rb

@@ -0,0 +1,46 @@
+require 'equipment'
+require 'ext/active_record'
+
+module Ext
+  # Hey a FormHelper.
+  #
+  # This extension is quite simple for now and only provides on method
+  # used to generate forms form active record models. That method is
+  # also not capable of generating something else than text fields.
+  #
+  # When complete, this module will be used by Ext::Scaffold.
+  #
+  # == Dependencies
+  #
+  # * Equipment
+  # * Ext::ActiveRecord
+  # 
+  # == TODO
+  # 
+  # * Implement and use Ext::Controls
+  #
+  module FormHelpers
+    extend Equipment
+    depends_on ActiveRecord
+
+    module Helpers
+      # No relations yet
+      def form_for(entity, opts)
+        entity = entity.new if entity.kind_of? Class
+        form({:method=>:post}.merge(opts)) do
+          entity.attributes.each do |prop|
+            unless /^id$|_id$/.match prop[0].to_s
+              input_name = prop[0]
+              label prop[0].to_s, :for=>input_name; br
+              input :type=>'text', :name=>input_name, :value=>entity.send(prop[0]); br
+            end
+          end
+
+          input :type=>:hidden, :name=>'id', :value=>entity.id if entity.id
+          input :type=>:submit
+        end
+      end
+    end
+  end
+end
+

data/lib/ext/forward.rb

@@ -5,9 +5,16 @@ 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
+  # *HINT* : forwarding should be used rarely in apps. Use redirect on
   # POST.
   #
+  # == Added features
+  #
+  # If $DBG is enabled :
+  # 
+  # * Print errors in the console
+  # * Show the requested URI with the dispatched controller.
+  #
   # == Workflows
   #
   # these are simplified workflows that illustrate the difference between
@@ -28,7 +35,7 @@ module Ext
   #
   # == TODO
   #
-  # * Allow more options in forwarding
+  # * Limit forwarding to X requests
   module Forward
     extend Equipment
 
@@ -36,22 +43,36 @@ module Ext
       super
       app.module_eval do
         def self.run(r=$stdin,e=ENV)
+          puts "REQUEST: `#{e['PATH_INFO']}`" if $DBG
+          self::Controllers.M
           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)
+          begin
+            puts "    --> #{k}" if $DBG
+            k.new(r,e,(m=m||e['REQUEST_METHOD']||'GET')).service(*a)
+          rescue Forwarder => fw
+            k, m, a = fw.controller, fw.method, fw.args
+
+            if /NotFound$/ =~ k.name # facility for NotFound controller
+              a = [e['PATH_INFO']] if a.empty? or not a.first
+              m = 'get'
+            end
+            
+            retry
+          rescue Exception => x
+            pp x if $DBG
+            pp x.backtrace if $DBG
+            k, a, m = self::Controllers::ServerError, [k,m,x], 'GET'
+            retry
+          end
         end
       end
     end
 
     class Forwarder < Exception # :nodoc:
-      attr_accessor :controller, :args
+      attr_accessor :controller, :method, :args
 
-      def initialize(controller, *args)
-        @controller, @args = controller, args
+      def initialize(controller, method, *args)
+        @controller, @method, @args = controller, method, args
       end
     end
 
@@ -59,12 +80,20 @@ module Ext
       # Forwards to another controller
       #
       # * controller : the other controller
-      # * *a : only for ruby hackers ;-)
+      # * method : the designed method, actual method if not specified
+      # * *args : method arguments
       #
-      # TODO : make *a accessible for non hackers
-      def forward(controller, *a)
-        raise Forwarder.new(controller, *a)
+      def forward(controller, method=@method, *a)
+        # method selector, :method=>'get' or 'post'
+
+        if /NotFound$/ =~ controller.name # facility for NotFound controller
+          a = [e['PATH_INFO']] if a.empty? or not a.first
+          method = 'get'
+        end
+
+        raise Forwarder.new(controller, method, *a)
       end
     end
   end
 end
+

data/lib/ext/js_helpers.rb

@@ -2,7 +2,6 @@ require 'equipment'
 require 'ext/app_util'
 require 'ext/use_helper'
 
-
 module Ext
   module JsHelpers
     extend Equipment
@@ -10,38 +9,86 @@ module Ext
     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
+
+      # Returns a link to the JoinJavascripts controller with the desired 
+      # scripts. If no script is passed, it will use the UseHelper specified 
+      # javascripts.
+      # 
+      # This is useful to avoid IE bugs. IE does not guarantee the javascript 
+      # loading order. That way, you are sure they're always as you want ;-)
+      # 
+      # raises ArgumentError if the produced url is longer than 512 chars.
+      #
+      # == Example
+      #
+      #  joined_js('prototype.js', 'event-selector.js')
+      #  #=> "/join_js/prototype-and-event-selector.js"
+      # 
+      # == Usage in the Views
+      #
+      #  def layout
+      #    html do
+      #      head do
+      #        script :type=>'text/css', :src=>joined_js
+      #      end
+      #      body { yield }
+      #    end
+      #  end
+      #
+      #  def index
+      #    use 'prototype.js', 'event-selector.js', 'my-script.js'
+      #  end
+      #
+      def joined_js(*scripts)
+        scripts = javascripts if scripts.empty?
+        script_name = scripts.map{|js| File.basename(js, '.js')}.join('-and-')
+        url = R(app::Controllers::JoinJavascripts, script_name)
+        raise ArgumentError, "Script name '#{script_name}' is too long" unless url.to_s.size < 512
+        url
       end
     end
 
     module Controllers
-      class JoinScripts
+      # Returns a big script with all the requested scripts.
+      # -and- is the separator.
+      #
+      # It will look in it's JoinJavascripts.lookup_paths accessor for
+      # paths where the scripts exist. ['.'] is the default.
+      # 
+      # If a script is not found, it will throw a javascript error.
+      class JoinJavascripts
         class << self
-          attr_accessor :root
-          def urls; ['/scripts/(.*).js'] end
+          attr_accessor :lookup_paths
+          def urls; ['/join_js/([^\/\.]*).js'] end
         end
 
-        self.root = '.'
+        @lookup_paths = [File.join(Equipment::DATA_PATH, 'js')]
 
         def get(scripts)
-          scripts = scripts.split(';').uniq
+          @headers['Content-Type'] = 'text/javascript'
+          scripts = scripts.split('-and-').map{|s|s+'.js'}
+
+          return "throw 'no files passed to JoinJavascript controller'" if scripts.empty?
+
           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"
+            message = "#{script} not found"
+            self.class.lookup_paths.each do |path|
+              path = File.join(path, script)
+              if File.exists?(path)
+                begin
+                  data << File.read(path)
+                  message = nil
+                  break
+                rescue => ex
+                  message = ex.message
+                end
+              end
             end
+            data << "throw '#{message.gsub("'", "\\\\'")}'\n" if message
           end
 
-          data
+          return data
         end
       end
     end