waw 0.2.2

data/lib/waw/kern/utils.rb

@@ -0,0 +1,27 @@
+module Waw
+  module Kern
+    #
+    # Utilities of the waw kernel
+    #
+    module Utils
+      
+      #
+      # Finds the root of the waw application by traversing the file system
+      # up from _from_ until a waw.deploy file can be found. Returns the 
+      # root_folder that contains the waw.deploy file.
+      #
+      # This method raises a WawError if the waw.deploy file cannot be found.
+      #
+      def find_web_root(from)
+        web_root = File.expand_path(from)
+        from = File.dirname(from) if File.file?(from)
+        until File.exists?(File.join(web_root, 'waw.deploy')) or File.exists?(File.join(web_root, 'wawdeploy'))
+          web_root = File.expand_path(File.join(web_root, '..'))
+          raise WawError, "Unable to find waw.deploy file from folder #{from}" if web_root == '/'
+        end
+        web_root
+      end
+    
+    end # module Utils
+  end # module Kern
+end # module Waw

data/lib/waw/resource_collection.rb

@@ -0,0 +1,100 @@
+module Waw
+  # Localized resources
+  class ResourceCollection
+    
+    # DSL for resources
+    class DSL
+      
+      # Creates a DSL instance
+      def initialize(resources)
+        @resources = resources
+      end
+      
+      # Adds a resource to the collection
+      def method_missing(name, *args, &block)
+        if args.length==0 and block.nil?
+          @resources.send(name)
+        elsif args.length==1 and block.nil?
+          @resources.send(:add_resource, name, args[0])
+        elsif args.length==0 and block
+          @resources.send(:add_resource, name, nil, &block)
+        elsif block
+          raise ArgumentError, "Bad resources usage on #{name} #{args.inspect} #{block.inspect}"
+        end
+      end
+      
+    end # class Resources
+    
+    # Resource name
+    attr_reader :__name
+    
+    # Creates a resource collection
+    def initialize(name = "unnamed")
+      @resources = {}
+      @__name = name
+    end
+    
+    # Yields the block with each resource key,value pair
+    def each
+      @resources.each_pair {|k, v| yield(k, v)}
+    end
+    alias :each_pair :each
+    
+    # Returns the resource installed under name
+    def [](name)
+      @resources[name]
+    end
+    
+    # Checks if a resource exists
+    def has_resource?(name)
+      @resources.has_key?(name)
+    end
+    
+    # Add a resource
+    def add_resource(name, value, &block)
+      if not(value.nil?) and block.nil?
+        @resources[name.to_s.to_sym] = value
+        self.instance_eval <<-EOF
+          def #{name}
+            @resources[:#{name}] 
+          end
+        EOF
+      elsif value.nil? and not(block.nil?)
+        @resources[name.to_s.to_sym] = block
+        self.instance_eval <<-EOF
+          def #{name}
+            @resources[:#{name}].call(self)
+          end
+        EOF
+      else
+        raise ArgumentError, "ResourceCollection.add_resource expects one argument or a block"
+      end
+    end
+    
+    # Logs a friendly message and returns nil
+    def method_missing(name, *args)
+      if args.size==1
+        args[0]
+      elsif args.size==0
+        Waw.logger.warn("No such resource #{name} on #{@__name}, (#{caller[0]})")
+        nil
+      else
+        super
+      end
+    end
+    
+    # Parses some resource string
+    def self.parse_resources(str, name = "unnamed")
+      r = ResourceCollection.new(name)
+      DSL.new(r).instance_eval str
+      r
+    end
+    
+    # Parses a resource file
+    def self.parse_resource_file(f, name=File.basename(f, '.rs'))
+      parse_resources File.read(f), name
+    end
+    
+    private :add_resource
+  end # class ResourceCollection
+end # module Waw

data/lib/waw/restart.rb

@@ -0,0 +1,32 @@
+module Waw
+  class Restart
+    include ::Rack::Delegator
+    
+    # Default options
+    DEFAULT_OPTIONS = { :when => :always }
+    
+    # Creates a restarter instance
+    def initialize(app, opts = {}, lock = Mutex.new)
+      @options = DEFAULT_OPTIONS.merge(opts)
+      @app = app
+      @lock = lock
+    end
+    
+    # Should I need to restart?
+    def restart?
+      @options[:when] == :always
+    end
+    
+    # Handle the call
+    def call(env)
+      if restart?
+        @lock.synchronize do
+          root_folder = Waw.root_folder
+          Waw.reload
+        end
+      end
+      @app.call(env)
+    end
+    
+  end # class Restart
+end # module Waw

data/lib/waw/routing.rb

@@ -0,0 +1,43 @@
+require 'waw/routing/dsl'
+require 'waw/routing/action_routing'
+require 'waw/routing/routing_rule'
+require 'waw/routing/feedback'
+require 'waw/routing/form_validation_feedback'
+require 'waw/routing/refresh'
+require 'waw/routing/redirect'
+require 'waw/routing/javascript'
+module Waw
+  module Routing
+    module Methods
+      
+      # Checks if a service response matches some expected pattern
+      def matches?(what, json_response = self)
+        raise ArgumentError, "Array expected as json_response (#{json_response.inspect} found)" unless Array===json_response
+        json_response = json_response.dup
+        what.split('/').each do |elm|
+          return false if json_response.empty?
+          case part = json_response.shift
+            when String, Symbol
+              if elm == '*'
+                # always ok here
+              else
+                return false unless part.to_s==elm.to_s
+              end
+            when Array
+              if elm == '*'
+                return false if part.empty?
+              else
+                return false unless part.any?{|e| e.to_s == elm.to_s} or (elm=='*')
+              end
+            else
+              raise ArgumentError, "Unexpected part in json_response #{part}"
+          end
+        end
+        true
+      end
+      alias :=~ :matches?
+      
+    end # module Methods 
+    extend Methods
+  end # module Routing
+end # module Waw

data/lib/waw/routing/action_routing.rb

@@ -0,0 +1,78 @@
+module Waw
+  module Routing
+    
+    #
+    # Routing rules installed on an action
+    #
+    class ActionRouting
+      
+      # Creates an empty routing table. If a block is given, executes it
+      # as a Routing DSL
+      def initialize(&block)
+        @rules = {}
+        DSL.new(self).instance_eval(&block) if block
+      end
+      
+      # Add some routing rules
+      def add_rules(action_results, exec)
+        action_results.each {|actr| @rules[actr] = exec}
+      end
+      
+      def generate_js_if_then_else(table, key, level = 0, align = 0)
+        case table
+          when Hash
+            if table.size==1 and table.has_key?('*')
+              generate_js_if_then_else(table['*'], key, level, align)
+            else
+              first, buffer, space = true, "", " "
+              
+              # normal table
+              table.each do |key, n|
+                next if key=='*'
+                code = "#{first ? space*align : ' else '}if (data[#{level}] == '#{key}') {\n" +
+                       "#{generate_js_if_then_else(n, key, level+1, align+2)}\n" +
+                       " "*align + "}"
+                first = false
+                buffer << code
+              end
+              
+              if table.has_key?('*')
+                buffer << " else {\n"
+                buffer << generate_js_if_then_else(table['*'], key, level, align+1)
+                buffer << " "*align + "}"
+              end
+              
+              buffer
+            end
+          when RoutingRule
+            table.generate_js_code(key, align)
+          else
+            raise "Unexpected table #{table}"
+        end
+      end
+      
+      # Generates the javascript routing
+      def generate_js_routing(action, align=0)
+        # Build the if-then-else table
+        table = Hash.new {|h, k| h[k] = Hash.new}
+        @rules.each do |pattern, rule|
+          elements = pattern.split('/')
+          raise "Unsupport action-routing pattern #{pattern}" if elements.size==0 or elements.size>2
+          elements << '*' if elements.size == 1
+          table[elements[0]][elements[1]] = rule
+        end
+        
+        # Build the javascript code now
+        generate_js_if_then_else(table, "", 0, align)
+      end
+      
+      # Applies this action routing on a browser
+      def apply_on_browser(result, browser)
+        @rules.each_pair do |pattern, rule|
+          rule.apply_on_browser(result, browser) if Waw::Routing.matches?(pattern, result)
+        end
+      end
+    
+    end # class ActionRouting
+  end # module Routing
+end # module Waw

data/lib/waw/routing/dsl.rb

@@ -0,0 +1,45 @@
+module Waw
+  module Routing
+    # The DSL for routing blocks
+    class DSL 
+      
+      # Creates a DSL instance for some routing instance
+      def initialize(routing)
+        @routing = routing
+      end
+      
+      # Evaluates the block as routing execution and installs it
+      # under all provided action results
+      def upon(*action_results)
+        raise ArgumentError, "Missing routing block on upon", caller unless block_given?
+        @routing.add_rules(action_results, yield)
+      end
+      
+      # Feedback routing execution
+      def feedback(*args)
+        Waw::Routing::Feedback.new(*args)
+      end
+      
+      # Form validation feedback routing execution
+      def form_validation_feedback(*args)
+        Waw::Routing::FormValidationFeedback.new(*args)
+      end
+      
+      # Refresh routing execution
+      def refresh(*args)
+        Waw::Routing::Refresh.new(*args)
+      end
+      
+      # Redirect routing execution
+      def redirect(*args)
+        Waw::Routing::Redirect.new(*args)
+      end
+      
+      # Javascript routing execution
+      def javascript(*args)
+        Waw::Routing::Javascript.new(*args)
+      end
+      
+    end # class DSL
+  end # module Routing
+end # module Waw

data/lib/waw/routing/feedback.rb

@@ -0,0 +1,23 @@
+module Waw
+  module Routing
+    # Feedback routing
+    class Feedback < RoutingRule
+
+      # Creates a feedback instance
+      def initialize(opts = {})
+        @opts = opts
+      end
+
+      def generate_js_code(result, align=0)
+        selector = @opts[:css_selector] || '.feedback'
+        buffer = ""
+        buffer << " "*align + "$(form + ' input').hide();\n" if @opts[:hide_input]
+        buffer << " "*align + "$(form + ' #{selector}').show();\n"
+        message = @opts[:message] ? "'#{@opts[:message]}'" : 'data[1][0]'
+        buffer << " "*align + "$(form + ' #{selector}').html(messages[#{message}]);"
+        buffer
+      end
+      
+    end # class Feedback
+  end # module Routing
+end # module Waw

data/lib/waw/routing/form_validation_feedback.rb

@@ -0,0 +1,36 @@
+module Waw
+  module Routing
+    # FormValidationFeedback routing
+    class FormValidationFeedback < RoutingRule
+
+      def initialize(opts = {})
+        @options = opts
+      end
+
+      def generate_js_code(result, align=0)
+        buffer = ""
+				buffer << " "*align + "str = '';\n"
+				buffer << " "*align + "str += '<ul>';\n"
+				buffer << " "*align + "for (var k in data[1]) {\n"
+				buffer << " "*(align+2)	+ "str += '<li>' + messages[data[1][k]] + '</li>';\n"
+				buffer << " "*align + "}\n"
+				buffer << " "*align + "str += '</ul>';\n"
+				buffer << " "*align + "$(form + ' .feedback').show();\n"
+				buffer << " "*align + "$(form + ' .feedback').html(str);\n"
+				if @options[:scroll]
+  				where = case @options[:scroll]
+    			  when :top
+  			      '0'
+  			    when :form
+  			      "$(form).offset().top"
+  			    when :feedback
+  			      "$(form + ' .feedback').offset().top"
+  			  end
+          buffer << "$('html, body').animate( { scrollTop: #{where} }, 'slow' );\n"
+  			end
+        buffer
+      end
+      
+    end # class FormValidationFeedback
+  end # module Routing
+end # module Waw

data/lib/waw/routing/javascript.rb

@@ -0,0 +1,17 @@
+module Waw
+  module Routing
+    # Javascript routing
+    class Javascript < RoutingRule
+
+      # Creates a javascript instance
+      def initialize(code)
+        @code = code
+      end
+
+      def generate_js_code(result, align=0)
+        @code
+      end
+      
+    end # class Javascript
+  end # module Routing
+end # module Waw

data/lib/waw/routing/redirect.rb

@@ -0,0 +1,26 @@
+module Waw
+  module Routing
+    # Redirect routing
+    class Redirect < RoutingRule
+      
+      # Creates a redirection rule instance
+      def initialize(opts = {})
+        @opts = opts
+      end
+      
+      # Forces the browser to refresh
+      def apply_on_browser(result, browser)
+        browser.location = @opts[:url]
+      end
+      
+      def generate_js_code(result, align=0)
+        if @opts[:url]
+          " "*align + "window.location = \"#{@opts[:url]}\";"
+        else
+          " "*align + "window.location = data[1];"
+        end
+      end
+      
+    end # class Redirect
+  end # module Routing
+end # module Waw

data/lib/waw/routing/refresh.rb

@@ -0,0 +1,17 @@
+module Waw
+  module Routing
+    # Refresh routing
+    class Refresh < RoutingRule
+
+      # Forces the browser to refresh
+      def apply_on_browser(result, browser)
+        browser.refresh
+      end
+      
+      def generate_js_code(result, align=0)
+        " "*align + "location.reload(true);"
+      end
+      
+    end # class Refresh
+  end # module Routing
+end # module Waw