waves 0.7.7 → 0.8.0

data/lib/layers/orm/{sequel → providers/sequel}/tasks/generate.rb

@@ -2,8 +2,10 @@ namespace :generate do
   
     desc 'Generate a Sequel model, with name=<name>'
     task :model do |task|
-      name = ENV['name']
-      model_name = name.camel_case
+
+      model_name = ENV['name'].camel_case
+      app_name = ( ENV['app'] || Dir.pwd.split('/').last ).camel_case
+
       raise "Cannot generate Default yet" if model_name == 'Default'
 
       filename = File.expand_path "models/#{name}.rb"
@@ -13,7 +15,7 @@ namespace :generate do
       end
 
       model = <<TEXT
-module #{Waves.application.name}
+module #{app_name}
   module Models
     class #{model_name} < Default
 

data/lib/layers/orm/{sequel → providers/sequel}/tasks/schema.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../migration"
+require "#{File.dirname(__FILE__)}/../../../migration"
 
 namespace :schema do
 
@@ -10,7 +10,7 @@ namespace :schema do
   desc "Performs Sequel migrations to version=<version>"
   task :migrate do |task|
     version = ENV['version']; version = version.to_i unless version.nil?
-    Sequel::Migrator.apply( Waves.application.database, Waves::Layers::ORM.migration_directory , version )
+    Sequel::Migrator.apply( Waves.main.database, Waves::Layers::ORM.migration_directory , version )
   end
 
 end

data/lib/{renderers → layers/renderers}/erubis.rb

@@ -5,10 +5,6 @@ module Erubis # :nodoc:
   # This is added to the Erubis Content class to allow the same helper methods
   # to be used with both Markaby and Erubis.
   class Context
-    include Waves::Helpers::UrlHelper
-    include Waves::Helpers::TagHelper
-    include Waves::Helpers::AssetHelper
-    include Waves::Helpers::NumberHelper
     
     def <<(s) 
       eval("_buf", @binding).concat s # add to rendered output
@@ -34,15 +30,15 @@ module Erubis # :nodoc:
 end
 
 module Waves
-
+  
   module Renderers
 
-    class Erubis
-
-      include Renderers::Mixin
-
-      extension :erb
-
+    module Erubis
+      
+      Extension = :erb
+      
+      extend Waves::Renderers::Mixin
+      
       def self.render( path, assigns )
         eruby = ::Erubis::Eruby.new( template( path ) )
         helper = helper( path )
@@ -56,8 +52,9 @@ module Waves
         context.render(eruby)
       end
 
-    end
 
+    end
+  
   end
 
-end
+end

data/lib/{renderers → layers/renderers}/haml.rb

@@ -1,32 +1,15 @@
 require 'haml'
 
 module Waves
-
+  
   module Renderers
 
-    class Scope
-      include Waves::Helpers::Common
-      include Waves::Helpers::Model
-      include Waves::Helpers::TagHelper
-      include Waves::Helpers::UrlHelper
-      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
-
-    class Haml
-
-      include Renderers::Mixin
-
-      extension :haml
-
+    module Haml
+      
+      Extension = :haml
+      
+      extend Waves::Renderers::Mixin
+      
       def self.render( path, assigns )
         engine = ::Haml::Engine.new( template( path ) )
         scope = Scope.new
@@ -37,9 +20,28 @@ module Waves
         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
 
-    end
+        def capture(&block)
+          capture_haml(nil, &block)
+        end
+
+      end
 
+    end
+  
   end
 
 end
+
+
+

data/lib/layers/renderers/markaby.rb

@@ -0,0 +1,29 @@
+module Waves
+  
+  module Renderers
+
+    module Markaby
+      
+      Extension = :mab
+      
+      extend Waves::Renderers::Mixin
+      
+      def self.included( app )
+        require 'markaby'
+        ::Markaby::Builder.set( :indent, 2 )
+        super
+      end
+      
+      def self.render( path, assigns )
+        builder = ::Markaby::Builder.new( assigns )
+        helper = helper( path )
+        builder.meta_eval { include( helper ) }
+        builder.instance_eval( template( path ) )
+        builder.to_s
+      end
+
+    end
+  
+  end
+
+end

data/lib/matchers/accept.rb

@@ -0,0 +1,21 @@
+module Waves
+
+  module Matchers
+
+    class Accept < Base
+      
+      def initialize( options )
+        @constraints = {
+          :accept => options[ :accept ],
+          :lang => options[ :lang ],
+          :charset => options[ :charset ]
+        }
+      end
+    
+      def call( request ) ; test( request ) ; end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/base.rb

@@ -0,0 +1,30 @@
+module Waves
+
+  module Matchers
+
+    class Base
+      
+      attr_accessor :constraints
+      
+      def []( *args ) ; call( *args ) ; end
+      
+      # used to provide consisting matching logic across all matchers
+      def test( request )
+        constraints.all? do | 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
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/content_type.rb

@@ -0,0 +1,17 @@
+module Waves
+
+  module Matchers
+
+    class ContentType < Base
+      
+      def initialize( content_type ) ; @constraints = { :content_type => content_type } ; end
+    
+      # we could maybe do something more sophisticated here, matching against content type patterns
+      # such */html or */xml, etc.; adapt from the matching done on accepts ... ?
+      def call( request ) ; test( request ) ; end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/path.rb

@@ -0,0 +1,67 @@
+module Waves
+
+  module Matchers
+    
+    class Path < Base
+      
+      # Takes an array of pattern elements ... coming soon, support for formatted strings!
+      def initialize( pattern ) ; @pattern = pattern  ; end
+      
+      def call( request )
+        return {} if @pattern == true or @pattern == false or @pattern.nil?
+        path = extract_path( request ).reverse
+        return {} if ( path.empty? and @pattern.empty? )
+        capture = {}
+        match =  @pattern.all? do | want |
+          case want
+          when true # means 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?
+      end
+
+      private 
+
+      # just a little helper method
+      def extract_path( request )
+        path = request.traits.waves.path
+        return path if path
+        path = request.path.split('/')
+        path.shift unless path.empty?
+        request.traits.waves.path = path
+      end
+
+    end
+    
+    
+  end
+
+end

data/lib/matchers/query.rb

@@ -0,0 +1,21 @@
+module Waves
+
+  module Matchers
+
+    class Query < Base
+      
+      def initialize( pattern ) ; @pattern = ( pattern or {} ) ; end
+    
+      def call( request )
+        @pattern.all? do | key, val |
+          key = key.to_s
+          ( ( val.respond_to?(:call) and val.call( request.query[ key ] ) ) or 
+            ( request.query[ key ] and ( ( val == true ) or ( val === request.query[ key ] ) ) ) )
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/request.rb

@@ -0,0 +1,27 @@
+module Waves
+
+  module Matchers
+
+    class Request < Base
+      
+      def initialize( options )
+        @uri = Matchers::URI.new( options )
+        @constraints = {
+          :content_type => Matchers::ContentType.new( options[ :content_type ] ),
+          :accept => Matchers::Accept.new( options ),
+          :query => Matchers::Query.new( options[:query] ),
+          :traits => Matchers::Traits.new( options[:traits] )
+        }
+      end
+
+      def call( request )
+        if test( request ) and captured = @uri[ request ]
+          request.traits.waves.captured = captured
+        end
+      end
+          
+    end
+    
+  end
+  
+end

data/lib/matchers/resource.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Resource
+      
+      def initialize( options )
+        @matcher = Waves::Matchers::Request.new( options )
+      end
+
+      def call( resource ) ; @matcher.call( resource.request ) ; end
+      def []( *args ) ; call( *args ) ; end
+      
+          
+    end
+    
+  end
+  
+end

data/lib/matchers/traits.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Traits < Base
+      
+      def initialize( pattern ) ; @pattern = ( pattern or {} ) ; end
+    
+      def call( request )
+        @pattern.all? do | key, val |
+          ( val.is_a? Proc and val.call( request.traits[ key ] ) ) or val === request.traits[ key ]
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/uri.rb

@@ -0,0 +1,20 @@
+module Waves
+
+  module Matchers
+
+    class URI < Base
+      
+      def initialize( options )
+        @path = Waves::Matchers::Path.new( options[ :path ] )
+        @constraints = { :server => options[ :server ], :scheme => options[ :scheme ] }
+      end
+    
+      def call( request )
+        @path.call( request ) if test( request )
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/renderers/mixin.rb

@@ -6,42 +6,28 @@ module Waves
     # Just include this in your Renderer class and write your render method.
     module Mixin
 
-      # Adds the following methods to the target class:
-      #
-      # - extension: allows you to set or get the extension used by this renderer.
-      #
-      #     Renderers::Markaby.extension 'foo' # tell Waves to use .foo as Markaby extension
+      # Adds the following methods to the mod class:
       #
       # - filename: generate a filename for the template based on a logical path.
       # - template: read the template from the file corresponding to the given logical path.
       # - helper: return a helper module that corresponds to the given logical path.
       #
-      def self.included(target)
-        class << target
-
-          def extension(*args)
-            return @extension if args.length == 0
-            @extension = args.first
-          end
-
-          def filename(path)
-            :templates / "#{path}.#{self.extension}"
-          end
-
-          def render(path,args=nil)
-          end
-
-          def template( path )
-            File.read( filename( path ) )
-          end
-
-          def helper( path )
-            Waves.application.helpers[
-              File.basename( File.dirname( path ) ).camel_case ]
-          end
-        end
+
+      def included( app )
+        Waves::Views.renderers << self
+      end
+
+      def filename(path)
+        "#{path}.#{self::Extension}"
+      end
+
+      def template( path )
+        File.read( filename( path ) )
       end
 
+      def helper( path )
+        Waves.main[ :helpers ][ File.basename( File.dirname( path ) ).camel_case ]
+      end
 
     end