waw 0.2.2

data/lib/waw/commands/command.rb

@@ -0,0 +1,115 @@
+require 'optparse'
+require 'fileutils'
+module Waw
+  module Commands
+    class Command
+      
+      # The verbose level
+      attr_accessor :verbose
+      
+      # Show stack traces?
+      attr_accessor :trace
+      
+      # Creates an empty command instance
+      def initialize
+        @verbose = false
+        @buffer = STDOUT
+      end
+      
+      # Parses commandline options provided as an array of Strings.
+      def options
+        @options  ||= OptionParser.new do |opt|
+          opt.program_name = File.basename $0
+          opt.version = Waw::VERSION
+          opt.release = nil
+          opt.summary_indent = ' ' * 4
+          banner = self.banner
+          opt.banner = banner.gsub(/^[ \t]+/, "")
+    
+          opt.separator nil
+          opt.separator "Options:"
+    
+          add_options(opt)
+
+          opt.on("--trace", "Display stack trace on error?") do |value|
+            @trace = true
+          end
+          
+          opt.on("--verbose", "-v", "Display extra progress as we progress") do |value|
+            @verbose = true
+          end
+          
+          # No argument, shows at tail.  This will print an options summary.
+          # Try it and see!
+          opt.on_tail("-h", "--help", "Show this message") do
+            puts options
+            exit
+          end
+
+          # Another typical switch to print the version.
+          opt.on_tail("--version", "Show version") do
+            puts opt.program_name << Waw::VERSION << " (c) University of Louvain, Bernard & Louis Lambeau"
+            exit
+          end
+    
+          opt.separator nil
+        end
+      end
+
+      # Runs the command
+      def run(requester_file, argv)
+        @requester_file = requester_file
+        check_command_policy
+        __run(requester_file, options.parse!(argv))
+      rescue OptionParser::InvalidOption => ex
+        exit ex.message
+      rescue SystemExit
+      rescue Exception => ex
+        error <<-EOF
+          A severe error occured. Please report this to the developers.
+          Try --trace if the trace does not appear
+        
+          #{ex.class}: #{ex.message}
+        EOF
+        error ex.backtrace.join("\n") if trace
+      end
+      
+      def shell_exec(what)
+        info "shell: #{what}" if verbose
+        info `#{what}`
+      end
+      
+      # Exits with a message, showing options if required
+      def exit(msg = nil, show_options=true)
+        info msg if msg
+        puts options if show_options
+        Kernel.exit(-1)
+      end
+      
+      def info(msg)
+        @buffer << msg.gsub(/^[ \t]+/, '') << "\n"
+      end
+      alias :error :info
+      
+      # Contribute to options
+      def add_options(opt)
+      end
+      
+      # Returns the command banner
+      def banner
+        raise "Command.banner should be overriden by subclasses"
+      end
+      
+      # Checks that the command may be safely executed!
+      def check_command_policy
+        raise "Command.check_command_policy should be overriden"
+      end
+      
+      # Runs the sub-class defined command
+      def __run(requester_file, arguments)
+        raise "Command._run should be overriden"
+      end
+
+    end
+  end
+end

data/lib/waw/commands/profile_command.rb

@@ -0,0 +1,66 @@
+require 'waw/wspec'
+require 'waw/commands/start_command'
+module Waw
+  module Commands
+    class ProfileCommand < Command
+      
+      def banner
+        <<-EOF
+          Usage: [waw-]profile [options]
+        EOF
+      end
+      
+      # Start command is always safe
+      def check_command_policy
+        true
+      end
+      
+      # Ignores a given location?
+      def ignore?(location, visited)
+        visited[location] or /\.(gif|zip|pdf|jpg|csv)$/ =~ location
+      end
+      
+      # Recursively visits the whole website
+      def visit(browser, location, visited = {})
+        return if ignore?(location, visited)
+        visited[location] = true
+        browser.location = location
+        unless browser.is200
+          puts "Hohoho, I've found a lost internal link #{location}"
+          return
+        else
+          puts "Visiting #{location}" if verbose
+          browser.all_internal_links.each do |link|
+            visit(browser, link[:href], visited)
+          end
+        end 
+      end
+      
+      # Runs the sub-class defined command
+      def __run(requester_file, arguments)
+        require 'waw/wspec/browser'
+        
+        # Start the server first
+        thread, waw_kernel = ::Waw::Commands::StartCommand.new.waw_start(requester_file, verbose)
+        visited, browser, location = {}, ::Waw::WSpec::Browser.new, waw_kernel.config.web_base
+        
+        # Launch the visit
+        t1 = Time.now
+        visit(browser, location, visited)
+        t2 = Time.now
+        
+        # Stop the server now
+        thread.exit
+        
+        # Show statistics
+        req_by_sec = visited.size.to_f/(t2-t1)
+        avg_by_sec = (t2-t1)/visited.size
+        
+        puts "#{visited.size} pages visited in #{t2-t1} seconds (#{req_by_sec} req./sec., #{avg_by_sec} sec./req.)"
+      rescue Interrupt => ex
+        info "waw-profile stopping now... ciao!" if verbose
+      end
+
+    end # module ProfileCommand
+  end # module Commands
+end # module Waw

data/lib/waw/commands/start_command.rb

@@ -0,0 +1,59 @@
+require 'uri'
+require 'net/http'
+module Waw
+  module Commands
+    class StartCommand < Command
+      
+      def banner
+        <<-EOF
+          Usage: [waw-]start [options]
+        EOF
+      end
+      
+      # Start command is always safe
+      def check_command_policy
+        true
+      end
+      
+      # Executes the waw-start command and returns the running thread
+      def waw_start(requester_file, verbose = true)
+        waw_kernel = Waw.autoload(requester_file)
+        t = Thread.new(waw_kernel) do |app|
+          begin
+            server = Rack::Handler::Mongrel
+          rescue LoadError => e
+            server = Rack::Handler::WEBrick
+          end
+          options = {:Port => app.config.web_port, :Host => "0.0.0.0", :AccessLog => []}
+          server.run app, options
+        end
+        try, ok = 0, false
+        begin
+          info "Attempting to reach the web server..." if verbose
+          ::Net::HTTP.get(URI.parse(waw_kernel.config.web_base))
+          ok = true
+        rescue Errno::ECONNREFUSED => ex
+          sleep 0.1
+        end until (ok or (try += 1)>10)
+        if ok
+          if verbose
+            info "Your web application has been started successfully"
+            info "Have a look at #{waw_kernel.config.web_base}"
+            info "Enjoy waw!"
+          end
+          [t, waw_kernel]
+        else
+          raise Waw::Error, "Unable to reach the web server after having been started"
+        end
+      end
+      
+      # Runs the sub-class defined command
+      def __run(requester_file, arguments)
+        waw_start(requester_file)[0].join
+      rescue Interrupt => ex
+        info "waw-start stopping now... ciao!"
+      end
+
+    end # class StartCommand
+  end # module Commans
+end # module Waw

data/lib/waw/config.rb

@@ -0,0 +1,110 @@
+module Waw
+  # Implements waw configuration utility
+  class Config
+    
+    # Implementation of the config domain specific language
+    class DSL
+      
+      # Creates a DSL instance
+      def initialize(config)
+        @config = config
+      end
+      
+      # When a method is missing, install config parameter
+      def method_missing(name, *args, &block)
+        if args.length==0 and block.nil?
+          @config.send(name)
+        elsif args.length==0
+          @config.install_configuration_property(name, block)
+        elsif block
+          raise WawConfigurationError, "Bad config usage on #{name}"
+        else
+          @config.install_configuration_property(name, args.size==1 ? args[0] : args)
+        end
+      end
+      
+    end # class DSL
+    
+    # Initialize a configuration instance. If merge_default is set to true,
+    # the default configuration file is automatically loaded.
+    def initialize(app, merge_default = true)
+      raise ArgumentError, "Waw application required as first argument" unless app.respond_to?(:root_folder)
+      @wawapp = app
+      self.merge_file(File.join(File.dirname(__FILE__), 'default_config.cfg')) if merge_default
+    end
+    
+    # Raises a configuration error
+    def config_error(name, message)
+      raise ConfigurationError, message
+    end
+    
+    # Checks if a configuration property is known
+    def knows?(name)
+      self.respond_to?(name.to_s.to_sym)
+    end
+    
+    # Returns the configuration property under name, 
+    # or returns default if the config does not know that name
+    def ensure(name, default)
+      knows?(name) ? self.send(name) : default
+    end
+    
+    # Installs a configuration parameter
+    def install_configuration_property(name, value)
+      case name
+        when :load_path
+          value = [value] unless Array===value
+          value = value.collect{|val| File.expand_path(File.join(@wawapp.root_folder, val))}
+          $LOAD_PATH.unshift(*value)
+        when :requires
+          value = [value] unless Array===value
+          value.each{|f| require(f)}
+        when :log_dir
+          config_error(name, "log_dir is expected to be a string") unless String===value
+          # config_error(name, "Unable to access log_dir #{value}") unless File.exists?(value) and 
+          #                                                                File.directory?(value) and
+          #                                                                File.writable?(value)
+        when :log_file
+          config_error(name, "log_file is expected to be a string") unless String===value
+        when :log_level
+          config_error(name, "Bad log_level #{value}") unless value>=0 and value<=5
+        when :log_frequency
+          config_error(name, "Bad log_frequency #{value}") unless %w{daily weekly monthly}.include?(value)
+        when :web_domain, :web_base
+          config_error(name, "web_domain is expected to be a string") unless String===value
+        when :rack_session
+          config_error(name, "rack_session is expected to be true or false") unless true==value or false==value
+        when :rack_session_expire
+          config_error(name, "rack_session_expire is expected to be an Integer") unless Integer===value
+      end
+      instance_eval "@#{name} = value"
+      instance_eval <<-EOF
+        def #{name}(force_array = false)
+          value = @#{name}
+          if Proc===value
+            self.instance_eval &value
+          else
+            force_array ? (Array===value ? value : [value]) : value
+          end
+        end
+      EOF
+    end
+    
+    # Merges the configuration with a given configuration string
+    def merge(config_str)
+      begin
+        DSL.new(self).instance_eval config_str
+      rescue ConfigurationError => ex
+        raise ex
+      end
+      self
+    end
+    
+    # Merges the configuration with a given configuration file
+    def merge_file(config_file)
+      raise ArgumentError, "Config file does not exists" unless File.exists?(config_file)
+      merge File.read(config_file)
+    end
+    
+  end # class Config
+end # module Waw

data/lib/waw/controller.rb

@@ -0,0 +1,25 @@
+module Waw
+  
+  #
+  # Controller of a web application, designing a number of typical services.
+  #
+  class Controller
+    include Waw::EnvironmentUtils
+    include ::Rack::Delegator
+    
+    # Handler for Rack calls to the controller
+    def call(env)
+      result = execute(env, request, response)
+      raise WawError, "Controller #{self.class} returned an empty result" unless result
+      raise WawError, "Controller #{self.class} returned an invalid result #{result.inspect}" unless Array===result
+      result
+    end
+    
+    # Executes the controller on a Rack::Request and Rack::Response pair
+    def execute(env, request, response)
+      raise "Should be subclassed"
+    end
+    
+  end # class Controller
+
+end # module Waw

data/lib/waw/controllers/action/action.rb

@@ -0,0 +1,91 @@
+module Waw
+  class ActionController < Waw::Controller
+    # 
+    # A Web action, inside an ActionController.
+    # 
+    class Action
+    
+      # Action controller
+      attr_reader :controller
+    
+      # Action name
+      attr_reader :name
+      
+      # Action signature (pre-conditions and validation)
+      attr_reader :signature
+      
+      # Action routing
+      attr_reader :routing
+    
+      # Creates an action instance
+      def initialize(name, signature, routing, controller, method)
+        @name, @signature, @routing = name, signature, routing
+        @controller, @method = controller, method
+        @routing = ::Waw::Routing::ActionRouting.new unless @routing
+      end
+      
+      # Returns a unique id for this action in the architecture
+      def id
+        "#{controller.url}/#{name}"[1..-1].gsub('/', '_')
+      end
+      
+      # Builds a href for this action, with optional parameters
+      def href(params = nil)
+        "#{controller.url}/#{name}" << (params ? "?#{params.to_url_query}" : "")
+      end
+      alias :url :href
+      alias :uri :href
+      
+      # Factors the ajax link for invoking this action in a <a onclick="...">
+      def ajax_link(arguments = {})
+        buffer = ""
+        arguments.each_pair {|k, v| buffer << ", '#{k}' : '#{v}'"}
+        "javascript:#{id}({#{buffer[2..-1]}}, '##{id}')"
+      end
+      
+      # Factors the ajax code for preparing a formulary
+      def ajax_form_preparer(opts = {})
+        form_id = opts[:form_id] || id
+        <<-EOF
+          <script type="text/javascript">
+          	$(document).ready(function() {
+          	  $("form##{form_id}").submit(function() {
+          	    #{id}($("form##{form_id}").serialize(), "form##{form_id}");
+            	  return false;
+          	  });
+            });
+          </script>
+        EOF
+      end
+      
+      # Factors a javascript call to the associated action
+      def ajax_action_call(opts = {})
+        form_id = opts[:form_id] || id
+        "#{id}($(\"form##{form_id}\").serialize(), \"form##{form_id}\");"
+      end
+      
+      # Factors the ajax code to submit the formulary
+      def ajax_form_submit(opts = {})
+        form_id = opts[:form_id] || id
+        "javascript:$('form##{form_id}').submit()"
+      end
+      
+      # Executes the action inside a controller and using parameters
+      def execute(params = {})
+        ok, values = @signature.apply(params)
+        if ok
+          # validation is ok, merge params and continue
+          [:success, @method.bind(controller.instance).call(params.merge!(values))]
+        else
+          # validation is ko
+          [:"validation-ko", values]
+        end
+      rescue ::Waw::Validation::KO => ex
+        [:"validation-ko", ex.failed]
+      rescue ::Waw::Validation::Error => ex
+        [:"validation-error", ex.failed]
+      end
+    
+    end # class Action
+  end # class ActionController
+end # module Waw