dyoder-waves 0.7.7 → 0.8.0

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

@@ -1,16 +1,11 @@
-gem 'sequel', '>= 2.0.0'
-require 'sequel'
-require "#{File.dirname(__FILE__)}/sequel/tasks/schema" if defined?(Rake)
-require "#{File.dirname(__FILE__)}/sequel/tasks/generate" if defined?(Rake)
-
 module Waves
   module Layers
     module ORM # :nodoc:
       
-      # Sets up the Sequel connection and configures AutoCode on Models, so that constants in that
-      # namespace get loaded from file or created as subclasses of Models::Default
+      # The Sequel ORM layer sets up the Sequel connection and configures AutoCode on Models, so that constants in that
+      # namespace get loaded from file or created as subclasses of Models::Default.  The dataset for models is set to the
+      # snakecased version of the model's class name.
       module Sequel
-
         # On inclusion, this module:
         # - creates on the application module a database method that establishes the Sequel connection
         # - arranges for autoloading/autocreation of missing constants in the Models namespace
@@ -23,9 +18,16 @@ module Waves
         # - delete(name)
         # - update(name)
         #
+        
+        
         def self.included(app)
           
-          def app.database ; @sequel ||= ::Sequel.open( config.database ) ; end
+          gem 'sequel', '>= 2.0.0'
+          require 'sequel'
+          require "#{File.dirname(__FILE__)}/sequel/tasks/schema" if defined?(Rake)
+          require "#{File.dirname(__FILE__)}/sequel/tasks/generate" if defined?(Rake)
+          
+          def app.database ; @sequel ||= ::Sequel.open( Waves.config.database ) ; end
                       
           app.auto_create_module( :Models ) do
             include AutoCode
@@ -44,7 +46,9 @@ module Waves
               if @dataset && @dataset.opts[:from] != [ default ]
                 # don't clobber dataset from autoloaded file
               else
-                set_dataset Waves.application.database[ basename.snake_case.pluralize.intern ]
+                if respond_to? :set_dataset
+                  set_dataset Waves.main.database[ basename.snake_case.pluralize.intern ]
+                end
               end
             end
           end
@@ -66,7 +70,7 @@ module Waves
           end
           
           def create
-            model.create( attributes )
+            model.create( attributes.to_hash )
           end
           
           def delete( name )
@@ -75,7 +79,7 @@ module Waves
           
           def update( name )
             instance = find( name )
-            instance.update_with_params( attributes )
+            instance.update_with_params( attributes.to_hash )
             instance
           end
         end

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/layers/renderers/haml.rb

@@ -0,0 +1,47 @@
+require 'haml'
+
+module Waves
+  
+  module Renderers
+
+    module Haml
+      
+      Extension = :haml
+      
+      extend Waves::Renderers::Mixin
+      
+      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/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