waw 0.2.2

data/lib/waw/routing/routing_rule.rb

@@ -0,0 +1,16 @@
+module Waw
+  module Routing
+    class RoutingRule
+      
+      # Applies this routing rule on a Waw::WSpec::Browser instance.
+      # By default, does nothing at all.
+      def apply_on_browser(result, browser)
+      end
+      
+      def generate_js_code(result, align=0)
+        raise "RoutingRule #{self.class} does not support javascript code generation" 
+      end
+      
+    end # RoutingRule
+  end # module Routing
+end # module Waw

data/lib/waw/scope_utils.rb

@@ -0,0 +1,69 @@
+module Waw
+  module ScopeUtils
+    
+    # Find the kernel context whose call must be delegated to.
+    def find_kernel_context
+      return self.waw_kernel if self.respond_to?(:waw_kernel)
+      return Waw.kernel if Waw.kernel
+      Waw.logger.warn("Using a empty kernel because no one has been found")
+      Waw::Kern::App.new("Empty autoloaded kernel").autoload(File.join(File.dirname(__FILE__), 'kern', 'empty'))
+    end
+    
+    ################################################################# About waw application
+    
+    # Returns the root folder
+    def root_folder
+      find_kernel_context.root_folder
+    end
+    
+    # Returns waw resources
+    def config
+      find_kernel_context.config
+    end
+    
+    # Logger to use
+    def logger
+      find_kernel_context.logger
+    end
+    
+    # Returns waw resources
+    def resources
+      find_kernel_context.resources
+    end
+    
+    ################################################################# About current request
+    
+    # Returns the current Rack env instance
+    def rack_env
+      find_kernel_context.rack_env
+    end
+    
+    # Returns the current Rack request instance
+    def request
+      find_kernel_context.request
+    end
+    
+    # Returns the current Rack request instance
+    def response
+      find_kernel_context.response
+    end
+    
+    # Request parameters
+    def params
+      find_kernel_context.params
+    end
+    
+    ################################################################# About current session
+    
+    # Returns the current Rack session
+    def real_session
+      find_kernel_context.real_session
+    end
+    
+    # Returns the waw session decorator
+    def session
+      find_kernel_context.session
+    end
+    
+  end # module ScopeUtils
+end # module Waw

data/lib/waw/session.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+module Waw
+  class Session
+    extend FullState::OnInstance
+    
+    # Creates a session instance
+    def initialize(rack_session)
+      @rack_session = rack_session
+    end
+    
+    # Returns Rack's underlying session Hash
+    def rack_session
+      @rack_session
+    end
+    
+    # Clears the session
+    def clear
+      rack_session.clear
+    end
+    
+    # Checks if a given key exists in the session
+    def has_key?(name)
+      rack_session.has_key?(name)
+    end
+    
+    # Returns the value of a given variable
+    def [](name)
+      rack_session[name]
+    end
+    alias :get :[]
+    
+    # Returns the value of a given variable
+    def []=(name, value)
+      rack_session[name] = value
+    end
+    alias :set   :[]=
+    
+    # Resets a given variable whose name is provided
+    def reset(name)
+      rack_session.delete(name)
+    end
+    alias :delete :reset
+    alias :unset :reset
+    
+    # Inspects the session
+    def inspect
+      rack_session.inspect
+    end
+    
+  end
+end

data/lib/waw/testing.rb

@@ -0,0 +1 @@
+require 'waw/wspec'

data/lib/waw/tools/mail.rb

@@ -0,0 +1,4 @@
+require 'waw/tools/mail/mail_agent'
+require 'waw/tools/mail/mail'
+require 'waw/tools/mail/template'
+require 'waw/tools/mail/mailbox'

data/lib/waw/tools/mail/mail.rb

@@ -0,0 +1,119 @@
+module Waw
+  module Tools
+    class MailAgent
+      # A helper to respect the mail protocol
+      class Mail
+        
+        # Source address
+        attr_accessor :from
+        
+        # Target addresses 
+        attr_accessor :to
+        
+        # Target carbon copy addresses 
+        attr_accessor :cc
+        
+        # Target b carbon copy addresses 
+        attr_accessor :bcc
+        
+        # Mail subject
+        attr_accessor :subject
+        
+        # Mail date
+        attr_accessor :date
+        
+        # MIME version
+        attr_accessor :mime_version
+        
+        # Content-type
+        attr_accessor :content_type
+        
+        # Content-type
+        attr_accessor :charset
+        
+        # Mail body
+        attr_accessor :body
+        
+        # Creates an empty mail
+        def initialize(subject = nil, body = nil, from = nil, *to)
+          @from = from
+          @to = to.empty? ? [] : to
+          @cc, @bcc = [], []
+          @subject = subject
+          @date = Time.now
+          @mime_version = "1.0"
+          @content_type = "text/plain"
+          @charset = "UTF-8"
+          @body = body
+        end
+        
+        # Class methods
+        class << self
+          
+          # Decodes a mail from a given string
+          def decode(str)
+            mail = Mail.new
+            lines = str.split("\n")
+            until false 
+              case line = lines.shift.strip
+                when /^From: (.*)$/
+                  mail.from = $1
+                when /^To: (.*)$/
+                  mail.to = $1.split(',').collect{|s| s.strip}
+                when /^Cc: (.*)$/
+                  mail.cc = $1.split(',').collect{|s| s.strip}
+                when /^Bcc: (.*)$/
+                  mail.bcc = $1.split(',').collect{|s| s.strip}
+                when /^Subject: (.*)$/
+                  mail.subject = $1
+                when /^Date: (.*)$/
+                  mail.date = Time.rfc2822($1)
+                when /^MIME-Version: (.*)$/
+                  mail.mime_version = $1
+                when /^Content-type: (.*); charset=(.*)$/
+                  mail.content_type = $1
+                  mail.charset = $2
+                when /^$/
+                  break
+              end
+            end
+            mail.body = lines.join("\n")
+            mail
+          end
+        
+          alias :parse :decode
+        end
+
+        # Returns a valid mail string instantiation
+        def to_s
+          str = <<-MAIL_END
+            From: #{from}
+            To: #{to.nil? ? '' : to.join(", ")}
+            Cc: #{cc.nil? ? '' : cc.join(", ")}
+            Bcc: #{bcc.nil? ? '' : bcc.join(", ")}
+            Subject: #{subject}
+            Date: #{date.rfc2822}
+            MIME-Version: #{mime_version}
+            Content-type: #{content_type}; charset=#{charset}
+
+            #{body}
+          MAIL_END
+          str.gsub(/^[ \t]*/, '')
+        end
+        alias :encode :to_s
+        alias :dump :to_s
+        
+        # Makes a deep copy of this mail. Changing the list of receivers
+        # in particular does not affect the original mail
+        def dup
+          mail = super
+          mail.to = to.nil? ? nil : to.dup
+          mail.cc = cc.nil? ? nil : cc.dup
+          mail.bcc = bcc.nil? ? nil : bcc.dup
+          mail
+        end
+        
+      end # class Mail
+    end # class MailAgent
+  end # module Tools
+end # module Waw 

data/lib/waw/tools/mail/mail_agent.rb

@@ -0,0 +1,123 @@
+module Waw
+  module Tools
+    # Provides a tool to send mails simply
+    class MailAgent
+      
+      # Creates a default mail agent
+      def initialize(opts = {}, force_real = false)
+        @force_real = force_real
+        if do_it_really?
+          @smtp_host = opts[:host]
+          @smtp_port = opts[:port]
+          @smtp_timeout = opts[:timeout]
+          raise ArgumentError, "Opts should include :host, :port and :timeout parameters\n#{opts.inspect} received"\
+            if @smtp_host.nil? or @smtp_port.nil? or @smtp_timeout.nil?
+        end
+        @templates = {}
+      end
+      
+      # Builds a mail instance. This method should always be used preferably
+      # to an explicit Mail.new invocation.
+      def mail(*args)
+        Mail.new(*args)
+      end
+      
+      # Builds a template instance. This method should always be used preferably
+      # to an explicit Template.new invocation.
+      def template(*args)
+        Template.new(*args)
+      end
+      
+      # Adds a mail template under a given name
+      def add_template(name, *args)
+        if args.size == 1 and Template===args[0]
+          @templates[name] = args[0]
+        else
+          @templates[name] = template(*args)
+        end
+      end
+      
+      # Converts a named template to a mail
+      def to_mail(template_name, wlang_context)
+        raise ArgumentError, "No such template #{template_name}" unless @templates.has_key?(template_name)
+        @templates[template_name].to_mail(wlang_context)
+      end
+      
+      # Send mails, really?
+      def do_it_really?
+        @force_real or (Waw.config and ['production', 'acceptation'].include?(Waw.config.deploy_mode))
+      end
+      
+      # Returns installed mailboxes
+      def mailboxes
+        @mailboxes ||= Hash.new{|h, k| h[k] = Mailbox.new(k)}
+      end
+      
+      # Returns the mailbox of a given receiver, creating
+      # a new one if it cannot be found
+      def mailbox(receiver)
+        mailboxes[receiver]
+      end
+      
+      #
+      # Sends an email. If Waw.config.deploy_mode is set to 'production'
+      # or 'acceptation', the mail is really sent. Otherwise it is pushed
+      # in the receiver mailbox.
+      #
+      # This method accepts the following invocation signatures:
+      #
+      #   # sending a real Mail instance (and only one)
+      #   agent.send_mail(mail)
+      #
+      #   # sending from a template for which receivers have been already set
+      #   agent.send_mail(:my_template, {:title => "Hello"})
+      #
+      #   # sending from a template, with explicit receivers as varargs
+      #   agent.send_mail(:my_template, {:title => "Hello"}, "receiver@example.com", ..., "receiver_N@example.com")
+      #
+      #   # sending from a template, with explicit receivers as an array
+      #   agent.send_mail(:my_template, {:title => "Hello"}, [...])
+      #
+      def send_mail(*args)
+        # Let try to match the signature
+        if args.size == 1 and Mail===args[0]
+          # first one
+          mail = args[0]
+        elsif Symbol===args[0] and Hash===args[1]
+          # the others
+          mail = to_mail(args.shift, args.shift)
+          unless args.empty?
+            if args.size == 1 and Array===args[0]
+              # third one
+              mail.to = args[0]
+            else
+              # fourth one
+              mail.to = args
+            end
+          else
+            # second one
+          end
+        else
+          raise ArgumentError, "Unable to find the send_mail sigature you want with #{args.inspect}"
+        end
+        
+        if do_it_really?
+          require 'net/smtp'
+          smtp_conn = Net::SMTP.new(@smtp_host, @smtp_port)
+          smtp_conn.open_timeout = @smtp_timeout
+          smtp_conn.start
+          smtp_conn.send_message(mail.dump, mail.from, *mail.to)
+          smtp_conn.finish
+        else
+          Waw.logger.debug mail.dump
+          sent = Mail.parse(mail.dump)
+          mail.to.each {|who| mailbox(who) << sent.dup}
+          mail.cc.each {|who| mailbox(who) << sent.dup}
+          mail.bcc.each {|who| mailbox(who) << sent.dup}
+        end
+      end
+      alias :<< :send_mail
+      
+    end # class MailAgent
+  end # module Tools
+end # module Waw

data/lib/waw/tools/mail/mailbox.rb

@@ -0,0 +1,62 @@
+module Waw
+  module Tools
+    class MailAgent
+      # Helper for testing purposes only.
+      class Mailbox
+        
+        # Creates an empty mailbox for a given adress
+        def initialize(mail_address)
+          @mail_address = mail_address
+          @mails = []
+        end
+        
+        # Returns the number of mails in this mailbox
+        def size
+          @mails.size
+        end
+        
+        # Checks if the mailbox is empty or not
+        def empty?
+          @mails.empty?
+        end
+        
+        # Pushes a mail inside the mailbox, returns an id
+        def push(mail)
+          @mails << [mail, false]
+          @mails.size-1
+        end
+        alias :<< :push
+        
+        # Returns the id-th mail in the mailbox. Returns nil
+        # if no such mail can be found
+        def [](id)
+          mail = @mails[id]
+          return nil unless mail
+          mail[0]
+        end
+      
+        # Checks if a mail is marked as read. Returns nil
+        # if no such mail can be found
+        def is_read?(id)
+          mail = @mails[id]
+          return nil unless mail
+          mail[1]
+        end
+        
+        # Marks a mail as read and returns it
+        def read(id)
+          mail = @mails[id]
+          return nil unless mail
+          mail[1] = true
+          mail[0]
+        end
+        
+        # Removes all mails
+        def clear
+          @mails.clear
+        end
+        
+      end # class Mailbox
+    end # class MailAgent
+  end # module Tools
+end # module Waw