waw 0.2.2

data/lib/waw/controllers/static/match.rb

@@ -0,0 +1,80 @@
+module Waw
+  class StaticController < ::Waw::Controller
+    class WawAccess
+      class Match
+        include Waw::ScopeUtils
+        
+        # Served file
+        attr_reader :served_file
+        
+        # Creates a match instance with a block a arguments 
+        # to pass
+        def initialize(wawaccess, served_file, block, *args)
+          @wawaccess, @served_file = wawaccess, served_file
+          @block, @args = block, args
+        end
+        
+        # Executes on a wawaccess instance
+        def __execute
+          instance_exec *@args, &@block
+        end
+        
+        # Delegated to the wawaccess that created me
+        def root; @wawaccess.root; end
+        def folder; @wawaccess.folder; end
+        
+        ################################################### Callbacks proposed to .wawaccess rules
+      
+        # Deny access to the file
+        def deny
+          body = "Forbidden\n"
+          [403, {"Content-Type" => "text/plain",
+                 "Content-Length" => body.size.to_s,
+                 "X-Cascade" => "pass"},
+           [body]]
+        end
+      
+        # Serves a static file from a real path
+        def static
+          if rack_env
+            rack_env["PATH_INFO"] = served_file
+            @wawaccess.file_server.call(rack_env)
+          else
+            path = File.join(root.folder, served_file)
+            [200, {'Content-Type' => 'text/plain'}, [File.read(path)]]
+          end
+        end
+      
+        # Run a rewriting
+        def apply(path, result_override = nil, headers_override = {})
+          result = root.do_path_serve(path)
+          [result_override || result[0], 
+           result[1].merge(headers_override),
+           result[2]]
+        end
+      
+        # Builds a default wlang contect
+        def default_wlang_context
+          context = {"css_files"   => root.find_files('css'),
+                     "js_files"    => root.find_files('js'),
+                     "served_file" => served_file}
+          context
+        end
+      
+        # Instantiates wlang on the current file, with a given context
+        def wlang(template = nil, context = {}, result_override = nil, headers_override = {})
+          if template.nil?
+            template = File.join(root.folder, served_file)
+          else
+            template = File.join(folder, template)
+          end
+          context = default_wlang_context.merge(context || {})
+          [result_override || 200, 
+           {'Content-Type' => 'text/html'}.merge(headers_override || {}), 
+            [::WLang.file_instantiate(template, context.unsymbolize_keys).to_s]]
+        end
+
+      end # class Match
+    end # class WawAccess
+  end # class StaticController
+end # module Waw

data/lib/waw/controllers/static/waw_access.rb

@@ -0,0 +1,235 @@
+require 'uri'
+require 'waw/controllers/static/match'
+module Waw
+  class StaticController < ::Waw::Controller
+    # Waw version of .htaccess files
+    class WawAccess
+      
+      # The folder which is served
+      attr_accessor :folder
+      
+      # Strategy :allow_all or :deny_all
+      attr_accessor :strategy
+      
+      # Does it inherits its parent configuration?
+      attr_accessor :inherits
+      
+      # The parent wawaccess file
+      attr_accessor :parent
+      
+      # Fake accessor that go to the top of the hierarchy
+      def file_server
+        @file_server || (parent && parent.file_server)
+      end
+      
+      # Creates a default WawAccess file
+      def initialize(parent = nil, folder = nil, read_file = nil)
+        @parent = parent
+        @folder = folder
+        @strategy = :deny_all
+        @inherits = true
+        @serve = []
+        @children = {}
+        @file_server = ::Rack::File.new(folder) if parent.nil?
+        dsl_merge_file(read_file) if read_file
+      end
+      
+      ################################################### About installation through DSL
+      
+      # Returns a wawaccess tree for a given folder
+      def self.load_hierarchy(root_folder, parent = nil)
+        raise ArgumentError, "Invalid folder #{root_folder}" unless (root_folder and File.directory?(root_folder))
+
+        # Locate and load the .wawaccess file or provide a default one
+        wawaccess_file = File.join(root_folder, '.wawaccess')
+        if File.exists?(wawaccess_file)
+          wawaccess = WawAccess.new(parent, root_folder, wawaccess_file)
+        else
+          wawaccess = WawAccess.new(parent, root_folder)
+          wawaccess.strategy = :deny_all
+          wawaccess.inherits = true
+        end
+        
+        # Install its children
+        Dir.new(root_folder).each do |file|
+          next if ['.', '..'].include?(file)
+          child_folder = File.join(root_folder, file)
+          next unless File.directory?(child_folder)
+          
+          # Load the child and save it
+          wawaccess.add_child(file, WawAccess.load_hierarchy(child_folder, wawaccess))
+        end
+        wawaccess
+      end
+      
+      ################################################### About installation through DSL
+      
+      def recognized_pattern?(pattern)
+        [FalseClass, TrueClass, String, 
+         Regexp, Waw::Validation::Validator].any?{|c| c===pattern}
+      end
+      
+      # Adds a child in the hierarchy
+      def add_child(folder, wawaccess)
+        @children[folder] = wawaccess
+      end
+      
+      # Installs some pattern services
+      def add_serve(patterns, &block)
+        raise ArgumentError, "WawAccess.add_serve expects a block" unless block 
+        patterns.each do |pattern|
+          raise WawError, "Invalid serving pattern #{pattern} (#{pattern.class})"\
+            unless recognized_pattern?(pattern)
+          @serve << [pattern, block]
+        end
+      end
+      
+      # Merges a DSL string inside this waw access
+      def dsl_merge(dsl_str, read_file=nil)
+        begin
+          dsl = WawAccess::DSL.new(self)
+          dsl.instance_eval(dsl_str)
+        rescue WawError => ex
+          raise WawError, "Corrupted .wawaccess file #{read_file}: #{ex.message}", ex.backtrace
+        rescue Exception => ex
+          raise WawError, "Corrupted .wawaccess file #{read_file}: #{ex.message}", ex.backtrace
+        end
+        self
+      end
+      
+      # Merge with a .wawaccess file
+      def dsl_merge_file(read_file)
+        raise WawError, "Missing .wawaccess file #{readfile}" unless File.file?(read_file)
+        dsl_merge(File.read(read_file), read_file)
+        self
+      end
+      
+      ################################################### Utilites about paths
+      
+      # Returns the real path of a file
+      def realpath(file)
+        File.expand_path(File.join(folder, file))
+      end
+      
+      # Locates the file that would be matched by a given normalized
+      # url.
+      def matching_file(path)
+        File.join(root.folder, path)
+      end
+      
+      # Relativize a path against a given folder
+      def relativize(file, folder = folder)
+        file, folder = File.expand_path(file), File.expand_path(folder)
+        file[(folder.length+1)..-1]
+      end
+      
+      # Helper to locate css and js files
+      def find_files(pattern)
+        Dir[File.join(folder, pattern, "*.#{pattern}")].sort{|f1, f2|
+          File.basename(f1) <=> File.basename(f2)
+        }.collect{|f|
+          File.join(pattern, File.basename(f))
+        }
+      end
+        
+      ################################################### Utilities about the hierarchy
+      
+      # Returns an identifier for this wawaccess
+      def identifier(append = true)
+        if parent
+          parent.identifier(false) + (append ? "#{File.basename(@folder)}/.wawaccess" : File.basename(@folder))
+        else
+          (append ? ".wawaccess" : "")
+        end
+      end
+      
+      # Returns the root waw access in the hierarchy
+      def root
+        @root ||= (parent ? parent.root : self)
+      end
+      
+      # Finds the wawaccess instance for a given url
+      def find_wawaccess_for(url, url_array = url.split('/').reject{|k| k.empty?})
+        if url_array.empty?
+          self
+        else
+          if @children.has_key?(nextfolder = url_array.shift)
+            @children[nextfolder].find_wawaccess_for(url, url_array)
+          else
+            self
+          end
+        end
+      end
+      
+      ################################################### .waw access rules application!
+      
+      # Finds the matching block inside this .wawaccess handler
+      def find_match(path)
+        @serve.each do |pattern, block|
+          case pattern
+            when FalseClass
+            when TrueClass
+              return Match.new(self, path, block)
+            when String
+              if pattern=='*'
+                return Match.new(self, path, block)
+              elsif /^\*?\.[a-z]+$/ =~ pattern
+                return Match.new(self, path, block) if File.extname(realpath(path))==pattern
+              else
+                return Match.new(self, path, block) if File.basename(realpath(path))==pattern
+              end
+            when Regexp
+              if matchdata = pattern.match(path)
+                return Match.new(self, path, block, *matchdata.to_a)
+              end
+            when Waw::Validation::Validator
+              if pattern.validate(matching_file(path))
+                return Match.new(self, path, block) 
+              end
+            else
+              raise WawError, "Unrecognized wawaccess pattern #{pattern}"
+          end
+        end
+        nil
+      end 
+      
+      # Applies the rules defined here or delegate to the parent if allowed
+      def apply_rules(path)
+        if match = find_match(path)
+          match.__execute
+        elsif (parent and inherits)
+          parent.apply_rules(path)
+        else
+          body = "File not found: #{path}\n"
+          [404, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s,
+             "X-Cascade" => "pass"},
+           [body]]
+        end
+      end
+      
+      ################################################### To be called on the tree root only!
+      
+      # Normalizes a requested path, removing any .html, .htm suffix
+      def normalize_req_path(req_path)
+        # 1) Decode the req_path with URI::decode
+        req_path = URI::decode(req_path)
+        # 2) Strip first
+        req_path = req_path.strip
+        # 3) Remove first slash 
+        req_path = req_path[1..-1] if req_path[0,1]=='/'
+        # 4) Remove last slash
+        req_path = req_path[0..-2] if req_path[req_path.length-1,1]=='/'
+        req_path
+      end
+  
+      # Serves a path from a root waw access in the hierarchy
+      def do_path_serve(path)
+        path = normalize_req_path(path)
+        waw_access = (find_wawaccess_for(path) || self)
+        waw_access.apply_rules(path)
+      end
+            
+    end # class WawAccess
+  end # class StaticController
+end # module Waw

data/lib/waw/controllers/static/waw_access_dsl.rb

@@ -0,0 +1,48 @@
+module Waw
+  class StaticController < ::Waw::Controller
+    class WawAccess
+      # Domain specific language for .wawaccess language
+      class DSL
+        include ::Waw::Validation
+        
+        # Creates a new DSL instance
+        def initialize(wawaccess)
+          raise ArgumentError, "wawaccess cannot be nil" unless WawAccess===wawaccess
+          @wawaccess = wawaccess
+        end
+        
+        # Returns a validator that matches the root of the wawaccess tree
+        def root
+          Waw::Validation.validator{|served_file| File.expand_path(served_file) == File.expand_path(@wawaccess.root.folder)}
+        end
+        
+        # Starts a wawaccess file
+        def wawaccess(&block)
+          raise WawError, "#{@wawaccess.identifier}: missing block in wawaccess call" unless block
+          self.instance_eval(&block)
+        end
+        
+        # Installs the default strategy
+        def strategy(which = :unknown)
+          raise WawError, "#{@wawaccess.identifier}: unrecognized wawaccess strategy #{which}" unless [:deny_all, :allow_all].include?(which)
+          @wawaccess.strategy = which
+        end
+        
+        # Installs the inherits strategy
+        def inherits(which = "unknown")
+          raise WawError, "#{@wawaccess.identifier}: unrecognized wawaccess inherits #{which}" unless [true, false].include?(which)
+          @wawaccess.inherits = which
+        end
+        
+        # Serve some patterns
+        def match(*patterns, &block)
+          patterns = patterns.compact
+          raise WawError, "#{@wawaccess.identifier}: missing patterns in wawaccess.match call" if patterns.empty?
+          raise WawError, "#{@wawaccess.identifier}: missing block in wawaccess.match call" if block.nil?
+          @wawaccess.add_serve(patterns, &block)
+        end
+        
+      end
+    end # class WawAccess
+  end # class StaticController
+end # module Waw

data/lib/waw/controllers/static_controller.rb

@@ -0,0 +1,37 @@
+require 'waw/controllers/static/waw_access'
+require 'waw/controllers/static/waw_access_dsl'
+module Waw
+  # 
+  # A waw service that serves public pages expressed in wlang wtpl format
+  #
+  class StaticController < ::Waw::Controller
+  
+    ##############################################################################################
+    ### About service creation and configuration
+    ##############################################################################################
+  
+    # Default options of this service
+    DEFAULT_OPTIONS = {:public => 'public'}
+  
+    # Creates a service instance
+    def initialize(opts = {})
+      @options = DEFAULT_OPTIONS.merge(opts)
+      @wawaccess = ::Waw::StaticController::WawAccess.load_hierarchy(File.join(root_folder, public_folder))
+    end
+  
+    # Returns the template folder
+    def public_folder
+      @options[:public] || @options[:root]
+    end
+  
+    ##############################################################################################
+    ### Main service execution
+    ##############################################################################################
+
+    # Executes the service
+    def execute(env, req, res)
+      @wawaccess.do_path_serve(env['PATH_INFO'])
+    end
+
+  end # class Controller
+end # module Waw

data/lib/waw/default_config.cfg

@@ -0,0 +1,14 @@
+# Logger configuration
+log_dir              'logs'
+log_file             'webapp.log'
+log_frequency        'weekly'
+log_level            Logger::DEBUG
+
+# Web configuration
+web_domain           '127.0.0.1'
+web_port             9292
+web_base             'http://127.0.0.1:9292/'
+
+# About Rack
+rack_session         true
+rack_session_expire  60 * 60 * 24

data/lib/waw/environment_utils.rb

@@ -0,0 +1,57 @@
+module Waw
+  # Provides environment utilities to get the current Rack environment, 
+  # session and so on. Some of these utilities make the assumption that 
+  # a session is installed in some Rack standard way (through Rack::Session::Pool)
+  # for example.
+  module EnvironmentUtils
+    include Waw::ScopeUtils
+    
+    DEPRECATED_MSG = <<-EOF
+      Method ${method_name} is deprecated and will be removed in version 0.3.
+      Please include Waw::ScopeUtils module instead.
+    EOF
+    
+    # Returns the current Rack env instance
+    deprecated DEPRECATED_MSG
+    def env
+      rack_env
+    end
+    
+    # Checks if a session has a given key
+    deprecated <<-EOF
+      Method ${method_name} is deprecated and will be removed in version 0.3.
+      Please include Waw::ScopeUtils module and use session.has_key? instead.
+    EOF
+    def session_has_key?(key)
+      session.has_key?(key)
+    end
+
+    # Sets a pair inside the session. Returns the value.
+    deprecated <<-EOF
+      Method ${method_name} is deprecated and will be removed in version 0.3.
+      Please include Waw::ScopeUtils module and use session.set instead.
+    EOF
+    def session_set(key, value)
+      session[key] = value
+    end
+    
+    # Sets a pair inside the session
+    deprecated <<-EOF
+      Method ${method_name} is deprecated and will be removed in version 0.3.
+      Please include Waw::ScopeUtils module and use session.unset instead.
+    EOF
+    def session_unset(key)
+      session.delete(key)
+    end
+    
+    # Get a value from the current session
+    deprecated <<-EOF
+      Method ${method_name} is deprecated and will be removed in version 0.3.
+      Please include Waw::ScopeUtils module and use session.get instead.
+    EOF
+    def session_get(key)
+      session[key]
+    end
+    
+  end # module EnvironmentUtils
+end # module Waw