waves 0.8.2 → 0.9.0

data/lib/waves/layers/rack/rack_cache.rb

@@ -0,0 +1,32 @@
+require 'rack/cache'
+
+module Waves
+
+  module Cache
+
+    module RackCache
+
+      def self.included(app)
+
+        #registering the default configuration for rack-cache
+          app.application.use Rack::Cache,
+            #set cache related options
+            :verbose => true,
+            # default_ttl will be add to any cacheable response without explicit indication of max-age.
+            # set :default_ttl, 60 * 60 * 24
+            # store can be heap, memcache or disk. Default option is heap.
+            #set :metastore,   'file:/var/cache/rack/meta'
+            :entitystore => 'file:./cache/rack/body',
+            # request containing 'Authorization' and 'Cookie' headers are defined 'private' and thus not cacheable.
+            # overriding the private_headers will define which headers make the request not cacheable.
+            # instead of overriding this config, you may choose to use the header 'Vary' in your application.
+            :private_headers => ['Authorization']
+          #end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/waves/layers/renderers/erubis.rb

@@ -0,0 +1,52 @@
+require 'erubis'
+
+module Waves
+
+  module Renderers
+
+    module Erubis
+
+      Extension = :erb
+
+      # extend Waves::Renderers::Mixin
+
+      def self.included( app )
+        Waves::Views.renderers << self
+        app.auto_eval :Views do
+          auto_eval true do
+            include ViewMethods
+          end
+        end
+      end
+
+      # def self.render( path, assigns={} )
+      #   eruby = ::Erubis::Eruby.new( template( path ) )
+      #   helper = helper( path )
+      #   context = ::Erubis::Context.new( assigns )
+      #   ( class << context ; self ; end ).module_eval do
+      #     include( helper )
+      #     def << (s) ; s ; end
+      #   end
+      #   eruby.evaluate( context )
+      # end
+
+      module ViewMethods
+
+        def erb(string, assigns={})
+          eruby = ::Erubis::Eruby.new( string )
+          helper = Waves.main::Helpers[self.class.basename]
+          context = ::Erubis::Context.new( assigns )
+          ( class << context ; self ; end ).module_eval do
+            include( helper )
+            def << (s) ; s ; end
+          end
+          eruby.evaluate( context )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/waves/layers/renderers/haml.rb

@@ -0,0 +1,67 @@
+require 'haml'
+
+module Waves
+
+  module Renderers
+
+    module Haml
+
+      Extension = :haml
+
+      # extend Waves::Renderers::Mixin
+
+      def self.included(app)
+        Waves::Views.renderers << self
+        Waves::Views::Base.send(:include, self::ViewMethods)
+      end
+
+      module ViewMethods
+
+        def haml(string, assigns={})
+          engine = ::Haml::Engine.new( string )
+          scope = Scope.new
+          helper = Waves.main::Helpers[self.class.basename]
+          scope.meta_eval { include( helper ) }
+          scope.instance_eval do
+            assigns.each { |key,val| instance_variable_set("@#{key}",val) unless key == :request }
+          end
+          engine.render(scope, assigns)
+        end
+
+      end
+
+      # def self.render( path, assigns )
+      #   engine = ::Haml::Engine.new( template( path ) )
+      #   scope = Scope.new
+      #   helper = helper( path )
+      #   scope.meta_eval { include( helper ) }
+      #   scope.instance_eval do
+      #     assigns.each { |key,val| instance_variable_set("@#{key}",val) unless key == :request }
+      #   end
+      #   engine.render(scope, assigns)
+      # end
+
+      class Scope
+        include Waves::Helpers::DocType
+        include Waves::Helpers::Layouts
+        include Waves::Helpers::Model
+        include Waves::Helpers::View
+
+        def <<(s)
+          eval("@haml_buffer", @binding).push_text s # add to rendered output
+        end
+
+        def capture(&block)
+          capture_haml(nil, &block)
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/lib/waves/layers/renderers/markaby.rb

@@ -0,0 +1,41 @@
+module Waves
+  
+  module Renderers
+
+    module Markaby
+      
+      Extension = :mab
+      
+      # extend Waves::Renderers::Mixin
+      
+      def self.included( app )
+        require 'markaby'
+        ::Markaby::Builder.set( :indent, 2 )
+        Waves::Views.renderers << self
+        # Waves::Views::Base.send(:include, self::ViewMethods)
+        app.auto_eval :Views do
+          auto_eval :Default do
+            include ViewMethods
+          end
+        end
+      end
+      
+      module ViewMethods
+        
+        def mab(string, assigns={})
+          builder = ::Markaby::Builder.new( assigns )
+          helper = Waves.main::Helpers[self.class.basename]
+          builder.meta_eval { include( helper ) }
+          builder.instance_eval( string )
+          builder.to_s
+        end
+        
+      end
+      
+
+
+    end
+  
+  end
+
+end

data/lib/waves/layers/text/inflect/english.rb

@@ -0,0 +1,42 @@
+module Waves
+  module Layers
+    module Text
+      module Inflect
+      
+        # Adds plural/singular methods for English to String
+        module English
+        
+          def self.included(app)
+          
+            require 'english/inflect'
+                    
+            Waves::Resources::Mixin::ClassMethods.module_eval do
+              def singular ; basename.snake_case.singular ; end
+              def plural ; basename.snake_case.plural ; end
+            end
+            
+            Waves::ResponseMixin.module_eval do
+              def singular ; self.class.basename.snake_case.singular ; end
+              def plural ; self.class.basename.snake_case.plural ; end
+            end
+
+            Waves::Resources::Mixin.module_eval do
+              def singular ; self.class.singular ; end
+              def plural ; self.class.plural ; end
+            end
+          
+            Waves::Resources::Paths.module_eval do
+              def resource ; self.class.resource.singular ; end
+              def resources ; self.class.resource.plural ; end
+            end
+          
+          end
+        
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/waves/matchers/accept.rb

@@ -0,0 +1,47 @@
+module Waves
+  module Matchers
+
+    # @todo Rename to Negotiation? --rue
+    #
+    class Accept
+
+      # Set up Accept parsing.
+      #
+      # Only the defined constraints are included.
+      #
+      def initialize(options)
+        
+        @constraints = {}
+        
+        { :accept => :accept, :charset => :accept_charset, :lang => :accept_lang }.each { |key,method|
+          if options[key]
+            if options[key].is_a? Array
+              @constraints[method] = options[key] unless options[key].empty?
+            else
+              @constraints[method] = [ options[key] ]
+            end
+          end
+        }
+        
+      end
+
+      # Verify that any and all Accept constraints match.
+      #
+      # Request handles these.
+      #
+      def call(request)
+        @constraints.all? { |key, val| request.send(key).include? val }
+      end
+      
+      # Proc-like interface
+      #
+      def [](request)
+        call request
+      end
+      
+
+    end
+
+  end
+
+end

data/lib/waves/matchers/ext.rb

@@ -0,0 +1,27 @@
+module Waves
+  module Matchers
+
+    class Ext
+      
+      def initialize( ext )
+        @ext = ext
+      end
+
+      def call(request)
+        test( request.extension, @ext )
+      end
+      
+      def test( val, pat )
+        case pat
+        when false then val.nil?
+        when true, '.*', val then true
+        when Symbol, Symbol then val == ".#{pat}"
+        when Array then pat.any? { |e| test( val, e ) }
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/waves/matchers/path.rb

@@ -0,0 +1,72 @@
+module Waves
+
+  module Matchers
+
+    class Path
+      
+      # Takes an array of pattern elements ... coming soon, support for formatted strings!
+      #
+      # Empty Array means no path, but nil is not processed.
+      #
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      # returns a hash of captured values
+      def call( request )
+        if @pattern.is_a? Array
+          path = extract_path( request ).reverse
+          return {} if @pattern.empty? && path.empty?
+          capture = {}
+          match = @pattern.all? do | want |
+            case want
+            when true # same as a Range of 1..-1
+              path = [] unless path.empty?
+            when Range
+              if want.end == -1
+                path = [] if path.length >= want.begin
+              else
+                path = [] if want.include? path.length
+              end
+            when String then want == path.pop
+            when Symbol then capture[ want ] = path.pop
+            when Regexp then want === path.pop
+            when Hash
+              key, value = want.to_a.first
+              case value
+              when true
+                ( capture[ key ], path = path.reverse, [] ) unless path.empty?
+              when Range
+                if value.end == -1
+                  ( capture[ key ], path = path.reverse, [] ) if path.length >= value.begin
+                else
+                  ( capture[ key ], path = path.reverse, [] ) if value.include? path.length
+                end
+              when String, Symbol
+                got = path.pop
+                capture[ key ] = got ? got : value.to_s
+              when Regexp then
+                got = path.pop
+                capture[ key ] = got if value === got
+              end
+            end
+          end
+          capture if match && path.empty?
+        elsif @pattern == true or @pattern == false or @pattern == nil
+          {}
+        end
+      end
+
+      # private
+
+      # just a little helper method
+      def extract_path( request )
+        request.traits.waves.path ||= request.path.chomp(request.ext).scan(/[^\/]+/).map { |e| Rack::Utils.unescape(e) }
+      end
+
+    end
+
+
+  end
+
+end

data/lib/waves/matchers/query.rb

@@ -0,0 +1,43 @@
+module Waves
+
+  module Matchers
+
+    # Query parameter matching.
+    #
+    class Query
+
+      # Create query matcher or fail.
+      #
+      # @todo Should map Symbols to Strings here. --rue
+      #
+      def initialize(pattern)
+        raise ArgumentError, "No Query constraints!" unless pattern
+        @pattern = pattern
+      end
+
+      # Match query parameters.
+      #
+      def call(request)
+        @pattern.all? {|key, val|
+          # @todo Is this right? I do not see how even a
+          #       Proc would be useful just given nil from
+          #       a nonexisting key. We just fail in those
+          #       cases for now. --rue
+          if given = request.query[key.to_s]
+            val == true or val === given or (val.call(given) rescue false)
+          end
+        }
+      end
+      
+      # Proc-like interface
+      #
+      def [](request)
+        call request
+      end
+      
+
+    end
+
+  end
+
+end

data/lib/waves/matchers/request.rb

@@ -0,0 +1,86 @@
+module Waves
+  module Matchers
+
+    class Request
+
+      attr_accessor :constraints
+
+
+      #
+      # @todo Further optimise the cases where there are no
+      #       constraints. --rue
+      #
+
+      def initialize(options)
+        
+        @uri = Matchers::URI.new( options )
+
+        @constraints = {}
+
+        if options[ :requested ]
+          @constraints[ :requested ] = Matchers::Requested.new( options[ :requested ] )
+        end
+        
+        if options.key?( :accept ) || options.key?( :lang ) || options.key?( :charset )
+          @constraints[:accept] = Matchers::Accept.new( options ) 
+        end
+        
+        if options.key?( :ext )
+          @constraints[ :ext ] = Matchers::Ext.new(  options[ :ext ] )
+        elsif options.key?( :extension )
+          @constraints[ :ext ] = Matchers::Ext.new(  options[ :extension ] )
+        end
+        
+        if options.key?( :query )
+          @constraints[:query] = Matchers::Query.new( options[:query] ) 
+        end
+          
+        if options[ :traits ]
+          @constraints[ :traits ] = Matchers::Traits.new( options[ :traits ] )
+        end
+          
+        if options[ :when ]
+          @constraints[ :when ] = options[ :when ]
+        end
+        
+      end
+
+      # Process all matchers for request.
+      #
+      def call(request)
+        if captured = @uri.call(request) and test(request)
+          request.traits.waves.captured = captured
+        end
+      end
+      
+      #
+      # @todo This could maybe be optimised by detecting
+      #       empty constraints before calling. Not high
+      #       importance. --rue
+      #
+      def test(request)
+        constraints.all? {|key, val|
+          if val.nil? or val == true
+            true
+          else
+            if val.respond_to? :call
+              val.call( request )
+            else
+              val == request.send( key ) or val === request.send( key ) or request.send( key ) === val
+            end
+          end
+        }
+      end
+      
+
+      # Proc-like interface
+      #
+      def [](request)
+        call request
+      end
+      
+    end
+
+  end
+
+end