glue 0.41.0 → 1.0.0

data/lib/glue/mailer.rb

@@ -1,55 +0,0 @@
-require 'glue/mail'
-require 'glue/mailer/incoming'
-require 'glue/mailer/outgoing'  
-require 'glue/configuration'
-
-require 'socket'
-
-module Glue
-
-# Handles incoming and outgoing emails. Can be called from
-# a Controller or a standalone script (target of the MTA).
-
-class Mailer < Mail
-  include IncomingMailer
-  include OutgoingMailer
-  
-  # The outgoing mail server configuration.
-
-  setting :server, :default => {
-    :address => 'localhost',
-    :port => 25,
-    :domain => Socket.gethostname,
-    :username => nil,
-    :password => nil,
-    :authentication => nil
-  }, :doc => 'The outgoing server configuration'
-  
-  # The delivery method. The following options are
-  # supported:
-  #
-  # * :smtp
-  # * :sendmail
-  # * :test
-
-  setting :delivery_method, :default => :smtp, :doc => 'The delivery method'
-    
-  # Disable deliveries, useful for testing.
-
-  setting :disable_deliveries, :default => false, :doc => 'Dissable deliveries?'
-
-  # The default template root.
-  
-  setting :template_root, :default => 'template/mail', :doc => 'The default template root'
-
-  # The default from address
-  
-  setting :from, :default => 'bot@nitroproject.org', :doc => 'The default from address'
-  
-  # An array to store the delivered mails, useful
-  # for testing.
-
-  cattr_accessor :deliveries; @@deliveries = []  
-end
-
-end

data/lib/glue/mailer/incoming.rb

@@ -1,41 +0,0 @@
-module Glue
-
-# Add support for incoming mail handling.
-#
-# You need to setup your MTA to support incoming email
-# handling. Here is an example for Postfix. Edit these files:
-#
-# /etc/postfix/master.cf:
-# mailman  unix  -       n       n       -       -       pipe
-#    flags= user=nobody argv=/path/to/ruby /path/to/app/script/runner.rb Mailer.receive(STDIN)
-#
-# /etc/postfix/main.cf:
-# transport_maps = hash:/etc/postfix/transport
-# virtual_mailbox_domains = lists.yourdomain.com
-#
-# /etc/postfix/transport:
-# lists.yourdomain.com    mailman:
-#
-# Then run:
-#
-# sudo postmap transport
-# sudo postfix stop
-# sudo postfix start
-
-module IncomingMailer
-  on_included %{ base.extend ClassMethods }  
-  
-  # You can overide this class for specialized handling.
-  
-  def receive(mail)
-  end
-  
-  module ClassMethods
-    def receive(encoded)
-      mail = Glue::Mail.new_from_encoded(encoded)
-      self.new.receive(mail)
-    end
-  end
-end
-
-end

data/lib/glue/mailer/outgoing.rb

@@ -1,119 +0,0 @@
-module Glue
-
-# Add support for outgoing mail handling.
-
-module OutgoingMailer
-  # The root directory where the templates reside.
-
-  attr_accessor :template_root
-  
-  on_included %{ base.extend ClassMethods }  
-  
-  def initialize(from = nil, to = nil, subject = nil, body = Nitro::FileTemplate.new)
-    super
-    @charset = Mailer.default_charset.dup
-    @encode_subject = Mailer.encode_subject
-    @template_root = Mailer.template_root
-  end
-  
-  module ClassMethods
-    def method_missing(method_symbol, *params) #:nodoc:
-      case method_symbol.id2name
-        when /^create_([_a-z]*)/
-          create_from_method($1, *params)
-        when /^deliver_([_a-z]*)/
-          begin
-            deliver(send("create_" + $1, *params))
-          rescue Object => e
-            raise e # FIXME
-          end
-      end        
-    end
-
-    def mail(from, to, subject, body, timestamp = nil, headers = {}, encode = Mail.encode_subject, charset = Mail.default_charset) #:nodoc:
-      deliver(create(from, to, subject, body, timestamp, headers, charset))
-    end
-
-    def create(from, to, subject, body, timestamp = nil, headers = {}, encode = Mail.encode_subject, charset = Mail.default_charset) #:nodoc:
-      m = Mail.new
-      m.to, m.subject, m.body, m.from = to, ( encode ? quoted_printable(subject, charset) : subject ), body, from
-      # m.date = timestamp.respond_to?("to_time") ? timestamp.to_time : (timestamp || Time.now)    
-      # m.set_content_type "text", "plain", { "charset" => charset }
-      headers.each do |k, v|
-        m[k] = v
-      end
-      return m
-    end
-
-    def deliver(mail) #:nodoc:
-      # gmosx, FIXME: for some STUPID reason, delivery_method
-      # returns nil, investigate.
-      Mailer.delivery_method = :smtp
-      unless Mailer.disable_deliveries
-        send("perform_delivery_#{Mailer.delivery_method}", mail) 
-      end
-    end
-                                  
-    def quoted_printable(text, charset) #:nodoc:
-      text = text.gsub( /[^a-z ]/i ) { "=%02x" % $&[0] }.gsub( / /, "_" )
-      "=?#{charset}?Q?#{text}?="
-    end
-                              
-    private
-
-    def create_from_method(method_name, *params)
-      mailer = new
-
-      mailer.send(method_name, *params)
-
-      unless mailer.body.is_a? String
-        mailer.body = render_body(method_name, mailer)
-      end
-
-      mail = create(
-        mailer.from, mailer.to, mailer.subject, 
-        mailer.body, mailer.sent_on, 
-        mailer.headers, mailer.charset
-      )
-
-      mail.cc = mailer.cc if mailer.cc
-      mail.bcc = mailer.bcc if mailer.bcc
-
-      return mail
-    end
-
-    # Render the body by expanding the template
-    
-    def render_body(method_name, mailer)
-      mailer.body.template_filename = "#{mailer.template_root}/#{method_name.to_s}.xhtml"
-      return mailer.body.process
-    end
-
-    # Deliver emails using SMTP.
-    
-    def perform_delivery_smtp(mail) # :nodoc:
-      c = Mailer.server
-      Net::SMTP.start(c[:address], c[:port], c[:domain], c[:username], c[:password], c[:authentication]) do |smtp|
-        smtp.send_message(mail.encoded, mail.from, *[mail.to, mail.cc, mail.bcc].compact)
-      end
-    end
-
-    # Deliver emails using sendmail.
-    
-    def perform_delivery_sendmail(mail) # :nodoc:
-      IO.popen('/usr/sbin/sendmail -i -t', 'w+') do |sm|
-        sm.print(mail.encoded)
-        sm.flush
-      end                                          
-    end
-    
-    # Used for testing, does not actually send the 
-    # mail.
-    
-    def perform_delivery_test(mail) # :nodoc:
-      deliveries << mail
-    end
-  end  
-end
-
-end

data/lib/glue/settings.rb

@@ -1,3 +0,0 @@
-# Just an alias for glue/configuration.
-
-require 'glue/configuration'

data/lib/glue/uri.rb

@@ -1,190 +0,0 @@
-require 'uri'
-require 'cgi'
-
-require 'facet/string/blank'
-
-module Glue
-
-# URI utilities collection.
-#
-# === Design
-#
-# Implement as a module to avoid class polution. You can still
-# use Ruby's advanced features to include the module in your
-# class. Passing the object to act upon allows to check for nil,
-# which isn't possible if you use self.
-#
-# The uris passed as parameters are typically strings.
-#--
-# gmosx, TODO: deprecate this.
-#++
-
-module UriUtils
-
-  # Decode the uri components.
-  
-  def self.decode(uri)    
-    # gmosx: hmm is this needed?
-    # guard against invalid filenames for example pictures with 
-    # spaces uploaded by users
-    escaped_uri = uri.gsub(/ /, "+")
-
-    if md = URI::REGEXP::REL_URI.match(escaped_uri)
-
-      path = "#{md[5]}#{md[6]}"
-      type = File.extname(path)
-      query_string = md[7]
-
-#      real_path = "#{$root_dir}/#{path}"
-
-      parameters = Glue::UriUtils.query_string_to_hash(query_string)
-      path.gsub!(/\+/, " ")
-
-      return [path, type, parameters, query_string]
-
-    end # match
-
-    # this is usefull for uncovering bugs!
-    raise ArgumentError.new("the parameter '#{uri}' is not a valid uri")
-  end
-
-  # Extend the basic query string parser provided by the cgi module.
-  # converts single valued params (the most common case) to
-  # objects instead of arrays
-  #
-  # Input:
-  # the query string
-  #
-  # Output:
-  # hash of parameters, contains arrays for multivalued parameters
-  # (multiselect, checkboxes , etc)
-  # If no query string is provided (nil or "") returns an empty hash.
-  
-  def self.query_string_to_hash(query_string)
-    return {} unless query_string
-
-    query_parameters = CGI::parse(query_string)
-
-    query_parameters.each { |key, val|
-      # replace the array with an object
-      query_parameters[key] = val[0] if 1 == val.length
-    }
-
-    # set default value to nil! cgi sets this to []
-    query_parameters.default = nil
-
-    return query_parameters
-  end
-
-  # Given a hash with parameter/value pairs construct a
-  # standard query string. This method only encodes simple
-  # types (Numeric, String) to avoid query string polution
-  # with marshal, etc.
-  #
-  # gmosx, FIXME: only numeric and strings are passed to
-  # the latest code, so update old code and optimize this!
-  #
-  # Input:
-  # the parameter hash
-  #
-  # Output:
-  # the query string
-
-  def self.hash_to_query_string(parameters)
-    return nil unless parameters
-    pairs = []
-    parameters.each { |param, value|
-      # only encode simple classes !
-
-      if value.is_a?(Numeric) or value.is_a?(String)
-        pairs << "#{param}=#{CGI.escape(value.to_s)}"
-      end
-    }
-    return pairs.join(";")
-  end
-
-  # This method returns the query string of a uri
-  #
-  # Input:
-  # the uri
-  #
-  # Output:
-  # the query string.
-  # returns nil if no query string
-
-  def self.get_query_string(uri)
-    return nil unless uri
-    # gmosx: INVESTIGATE ruby's URI seems to differently handle
-    # abs and rel uris.
-    if md = URI::REGEXP::ABS_URI.match(uri)
-      return md[8]
-    elsif md = URI::REGEXP::REL_URI.match(uri)
-      return md[7]
-    end
-    return nil
-  end
-
-  # Removes the query string from a uri
-  #
-  # Input:
-  # the uri
-  #
-  # Output:
-  # the chomped uri.
-
-  def self.chomp_query_string(uri)
-    return nil unless uri
-    query_string = self.get_query_string(uri)
-    return uri.dup.chomp("?#{query_string}")
-  end
-
-  # Get a uri and a hash of parameters. Inject the hash values
-  # as parameters in the query sting path. Returns the full
-  # uri.
-  #
-  # Input:
-  # the uri to filter (String)
-  # hash of parameters to update
-  #
-  # Output:
-  # the full updated query string
-  #
-  # === TODO:
-  # optimize this a litle bit.
-  
-  def self.update_query_string(uri, parameters)
-    query_string = self.get_query_string(uri)
-    rest = uri.dup.gsub(/\?#{query_string}/, "")
-
-    hash = self.query_string_to_hash(query_string)
-    hash.update(parameters)
-    query_string = self.hash_to_query_string(hash)
-
-    unless query_string.blank?
-      return "#{rest}?#{query_string}"
-    else
-      return rest
-    end
-  end
-  
-  # TODO: find a better name.
-  # Gets the request uri, injects extra parameters in the query string
-  # and returns a new uri. The request object is not modified.
-  # There is always a qs string so an extra test is skipped.
-  
-  def self.update_request_uri(request, parameters)
-    hash = request.parameters.dup()
-    hash.update(parameters)
-
-    # use this in hash_to_querystring.    
-    query_string = hash.collect { |k, v|
-      "#{k}=#{v}"
-    }.join(";")
-    
-    return "#{request.translated_uri}?#{query_string}"
-  end
-
-end
-
-end
-

data/lib/glue/validation.rb

@@ -1,447 +0,0 @@
-require 'facets/core/class/cattr'
-require 'facets/core/module/on_included'
-require 'facets/more/inheritor'
-
-require 'glue/configuration'
-
-module Glue 
-
-# Implements a meta-language for validating managed
-# objects. Typically used in Validator objects but can be
-# included in managed objects too.
-#
-# Additional og-related validation macros can be found
-# in lib/og/validation.
-#
-# The following validation macros are available:
-#
-#  * validate_value
-#  * validate_confirmation
-#  * validate_format
-#  * validate_length
-#  * validate_inclusion
-#
-# Og/Database specific validation methods are added in the
-# file og/validation.rb
-#
-# === Example
-#
-# class User
-#    attr_accessor :name, String 
-#    attr_accessor :level, Fixnum
-#
-#    validate_length :name, :range => 2..6 
-#    validate_unique :name, :msg => :name_allready_exists 
-#    validate_format :name, :format => /[a-z]*/, :msg => 'invalid format', :on => :create 
-#  end
-#
-#  class CustomUserValidator 
-#    include Validation
-#    validate_length :name, :range => 2..6, :msg_short => :name_too_short, :msg_long => :name_too_long 
-#  end
-#
-#  user = @request.fill(User.new)
-#  user.level = 15
-#
-#  unless user.valid?
-#    user.save
-#  else
-#    p user.errors[:name]
-#  end
-#
-#  unless user.save
-#    p user.errors.on(:name)
-#  end
-#
-#  unless errors = CustomUserValidator.errors(user)
-#    user.save
-#  else
-#    p errors[:name]
-#  end
-#--
-# TODO: all validation methods should imply validate_value.
-#++
-
-module Validation
-
-  # The postfix attached to confirmation attributes.
-    
-  setting :confirmation_postfix, :default => '_confirmation', :doc => 'The postfix attached to confirmation attributes.'
-
-  # Encapsulates a list of validation errors.
-  
-  class Errors
-    attr_accessor :errors 
-
-    setting :no_value, :default => 'No value provided'
-    setting :no_confirmation, :default => 'Invalid confirmation'
-    setting :invalid_format, :default => 'Invalid format'
-    setting :too_short, :default => 'Too short, must be more than %d characters long'
-    setting :too_long, :default => 'Too long, must be less than %d characters long'
-    setting :invalid_length, :default => 'Must be %d characters long'
-    setting :no_inclusion, :default => 'The value is invalid'
-    setting :no_numeric, :default => 'The value must be numeric'
-    setting :not_unique, :default => 'The value is already used'
-    
-    def initialize
-      @errors = {}
-    end
-
-    def add(attr, message)
-      (@errors[attr] ||= []) << message
-    end
-
-    def on(attr)
-      @errors[attr]
-    end
-    alias_method :[], :on
-  
-    # Yields each attribute and associated message.
-    
-    def each
-      @errors.each_key do |attr| 
-        @errors[attr].each { |msg| yield attr, msg }
-      end
-    end
-
-    def size
-      @errors.size
-    end
-    alias_method :count, :size
-
-    def empty?
-      @errors.empty?
-    end
-
-    def clear
-      @errors.clear
-    end
-
-    def to_a
-      @errors.inject([]) { |a, kv| a << kv }
-    end
-    
-    def join(glue)
-      @errors.to_a.join(glue)
-    end
-  end
-
-  # A Key is used to uniquely identify a validation rule.
-  
-  class Key
-    attr_reader :validation
-    attr_reader :field
-
-    def initialize(validation, field)
-      @validation, @field = validation.to_s, field.to_s
-    end
-
-    def hash
-      "#{@validation}-#{@field}".hash
-    end
-
-    def ==(other)
-      self.validation == other.validation and self.field == other.field
-    end
-  end
-    
-  # If the validate method returns true, this
-  # attributes holds the errors found.
-  
-  attr_accessor :errors
-
-  # Call the #validate method for this object.
-  # If validation errors are found, sets the
-  # @errors attribute to the Errors object and 
-  # returns true.
-  
-  def valid?
-    validate
-    @errors.empty?
-  end
-    
-  # Evaluate the class and see if it is valid.
-  # Can accept any parameter for 'on' event,
-  # and defaults to :save
-
-  def validate(on = :save)
-    @errors = Errors.new
-
-    return if self.class.validations.length == 0
-
-    for event, block in self.class.validations
-      block.call(self) if event == on.to_sym
-    end
-  end
-
-  on_included %{
-    base.module_eval do
-      inheritor(:validations, [], :+) unless @validations
-      # THINK: investigate carefuly!
-      def self.included(cbase)
-        super
-        cbase.send :include, Glue::Validation
-      end
-    end
-    base.extend(ClassMethods)
-  }
-
-  # Implements the Validation meta-language.
-  
-  module ClassMethods 
-    # Validates that the attributes have a values, ie they are
-    # neither nil or empty.
-    #
-    # === Example
-    #
-    # validate_value :param, :msg => 'No confirmation'
-    
-    def validate_value(*params)
-      c = parse_config(params, :msg => Glue::Validation::Errors.no_value, :on => :save)
-
-      params.each do |field|
-        define_validation(:value, field, c[:on]) do |obj|
-          value = obj.send(field)
-          obj.errors.add(field, c[:msg]) if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-        end
-      end
-    end
-
-    # Validates the confirmation of +String+ attributes.
-    #
-    # === Example
-    #
-    # validate_confirmation :password, :msg => 'No confirmation'
-    
-    def validate_confirmation(*params)
-      c = parse_config(params,
-        :msg => Glue::Validation::Errors.no_confirmation, 
-        :postfix => Glue::Validation.confirmation_postfix,
-        :on => :save 
-      )
-
-      params.each do |field|
-        confirm_name = field.to_s + c[:postfix]
-        attr_accessor confirm_name.to_sym
-
-        define_validation(:confirmation, field, c[:on]) do |obj|
-          value = obj.send(field)
-          obj.errors.add(field, c[:msg]) if value.nil? or obj.send(confirm_name) != value
-        end
-      end
-    end
-
-    # Validates the format of +String+ attributes.
-    # WARNING: regexp options are ignored.
-    #
-    # === Example
-    # 
-    # validate_format :name, :format => /$A*/, :msg => 'My error', :on => :create
-    #
-    #--
-    # FIXME: how to get the Regexp options?
-    #++
-
-    def validate_format(*params)
-      c = parse_config(params,
-        :format => nil, 
-        :msg_no_value => Glue::Validation::Errors.no_value,
-        :msg => Glue::Validation::Errors.invalid_format, 
-        :on => :save 
-      )
-
-      unless c[:format].is_a?(Regexp)
-        raise ArgumentError, "A regular expression must be supplied as the :format option for validate_format."
-      end
-
-      params.each do |field|
-        define_validation(:format, field, c[:on]) do |obj|
-          value = obj.send(field)
-          obj.errors.add(field, c[:msg]) if value.nil? or not value.to_s.match(c[:format].source)
-        end
-      end                                                
-    end
-    
-    # Validates the length of +String+ attributes.
-    #
-    # === Example
-    # 
-    # validate_length :name, :max => 30, :msg => 'Too long'
-    # validate_length :name, :min => 2, :msg => 'Too sort'
-    # validate_length :name, :range => 2..30
-    # validate_length :name, :length => 15, :msg => 'Name should be %d chars long'
-    
-    LENGTHS = [:min, :max, :range, :length].freeze
-    
-    def validate_length(*params)
-      c = parse_config(params,
-#       :lengths => {:min => nil, :max => nil, :range => nil, :length => nil},
-        :min => nil, :max => nil, :range => nil, :length => nil,
-        :msg => nil, 
-        :msg_no_value => Glue::Validation::Errors.no_value,
-        :msg_short => Glue::Validation::Errors.too_short,
-        :msg_long => Glue::Validation::Errors.too_long,
-        :msg_invalid => Glue::Validation::Errors.invalid_length,
-        :on => :save 
-      )
-
-      length_params = c.reject {|k,v| !LENGTHS.include?(k) || v.nil? }
-      valid_count = length_params.reject{|k,v| v.nil?}.length
-      
-      if valid_count == 0
-        raise ArgumentError, 'One of :min, :max, :range, or :length must be provided!'
-      elsif valid_count > 1
-        raise ArgumentError, 'You can only use one of :min, :max, :range, or :length options!'
-      end
-
-      operation, required = length_params.keys[0], length_params.values[0]
-     
-      params.each do |field|
-        define_validation(:length, field, c[:on]) do |obj|
-          msg = c[:msg]
-          value = obj.send(field)
-          if value.nil?
-            obj.errors.add(field, c[:msg_no_value])
-          else 
-            case operation
-            when :min
-              msg ||= c[:msg_short]
-              obj.errors.add(field, msg % required) if value.length < required
-            when :max
-              msg ||= c[:msg_long]
-              obj.errors.add(field, msg % required) if value.length > required
-            when :range
-              min, max = required.first, required.last
-              if value.length < min
-                msg ||= c[:msg_short]
-                obj.errors.add(field, msg % min)
-              end
-              if value.length > max
-                msg ||= c[:msg_long]
-                obj.errors.add(field, msg % min)
-              end
-            when :length
-              msg ||= c[:msg_invalid]
-              obj.errors.add(field, msg % required) if value.length != required
-            end
-          end
-        end
-      end
-    end
-    
-    # Validates that the attributes are included in 
-    # an enumeration.
-    #
-    # === Example
-    #
-    # validate_inclusion :sex, :in => %w{ Male Female }, :msg => 'huh??'
-    # validate_inclusion :age, :in => 5..99 
-
-    def validate_inclusion(*params)
-      c = parse_config(params,
-        :in => nil, 
-        :msg => Glue::Validation::Errors.no_inclusion, 
-        :allow_nil => false,
-        :on => :save 
-      )
-
-      unless c[:in].respond_to?('include?')
-        raise(ArgumentError, 'An object that responds to #include? must be supplied as the :in option')
-      end
-
-      params.each do |field|
-        define_validation(:inclusion, field, c[:on]) do |obj|
-          value = obj.send(field)
-          unless (c[:allow_nil] && value.nil?) or c[:in].include?(value)
-            obj.errors.add(field, c[:msg])
-          end
-        end
-      end                                                
-    end
-
-    # Validates that the attributes have numeric values.
-    #
-    # [+:integer+]
-    #    Only accept integers
-    #
-    #  [+:msg]
-    #    Custom message
-    #
-    #  [+:on:]
-    #    When to validate
-    #    
-    # === Example
-    #
-    # validate_numeric :age, :msg => 'Must be an integer'
-
-    def validate_numeric(*params)
-      c = parse_config(params, 
-        :integer => false,
-        :msg => Glue::Validation::Errors.no_numeric, 
-        :on => :save 
-      )
-
-      params.each do |field|
-        define_validation(:numeric, field, c[:on]) do |obj|
-          value = obj.send(field).to_s
-          if c[:integer] 
-            unless value =~ /^[\+\-]*\d+$/
-              obj.errors.add(field, c[:msg])
-            end
-          else
-            begin
-              Float(value)
-            rescue ArgumentError, TypeError
-              obj.errors.add(field, c[:msg])
-            end
-          end
-        end
-      end
-    end
-    alias_method :validate_numericality, :validate_numeric
-
-  protected
-
-    # Parse the configuration for a validation by comparing
-    # the default options with the user-specified options,
-    # and returning the results.
-
-    def parse_config(params, defaults = {})
-      defaults.update(params.pop) if params.last.is_a?(Hash)
-      defaults
-    end
-
-    # Define a validation for this class on the specified event.
-    # Specify the on event for when this validation should be
-    # checked.
-    #
-    # An extra check is performed to avoid multiple validations.
-    #
-    # This example creates a validation for the 'save' event,
-    # and will add an error to the record if the 'name' property
-    # of the validating object is nil.
-    #
-    # === Example
-    #
-    # field = :name
-    #
-    # define_validation(:value, field, :save) do |object|
-    #   object.errors.add(field, "You must set a value for #{field}") if object.send(field).nil?
-    # end
-    
-    def define_validation(val, field, on = :save, &block)
-      vk = Validation::Key.new(val, field)
-      unless validations.find { |v| v[2] == vk }
-        validations! << [on, block, vk]
-      end
-    end
-    
-  end
-
-end
-
-end
-
-class Module # :nodoc: all
-  include Glue::Validation::ClassMethods
-end