equipment 0.1.0 → 1.4.84

data/lib/ext/security.rb

@@ -1,79 +1,114 @@
 require 'equipment'
-require 'ext/patches'
+require 'ext/app_util'
 require 'ext/forward'
+require 'ext/view'
 
 module Ext
 
-  # Generic authentication module. Used by BasicAuth for example.
+  # Generic authentication module. Used by BasicAuth for example. 
+  # 
+  # == Warning
+  #
+  # Never use this module alone. You should at least create another module that
+  # extends Base. This is because of how Equipment works right now. You wouldn't
+  # be able to define authenticate and authorize and call super. Ask zimbatm for
+  # more information on this if you're interested... :-)
+  #
+  # == Usage
+  # 
+  # Security is split in two methods ; authenticate and authorize.
+  # The role of authenticate is to detect the user, loaded by session or
+  # other. The role of authorize is to tell if the user is authorized or
+  # not. Authorize must be overriden if you want to secure some place of
+  # your app. Defining it in Base will act globally. You can also define
+  # them individually in each controller, like you want. Finally, both
+  # methods are chained, so you can use super to mix various security
+  # mechanism.
+  #
+  # In your app, override authenticate if you want to load your users
+  # from the database. eg.
+  #
+  #  def authenticate
+  #    user, pass = *super
+  #    @user = User.find_by_login_and_password(user, pass)
+  #    return [user, pass] if @user
+  #    return [nil, nil]
+  #  end
+  #
+  # Override authotize like that
+  #
+  #  def authorize(user, pass)
+  #    # some auth mechanism
+  #    if user == pass
+  #      return true
+  #    else
+  #      return false
+  #    end
+  #  end
   #
   # == Dependencies
   # 
   # * Equipment
+  # * AppUtil
   # * Forward
-  # * Patches
-  #
-  # == TODO
+  # * View
   #
-  # * More doc
   module Security
     extend Equipment
-    depends_on Patches
+    depends_on AppUtil
     depends_on Forward
-
-    def self.equip(app)
-      super
-      app::Controllers::Unauthorized.send :include, app::C, app::Base, app::Models
-      app::Controllers::Unauthenticated.send :include, app::C, app::Base, app::Models
-    end
+    depends_on View
 
     module Base
-      # Blank authentication, returns [nil, nil]
+      # Blank authentication terminator, returns [nil, nil]
       def authenticate; return nil, nil end
 
-      # Blank authorization, returns true
-      def authorize(user, pass, force=false); not force; end
+      # Blank authorization terminator, returns nil as ternary operator.
+      def authorize(user, pass); return nil end
 
       # Checks the credencials when serving a page if `authorize` is defined
-      # in your app, Base or controller.
+      # in your app, Base or controller. If you forward to controllers
+      # that don't have urls, the security will not be checked.
       def service(*a)
-        puts "Walking trough service"
+        return super if self.class.urls.empty?
         user, pass = authenticate
-        if authorize(user, pass)
-          super
+        if authorize(user, pass) != false # nil is accepted, not false
+          return super
         elsif not user
-          puts "Forwarding to Unauthenticated"
-          forward(app::Controllers::Unauthenticated)
+          forward app::Controllers::Unauthenticated, 'get'
         else
-          puts "Forwarding to Unauthorized"
-          forward(app::Controllers::Unauthorized, user)
+          forward app::Controllers::Unauthorized, 'get', user
         end
         self
       end
 
     end
 
+    # Security defines two controllers that correspond to your those two
+    # methods.
     module Controllers
       # Called when an url is not authorized. You can override this is your app.
       # Or create an `unauthorized` view. @bad_user is the user name.
       class Unauthorized
         def self.urls; [] end # do not serve urls directly.
-        def authenticate; return nil, nil end
-        def authorize(user, pass, force=false); true; end
 
         def get(bad_user)
           @bad_user = bad_user
-          render(:unauthorized) rescue "Unauthorized user : #@bad_user"
+          if has_view?(:unauthorized)
+            render(:unauthorized)
+          else "Unauthorized user : #@bad_user" end
         end
       end
 
-      # Customize by creating an "unauthenticated" view
+      # Customize by creating an "unauthenticated" view. You could
+      # implement a login page here.
       class Unauthenticated
         def self.urls; [] end # do not serve urls directly.
-        def authenticate; return nil, nil end
-        def authorize(user, pass, force=false); true; end
 
         def get
-          render(:unauthenticated) rescue 'Unauthenticated'
+          if has_view?(:unauthenticated)
+            render(:unauthenticated)
+          else 'Unauthenticated' end
         end
       end
 

data/lib/ext/sendfile.rb

@@ -3,7 +3,7 @@ require 'ext/app_util'
 require 'ext/forward'
 
 begin
-  require 'mime/types' # requires that package
+  require 'mimetype_ext' # requires that package
 rescue LoadError
   STDERR.puts '*** mime/types not available. You will have to specify mime \
 types in Equipment::Sendfile.'
@@ -23,7 +23,6 @@ module Ext
   # == Dependencies
   #
   # * Equipment
-  # * AppUtil
   # * Forward
   # * `mime-types` package. Available as a gem.
   # * `sendfile` package (optional). Available as a gem.
@@ -68,13 +67,13 @@ module Ext
 
         # Sendfile is used ?
         if $mongrel_has_sendfile
-          @headers['X-Sendfile'] = path
+          @headers['X-SENDFILE'] = path
         else
           @body = file.read
         end
 
       rescue Errno::ENOENT, Errno::EISDIR # File not found
-        forward(app::Controllers::NotFound, @env.PATH_INFO)
+        forward app::Controllers::NotFound, 'get', @env.PATH_INFO
       ensure
         file.close if file
       end

data/lib/ext/settings.rb

@@ -0,0 +1,243 @@
+require 'equipment'
+require 'forwardable'
+require 'yaml'
+
+module Ext
+  # Settings allow you to have configurable settings in your app. Define
+  # your own configuration settings in the app root and then call
+  # #load_settings.
+  #
+  # NOTE : This Equipment is usable without Camping.
+  # 
+  # == Example
+  #
+  #  require 'camping'
+  #  require 'ext/settings'
+  #
+  #  Camping.goes :YourApp
+  #
+  #  module YourApp
+  #    equip Ext::Settings
+  #
+  #    setting :database, {:store=>'mysql', :hostname=>'localhost'}
+  #
+  #    load_settings('your_config.yaml')
+  #  end
+  #
+  #  YourApp.database #=> {:store=>'mysql', :hostname=>'localhost'}
+  # 
+  # == Dependencies
+  #
+  # * Equipment
+  # * YAML
+  # * Forwardable
+  # 
+  # == TODO 
+  #
+  # Implement type-casting ?
+  #
+  module Settings
+    extend Equipment
+
+    # Define C if not defined.
+    def self.equip(app)
+      app.module_eval "C=self" unless app.const_defined? :C
+      super
+    end
+
+    # Class methods for your app.
+    module CClassMethods
+      attr_accessor :settings_path
+      
+      # This is the method that let you create settings. If you pass a
+      # block, it will be called when the key is assigned and the return
+      # value will be used.
+      #
+      # == Example
+      #
+      #   setting :user, 'HEY', do |new,old|
+      #     new.downcase
+      #   end
+      #
+      #   self.user #=> "hey"
+      def setting(key, value, &on_change)
+        settings.set(key, value, &on_change)
+
+        # reader
+        metaclass.send :define_method, key do
+          settings[key].value
+        end
+
+        # writer
+        metaclass.send :define_method, "#{key}=" do |val|
+          settings[key].value = val
+        end     
+      end
+
+      # The group of settings. You can call settings.to_yaml to get the
+      # output.
+      def settings; @settings ||= SettingGroup.new(self) end
+
+      # Loads the specified file. If none is given, it will look in /etc
+      # and your home folder for a file called you_app.yaml
+      def load_settings(yaml_file=settings_path)
+        if yaml_file
+          settings.load(yaml_file)
+          puts "INFO: '#{yaml_file}' loaded." if $DBG
+        else
+          name = self.name.methodize
+ 
+          # YAML config
+          configs = []
+          configs << File.join(ENV['HOME'], ".#{name}.yaml") if ENV['HOME']
+          configs << File.join(ENV['APPDATA'], "#{name}.yaml") if ENV['APPDATA']
+          configs << "/etc/#{name}.yaml"
+          configs.each do |conf|
+            conf = File.expand_path(conf)
+            if File.exists?(conf)
+              settings_path = conf
+              load_settings(conf)
+              break
+            end
+          end
+
+          # Ruby config
+          configs = []
+          configs << File.join(ENV['HOME'], ".#{name}.rb") if ENV['HOME']
+          configs << File.join(ENV['APPDATA'], "#{name}.yaml") if ENV['APPDATA']
+          configs << "/etc/#{name}.rb"
+          configs.each do |conf|
+            conf = File.expand_path(conf)
+            if File.exists?(conf)
+              load conf
+              break
+            end
+          end
+        end
+      end
+
+      # Export the settings once they're changed. You'll have to call
+      # this by hand.
+      # 
+      # Oh and, the keys will be stored in the following format : 
+      # 'YourApp.keyname'
+      def save_settings(yaml_file=settings_path)
+        raise ArgumentError, "No settings path given" unless yaml_file
+        settings.save(yaml_file)
+      end
+    end
+
+    # This is the class that represent one setting. You should not use
+    # that directly but access it trough the YourApp.settings method.
+    #
+    # default_value is the value that you specified when defining the
+    # setting.
+    class Setting
+      # klass is not used here. It's for YAML.
+      attr_reader :klass, :key, :value, :default_value
+      def initialize(klass, key, default_value, &on_change)
+        @klass, @key = klass, key
+        @on_change = on_change
+        @default_value = self.value = default_value
+      end
+
+      # Calls the on_change transformer if available.
+      def value=(new_val)
+        if @on_change
+          @value = @on_change.call(new_val)
+        else
+          @value = new_val
+        end
+      end
+
+      def on_change(&block)
+        raise ArgumentError, "please give a block" unless block_given?
+        @on_change = block
+      end
+    end
+
+    # This is the class that represent YourApp.settings. Do not use it
+    # directly. Kind of HashWithIndifferentAccess.
+    class SettingGroup
+      extend Forwardable
+
+      def_delegators :@hash, :keys
+
+      # To generate the YAML keys.
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+        @hash = {}
+      end
+
+      def get(key)
+        key = convert_key(key)
+        @hash[key]
+      end
+      alias_method :[], :get
+
+      def set(key, value, &on_change)
+        key = convert_key(key)
+        raise ArgumentError, "#{klass}.#{key} already defined" if @hash.has_key? key
+        @hash[key] = Setting.new(klass, key, value, &on_change)
+      end
+      alias_method :[]=, :set
+ 
+      def method_missing(m)
+        raise NoMethodError unless @hash.has_key? m
+        @hash[m]
+      end
+
+      # Loads your configuration file. Used by load_settings.
+      def load(file)
+
+        case file
+        when String
+          file = File.open(file)
+        end
+
+        vals = YAML::load(file)
+        if vals.kind_of? Hash
+          vals.select{|k,v| /^#{klass.name}\./ =~ k}.each do |k,v|
+            key = k.sub /^#{klass.name}\./,''
+            if @hash.has_key? key
+              @hash[key].value = v
+            else
+              puts "INFO: #{klass.name}.#{key} does not exist. #{@hash.inspect}"
+            end
+          end
+        end
+      end
+
+      # Exports your configuration file as YAML. Used by save_settings.
+      def save(file)
+
+        case file
+        when String
+          file = File.open(file, 'w')
+        end
+
+        file.write(to_yaml)
+      end
+
+      def to_hash
+        @hash.keys.sort.inject(Hash.new) do |hash,k|
+          hash["#{klass}.#{k}"] = @hash[k].value
+          hash
+        end
+      end
+
+      def to_yaml
+        to_hash.to_yaml
+      end
+
+    private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+  end
+end
+

data/lib/ext/template_view.rb

@@ -1,9 +1,10 @@
 require 'equipment'
-require 'ext/patches'
+require 'ext/view'
+
+raise "Templates are broken for now, sorry !"
 
 module Ext
-  # A microcospical extension to decouple views from camping. Especially
-  # the ones based on templates.
+  # A microcospical extension to decouple template views from camping.
   #
   # Adds a V class to your app on which all instance variables
   # will be sent before rendering the view.
@@ -11,39 +12,26 @@ module Ext
   # == Dependencies
   #
   # * Equipment
-  # * Patches
+  # * View
   #
   # == TODO
   #
   # * Add support for layouts
   module TemplateView
     extend Equipment
-    depends_on Patches
-
-    def self.equip(app)
-      super
-      app.module_eval <<-SOME_VIEW
-        # Some kind of view data proxy for template-based renderers
-        class V
-          include Helpers
-          include Controllers
-          def bind(m,*a,&b); binding; end
-          def R(klass, *args); self / super; end
-        end
-      SOME_VIEW
-    end
+    depends_on View
 
     module Base
       # Takes template_root from ViewsClassMethods#template_root.
       #
       # You can change that by setting @template_root in your controller.
-      def template_root; @template_root || app::Views.template_root || '' end
+      def template_root; @template_root || app.template_root || '' end
 
       # Same as #template_root
-      def use_cache; @use_cache || app::Views.use_cache; end
+      def use_cache; @use_cache || app.use_cache; end
     end
 
-    module ViewsClassMethods
+    module CClassMethods
       # Sets the template_root. Usage is up to the template.
       attr_accessor :template_root
 
@@ -54,19 +42,3 @@ module Ext
 
 end
 
-class Object
-
-  # Sets all instance variables of an object to another
-  #
-  # if force is set to true, existing instance variables will be overwritten
-  def instance_variables_send(obj, force=false)
-    instance_variables.each do |v|
-      if force or not obj.instance_variables.include? v
-        obj.instance_variable_set(v, instance_variable_get(v))
-      end
-    end
-    obj
-  end
-  alias :ivs_send :instance_variables_send
-end
-