waw 0.2.2

data/lib/waw/errors.rb

@@ -0,0 +1,4 @@
+module Waw
+  class WawError < StandardError; end
+  class ConfigurationError < WawError; end
+end

data/lib/waw/ext.rb

@@ -0,0 +1,3 @@
+require 'waw/ext/core'
+require 'waw/ext/rack'
+require 'waw/ext/wlang'

data/lib/waw/ext/core.rb

@@ -0,0 +1,4 @@
+require 'waw/ext/core/object'
+require 'waw/ext/core/module'
+require 'waw/ext/core/hash'
+require 'waw/ext/core/logger'

data/lib/waw/ext/core/hash.rb

@@ -0,0 +1,47 @@
+class Hash
+
+  def keep!(*keys)
+    self.delete_if{|k,v| !keys.flatten.include?(k)}
+  end
+
+  def keep(*keys)
+    self.dup.delete_if{|k,v| !keys.flatten.include?(k)}
+  end
+
+  def forget!(*keys)
+    self.delete_if{|k,v| keys.flatten.include?(k)}
+  end
+
+  def forget(*keys)
+    self.dup.delete_if{|k,v| keys.flatten.include?(k)}
+  end
+
+  def symbolize_keys
+    copy = Hash.new
+    self.each_pair {|k,v| copy[k.to_s.to_sym] = v}
+    copy
+  end
+  
+  def methodize
+    copy = self.symbolize_keys
+    keys.each {|key| 
+      copy.instance_eval <<-EOF
+        def #{key}
+          self[:"#{key}"]
+        end
+      EOF
+    }
+    copy
+  end
+
+  def unsymbolize_keys
+    copy = Hash.new
+    self.each_pair {|k,v| copy[k.to_s] = v}
+    copy
+  end
+
+  def to_url_query
+    ::Rack::Utils.build_query(self)
+  end
+
+end

data/lib/waw/ext/core/logger.rb

@@ -0,0 +1,10 @@
+require 'logger'
+
+class Logger
+  
+  def write(*args)
+    info(*args)
+  end
+  
+end
+

data/lib/waw/ext/core/module.rb

@@ -0,0 +1,20 @@
+class Module
+  
+  def deprecated(msg = "The method ${method_name} is deprecated")
+    @deprecated = msg
+  end
+  
+  # If a signature has been installed, let the next added method
+  # become an action
+  def method_added(name)
+    if @deprecated
+      deprecated, @deprecated = @deprecated.gsub(/#{Regexp.escape('${method_name}')}/, "#{self.name}.#{name}"), nil
+      method = instance_method(name)
+      define_method name do |*args|
+        $waw_deprecated_io << deprecated << " (#{caller[0]})\n" if $waw_deprecated_io
+        method.bind(self).call(*args)
+      end 
+    end
+  end
+
+end

data/lib/waw/ext/core/object.rb

@@ -0,0 +1,29 @@
+class Object
+  # From active_support 2.3.4
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/waw/ext/rack.rb

@@ -0,0 +1,19 @@
+# Force some auto loading ...
+require 'rubygems'
+require 'rack'
+::Rack::Session::Pool
+
+# Let the delegator be known
+require 'waw/ext/rack/delegator'
+
+# Install the delegator on all standard Rack applications
+[::Rack::Builder, ::Rack::Session::Abstract::ID, ::Rack::CommonLogger,
+ ::Rack::ShowExceptions, ::Rack::Static, ::Rack::URLMap, ::Rack::Reloader].each do |rack_app|
+   rack_app.instance_eval <<-EOF
+     include ::Rack::Delegator
+   EOF
+end
+
+# Makes overrides now
+require 'waw/ext/rack/builder.rb'
+require 'waw/ext/rack/urlmap.rb'

data/lib/waw/ext/rack/builder.rb

@@ -0,0 +1,43 @@
+module Rack
+  class Builder
+    
+    #
+    # Adds or push an error handler on top of the application chain.
+    #
+    # The method accepts the following argument variants:
+    #
+    #   error_handler{|k,ex| ... }
+    #   error_handler(SomeValidator){|k,ex| ... }
+    #   error_handler(SomeHandler)
+    #   error_handler(SomeValidator, SomeHandler)
+    #
+    def error_handler(*args, &block)
+      @ins << lambda{|app| 
+        if ::Waw::ErrorHandler === app
+          app.unshift(*args, &block)
+          app
+        else
+          handler = ::Waw::ErrorHandler.new(app)
+          handler.push(*args, &block)
+          handler
+        end
+      }
+    end
+    
+    #
+    # The to_app method works as follows:
+    #
+    #   error_handler(args_1) -> 
+    #   error_handler(args_2) -> 
+    #   use X  -> lambda{|app| X.new(app)}
+    #   use Y  -> lambda{|app| Y.new(app)}
+    #   run Z  -> Z
+    #
+    # which leads to a memo call on the @ins array
+    #   Y_instance = lambdaY.call(Z)
+    #   X_instance = lambdaX.call(Y_instance)
+    #   ...
+    #   
+    
+  end # module Builder
+end # module Rack

data/lib/waw/ext/rack/delegator.rb

@@ -0,0 +1,51 @@
+module Rack
+  # Extends Rack application with utilities. This module may be included
+  # by standard rack applications delegating to another one. The later is
+  # expected to be returned by delegate. Methods are intended to be 
+  # overriden for matching specific situations.
+  module Delegator
+
+    # Returns delegate rack application. By default, returns @app.
+    def delegate
+      @app
+    end
+    
+    # Checks if an app may be safely considered in the chain
+    def is_delegate?(app)
+      Delegator===app
+    end
+    
+    # Checks if a delegate exists.
+    def has_delegate?
+      not(delegate.nil?) and is_delegate?(delegate)
+    end
+
+    # Finds a rack application mapped to a given path. If a block is 
+    # provided it is used as a predicate matcher.
+    def find_rack_app(path = nil, &block)
+      return self if (block && block.call(self))
+      has_delegate? ? delegate.find_rack_app(path, &block) : nil
+    end
+    
+    # Recursively finds the URL on which a given application is installed.
+    def find_url_of(app)
+      visit{|path, visited| return path if app==visited}
+      nil
+    end
+    
+    # Visits the Rack application tree recursively by calling the block.
+    # The later is expected to have two parameters |path,app|. The first
+    # one is an array containing url components, the second is the 
+    # visited application.
+    def visit(&block)
+      _visit("/", block)
+    end
+    
+    # Internal implementation of visit.
+    def _visit(path, block)
+      block.call(path, self)
+      delegate._visit(path, block) if has_delegate?
+    end
+    
+  end # module Delegator
+end # module Rack

data/lib/waw/ext/rack/urlmap.rb

@@ -0,0 +1,55 @@
+module Rack
+  
+  # Some overridings of Delegator
+  class URLMap
+    
+    # Overrides Delegator.find_rack_app
+    def find_rack_app(path = nil, &block)
+      return self if (block && block.call(self))
+      the_app, the_rest = nil, nil
+      if path.nil?
+        @mapping.each do |host, location, match, app|
+          if is_delegate?(app) 
+            found = app.find_rack_app(path, &block)
+            return found if found
+          end
+        end
+        return nil
+      else
+        @mapping.each do |host, location, match, app|
+          next unless path =~ match && rest = $1
+          next unless rest.empty? || rest[0] == ?/
+          the_app, the_rest = app, rest
+          break
+        end
+        if the_app
+          # we've found one
+          if the_rest.empty? or the_rest=='/'
+            block ? the_app.find_rack_app(nil, &block) : the_app
+          else
+            the_app.find_rack_app(the_rest, &block)
+          end
+        else
+          nil
+        end
+      end
+    end
+    
+    # Overrides Delegator._visit
+    def _visit(path, block)
+      block.call(path, self)
+      @mapping.each do |host, location, match, app|
+        # seems required on some configurations where rack does not acts
+        # as expected (3 arguments and not 4)
+        app = match if app.nil? 
+        unless is_delegate?(app)
+          Waw.logger.warn("We found a rack application which is not a delegator on #{path}: #{app.inspect}!")
+          next 
+        end
+        app._visit((location.to_s.empty? ? path : path.chomp('/') + location.to_s), block)
+      end
+    end
+
+  end # class URLMap  
+
+end # module Rack

data/lib/waw/ext/wlang.rb

@@ -0,0 +1 @@
+require 'waw/ext/wlang/hosted_language'

data/lib/waw/ext/wlang/hosted_language.rb

@@ -0,0 +1,21 @@
+module WLang
+  class HostedLanguage
+    include ::Waw::ScopeUtils
+    
+    # 
+    # Overrides the original version that always raises an UndefinedVariableError 
+    # to put waw scoping utilities as low-level variables in all wlang scopes as
+    # well as installed resources.
+    #
+    def variable_missing(name)
+      if self.respond_to?(name)
+        self.send(name)
+      elsif resources && resources.has_resource?(name)
+        resources[name]
+      else
+        raise ::WLang::UndefinedVariableError.new(nil, nil, nil, name)
+      end
+    end
+    
+  end # class HostedLanguage
+end # module WLang

data/lib/waw/fullstate.rb

@@ -0,0 +1,8 @@
+require 'waw/fullstate/on_instance'
+require 'waw/fullstate/on_class'
+require 'waw/fullstate/variable'
+module Waw
+  module FullState
+    
+  end
+end

data/lib/waw/fullstate/on_class.rb

@@ -0,0 +1,37 @@
+module Waw
+  module FullState
+    # Provides the introspection methods for installing fullstate
+    # utilities on classes.
+    module OnClass
+            
+      # Returns the class full state variables
+      def __full_state_variables
+        @__full_state_variables ||= {}
+      end
+            
+      # Installs a friendly session variable on the controller
+      def session_var(name, default_value=nil, &block)
+        __full_state_variables[name] = Waw::FullState::Variable.new(name, default_value, &block)
+        instance_eval <<-EOF
+          class << self
+            def #{name}
+              __full_state_variables[:#{name}].value(self)
+            end
+            def #{name}=(arg)
+              __full_state_variables[:#{name}].value = arg
+            end
+            def reset(varname)
+              __full_state_variables[varname].reset
+            end
+          end
+        EOF
+      end
+      
+      # Installs a query variable with a given block
+      def query_var(name, &block)
+        session_var(name, nil, &block)
+      end
+      
+    end # module OnClasses
+  end # module FullState
+end # module Waw

data/lib/waw/fullstate/on_instance.rb

@@ -0,0 +1,27 @@
+module Waw
+  module FullState
+    # Provides the introspection methods for installing fullstate
+    # utilities on instances.
+    module OnInstance
+      
+      # Installs a friendly session variable on the controller
+      def session_var(name, default_value=nil, &block)
+        var = Waw::FullState::Variable.new(name, default_value, &block)
+        define_method name do
+          var.value(self)
+        end
+        define_method :"#{name}=" do |arg|
+          var.value = arg
+        end
+      rescue ArgumentError => ex
+        raise ex, ex.message, ex.backtrace[1..-1]
+      end
+      
+      # Installs a query variable with a given block
+      def query_var(name, &block)
+        session_var(name, nil, &block)
+      end
+      
+    end # module OnInstances
+  end # module FullState
+end # module Waw

data/lib/waw/fullstate/variable.rb

@@ -0,0 +1,36 @@
+module Waw
+  module FullState
+    class Variable
+      include Waw::ScopeUtils
+      
+      # Creates a variable instance with a default value
+      def initialize(name, default_value = nil, &block)
+        raise ArgumentError, "Waw variables accept a default value or a block, but not both"\
+          unless default_value.nil? or block.nil?
+        @name, @default_value = name, (block ? block : default_value)
+      end
+      
+      # Resets to the default value
+      def reset
+        session.unset(@name)
+      end
+      
+      # Returns the current value of the variable
+      def value(*args)
+        if session.has_key?(@name)
+          session.get(@name)
+        elsif @default_value.is_a?(Proc)
+          @default_value.call(*args)
+        else
+          @default_value
+        end
+      end
+      
+      # Sets the value of the variable
+      def value=(val)
+        session.set(@name, val)
+      end
+      
+    end # class Variable
+  end # module FullState
+end # module Waw

data/lib/waw/kern.rb

@@ -0,0 +1,6 @@
+require 'waw/kern/freezed_state'
+require 'waw/kern/living_state'
+require 'waw/kern/hooks'
+require 'waw/kern/lifecycle'
+require 'waw/kern/utils'
+require 'waw/kern/app'