waw 0.2.2

data/lib/waw/validation/size_validations.rb

@@ -0,0 +1,44 @@
+module Waw
+  module Validation
+    # Validation linked to the length of the string
+    module SizeValidations
+      module Methods
+        
+        # Checks that it has a size
+        def has_size?(val) val.respond_to?(:size) end
+        
+        # Builds a validator that verifies that the length is greater than
+        # a specified value
+        def >(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| has_size?(val) and (val.size > value)} }}
+        end
+    
+        # Builds a validator that verifies that the length is greater-or-equal to
+        # a specified value
+        def >=(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| has_size?(val) and (val.size >= value)} }}
+        end
+    
+        # Builds a validator that verifies that the length is less than
+        # a specified value
+        def <(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| has_size?(val) and (val.size < value)} }}
+        end
+    
+        # Builds a validator that verifies that the length is less-or-equal to
+        # a specified value
+        def <=(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| has_size?(val) and (val.size <= value)} }}
+        end
+    
+        # Builds a validator that verifies that the length is equal to a
+        # specified value
+        def ==(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| has_size?(val) and (val.size == value)} }}
+        end
+        
+      end
+      extend Methods
+    end # module SizeValidations
+  end # module Validation
+end # module Waw

data/lib/waw/validation/string_validator.rb

@@ -0,0 +1,15 @@
+module Waw
+  module Validation
+    class StringValidator < Validator
+      
+      def validate(*values)
+        values.all?{|v| String===v}
+      end
+      
+      def convert_and_validate(*values)
+        [validate(*values), values]
+      end
+      
+    end
+  end # module Validation
+end # module Waw

data/lib/waw/validation/validator.rb

@@ -0,0 +1,48 @@
+module Waw
+  module Validation
+    #
+    # A validator reusable class.
+    #
+    class Validator
+      include ::Waw::Validation::Helpers
+      
+      # Creates a validator instance that takes a block as validation code
+      def initialize(&block)
+        @block = block
+      end
+      
+      # Calls the block installed at initialization time    
+      def validate(*values)
+        raise "Missing validation block on #{self}" unless @block
+        @block.call(*values)
+      end
+      def ===(*args)
+        validate(*args)
+      end
+    
+      # Converts and validate
+      def convert_and_validate(*values)
+        validate(*values) ? [true, values] : [false, values]
+      end
+      def =~(*args)
+        convert_and_validate(*args)
+      end
+    
+      # Negates this validator
+      def not
+        NotValidator.new(self)
+      end
+    
+      # Creates a validator by disjunction
+      def |(validator)
+        OrValidator.new(self, Waw::Validation.to_validator(validator))
+      end
+    
+      # Creates a validator by conjunction
+      def &(validator)
+        AndValidator.new(self, Waw::Validation.to_validator(validator))
+      end
+    
+    end # class Validator
+  end # module Validation
+end # module Waw

data/lib/waw/wawgen.rb

@@ -0,0 +1,2 @@
+require 'waw/wawgen/project'
+require 'waw/wawgen/create'

data/lib/waw/wawgen/create.rb

@@ -0,0 +1,166 @@
+require 'optparse'
+require 'fileutils'
+module Waw
+  module Wawgen
+    # Implementation of 'waw create'
+    class Create
+      
+      # Which layout
+      attr_reader :layout
+      
+      # Force overrides?
+      attr_reader :force
+
+      # Creates a command instance
+      def initialize
+        @layout = 'empty'
+        @force = false
+      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 = WLang::VERSION
+          opt.release = nil
+          opt.summary_indent = ' ' * 4
+          banner = <<-EOF
+            # Usage waw create [options] ProjectName
+      
+            # Creates an initial waw project structure
+          EOF
+          opt.banner = banner.gsub(/[ \t]+# /, "")
+    
+          opt.separator nil
+          opt.separator "Options:"
+    
+          opt.on("--force", "-f", "Erase any exsting file on conflict") do |value|
+            @force = true
+          end
+
+          opt.on("--layout=LAYOUT", "-l", "Use a specific waw layout (default empty)") do |value|
+            @layout = value
+          end
+
+          opt.on("--verbose", "-v", "Display extra progress as we parse.") do |value|
+            @verbosity = 2
+          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 "waw version " << Waw::VERSION << " (c) University of Louvain, Bernard & Louis Lambeau"
+            exit
+          end
+    
+          opt.separator nil
+        end
+      end
+
+      # Runs the command
+      def run(argv)
+        # parse options
+        rest = options.parse!(argv)
+        if rest.length != 1
+          puts options
+          exit(-1)
+        end
+        
+        # check project name
+        project_name = rest[0]
+        exit("Invalid project name #{project_name}, must start with [a-zA-Z]") unless /^[a-zA-Z]/ =~ project_name
+        if project_name =~ /^[a-z]/
+          project_name = (project_name[0...1].upcase + project_name[1..-1]) 
+          puts "Warning: using #{project_name} as project name for ruby needs..."
+        end
+        
+        # create project
+        project = ::Waw::Wawgen::Project.new(project_name)
+        begin
+          generate(project)
+        rescue WLang::Error => ex
+          puts ex.message
+          puts ex.wlang_backtrace.join("\n")
+          puts ex.backtrace.join("\n")
+        end
+      end
+      
+      # Puts an error message and exits
+      def exit(msg)
+        puts msg
+        Kernel.exit(-1)
+      end
+
+      def generate_recursively(project, layout_folder, target_folder)
+        # Generate files now
+        Dir.new(layout_folder).each do |file|
+          next if ['.', '..', 'dontforgetme'].include?(file)
+          next if 'dependencies'==file
+          target = File.join(target_folder, file.gsub('project', project.lowname))
+          puts "Generating #{target} from #{layout}/#{file}"
+
+          if File.directory?(source=File.join(layout_folder, file))
+            FileUtils.mkdir_p target unless File.exists?(target)
+            generate_recursively(project, source, target)
+          else
+            File.open(target, 'w') do |io|
+              if /jquery/ =~ file
+                io << File.read(File.join(layout_folder, file))
+              else
+                context = {"project" => project}
+                io << WLang.file_instantiate(File.join(layout_folder, file), context, 'wlang/active-string', :parentheses).to_s
+              end
+            end
+          end
+        end
+      end
+
+      # Generates a given layout for a specific project
+      def generate_layout(project, layout)
+        # Locate the layout folder
+        layout_folder = File.join(File.dirname(__FILE__), '..', '..', '..', 'layouts', layout)
+        puts File.expand_path(layout_folder)
+        exit("Unknown layout #{layout}") unless File.exists?(layout_folder)
+        
+        # Handle dependencies
+        dependencies_file = File.join(layout_folder, 'dependencies')
+        if File.exists?(dependencies_file)
+          File.readlines(dependencies_file).each do |line|
+            next if /^#/ =~ (line = line.strip)
+            line.split(/\s/).each do |word| 
+              generate_layout(project, word)
+            end
+          end
+        end
+        
+        # Let recursive generation occur
+        puts "Generating recursively project, #{layout_folder}, #{project.folder}"
+        generate_recursively(project, layout_folder, project.folder)
+      end
+
+      # Generates the project
+      def generate(project)
+        # A small debug message and we start
+        puts "Generating project with names #{project.upname} inside #{project.lowname} using layout #{layout}"
+        
+        # 1) Create the output folder if it not exists
+        if File.exists?(project.folder) and not(force)
+          exit("The project folder #{project.lowname} already exists. Remove it first")
+        else
+          FileUtils.rm_rf project.folder if File.exists?(project.folder)
+          FileUtils.mkdir_p project.folder
+        end
+
+        generate_layout(project, layout)
+        FileUtils.chmod 0755, File.join(project.root, 'config.ru')
+      end
+      
+    end # class Create
+  end # module Wawgen
+end # module Waw

data/lib/waw/wawgen/project.rb

@@ -0,0 +1,25 @@
+module Waw
+  module Wawgen
+    class Project
+
+      # Upper case name of the project
+      attr_reader :upname
+  
+      # Lower case name of the project
+      attr_reader :lowname
+  
+      # Creates a project instance
+      def initialize(name, folder=nil)
+        @upname, @lowname = name, WLang::encode(name, 'ruby/method-case')
+        @folder = folder
+      end
+  
+      # Returns root folder
+      def root
+        @folder ||= lowname
+      end
+      alias :folder :root
+  
+    end # class Project
+  end # module Wawgen
+end # module Waw

data/lib/waw/wspec.rb

@@ -0,0 +1,5 @@
+require 'waw/wspec/html_analysis'
+require 'waw/wspec/browser'
+require 'waw/wspec/suite'
+require 'waw/wspec/dsl'
+require 'waw/wspec/scenario'

data/lib/waw/wspec/browser.rb

@@ -0,0 +1,240 @@
+require 'net/http'
+require 'uri'
+module Waw
+  module WSpec
+    # A fake browser for waw application testing
+    class Browser
+      include Waw::WSpec::HTMLAnalysis
+      
+      # Current browser location
+      attr_reader :location
+      
+      # Current server response
+      attr_reader :response
+      
+      # The last action result
+      attr_reader :last_action_result
+      
+      # Creates a browser instance
+      def initialize(location = nil)
+        self.location = location if location
+      end
+      
+      #################################################################### URI utilities
+      
+      # Checks if something is an URI
+      def is_uri?(uri)
+        URI::Generic===uri
+      end
+      
+      # Ensures that something is an uri or convert it.
+      def ensure_uri(uri)
+        raise ArgumentError, "ensure_uri: uri may not be nil" if uri.nil?
+        is_uri?(uri) ? uri : URI.parse(uri)
+      end
+      
+      # Extracts the base of an URI
+      def extract_base(uri)
+        raise ArgumentError, "extract_base: uri may not be nil" if uri.nil?
+        ensure_uri("#{uri.scheme}://#{uri.host}#{uri.port ? (':' + uri.port.to_s) : ''}/")
+      end
+      
+      # Computes the new location if a relative uri is followed
+      def relative_uri(uri)
+        raise ArgumentError, "relative_uri: uri may not be nil" if uri.nil?
+        uri = ensure_uri(uri)
+        if uri.path[0...1] == '/'
+          new_location = base.dup
+          new_location.path = uri.path
+          new_location.query = uri.query
+          new_location
+        else
+          new_location = base.dup
+          new_location.path = '/' + uri.path
+          new_location.query = uri.query
+          new_location
+        end
+      end
+      
+      #################################################################### Query utilities
+      
+      # Looks for the base of the website
+      def base
+        @base ||= find_base
+      end
+      
+      # Finds the base of the current location
+      def find_base
+        if contents and (found = tag("base", {:href => /.*/}, contents))
+          ensure_uri(found[:href])
+        else
+          extract_base(location)
+        end
+      end
+      
+      # Checks if the last request waw answered by a 404 not found
+      def is404
+        (Net::HTTPNotFound === response)
+      end
+      alias :is404? :is404
+      
+      # Checks if the last request waw answered by a 200 OK
+      def is200
+        (Net::HTTPSuccess === response)
+      end
+      alias :is200? :is200
+      
+      # Returns the current shown contents
+      def contents
+        response ? response.read_body : nil
+      end
+      alias :browser_contents :contents
+      
+      #################################################################### Location set
+      
+      # Go to a relative position
+      def go_relative(uri)
+        self.location = relative_uri(uri)
+      end
+      
+      # Sets the current location
+      def location=(loc)
+        if (loc = ensure_uri(loc)).relative?
+          go_relative(loc)
+        else
+          @location, @response = fetch(loc)
+          @location
+        end
+      end
+      
+      # Fetches the headers only and returns it without keeping the result in browser
+      # state
+      def headers_fetch(uri)
+        # Fetch the result at that location
+        if (loc = ensure_uri(uri)).relative?
+          headers_fetch(relative_uri(uri))
+        else
+          response = Net::HTTP.start(loc.host, loc.port) do |http|
+            headers = @cookie ? {'Cookie' => @cookie} : {}
+            http.head(loc.path, headers)
+          end
+        end
+      end
+      
+      # Refreshes the browser
+      def refresh
+        self.location = location
+      end
+      
+      # Simulates a click. Support relative as well as absolute paths.
+      # Raises a URI::InvalidURIError if the given href seems invalid.
+      def click_href(href)
+        uri = URI.parse(href)
+        if uri.relative?
+          go_relative(uri)
+        else
+          case uri.scheme
+            when "http"
+              self.location = href
+            else
+              raise ArgumentError, "This browser does not support #{href} location"
+          end
+        end
+      end
+      
+      #################################################################### Server invocation utilities
+      
+      # Applies the action routing for a given action
+      def apply_action_routing(action, result)
+        @last_action_result = result
+        action.routing.apply_on_browser(result, self) if action.routing
+        result.extend(Waw::Routing::Methods)
+        result
+      end        
+      
+      # Invokes an action server side, decodes json response an applies action routing. 
+      # Returns the action result.
+      def invoke_action(action, args = {})
+        raise ArgumentError, "Browser.invoke_action expects an ActionController::Action as first parameter"\
+          unless ::Waw::ActionController::Action===action
+        location, response = fetch(relative_uri(action.uri), :post, args)
+        apply_action_routing(action, JSON.parse(response.body))
+        self.response
+      end
+      
+      # Invokes a service server side and returns HTTP response
+      def invoke_service(service, args = {})
+        raise ArgumentError, "Browser.invoke_service expects a String as first parameter"\
+          unless String===service
+        location, response = fetch(relative_uri(service), :post, args)
+        self.response
+      end
+      
+      # Invokes a server service with arguments and decoding method
+      def server_invoke(service, args, decode_method = nil)
+        location, response = fetch(relative_uri(service), :post, args)
+        response
+      end
+      
+      #################################################################### Private section
+      # Clean cache after fetch
+      def clean_post_fetch
+        @base = nil
+      end
+      
+      # Fetchs a given location
+      def fetch(uri, method = :get, data = {}, limit = 10)
+        # You should choose better exception.
+        raise 'HTTP redirect too deep' if limit == 0
+
+        # Fetch the result at that location
+        location = ensure_uri(uri)
+        response = Net::HTTP.start(location.host, location.port) do |http|
+          headers = @cookie ? {'Cookie' => @cookie} : {}
+          case method
+            when :get
+              path = location.path
+              path += '?' + location.query if location.query
+              http.request_get(path, headers)
+            when :post
+              req = Net::HTTP::Post.new(location.path, headers)
+              req.form_data = data.unsymbolize_keys
+              http.request(req)
+            else
+              raise ArgumentError, "Invalid fetch method #{method}"
+          end
+        end
+        
+        # If a cookie is requested save it
+        @cookie = response['set-cookie']
+        
+        # Catch the response, following redirections
+        result = case response
+          when Net::HTTPRedirection 
+            fetch(response['location'] || response['Location'], :get, {}, limit - 1)
+          else
+            [location, response]
+        end
+        
+        # Cleans cache and returns result
+        clean_post_fetch
+        result
+      end
+      
+      #################################################################### Helpers to save context
+      
+      # Installs the browser context
+      def install_context(location, response, cookie)
+        @location, @response, @cookie = location, response, cookie
+        self
+      end
+      
+      # Duplicates this browser instance, with internal state  
+      def dup
+        Browser.new.install_context(@location, @response, @cookie)
+      end
+      
+    end # class Browser
+    class ServerError < StandardError; end
+  end # module WSpec
+end # module Waw