waves-edge 2009.03.10.13.14

data/lib/layers/orm/providers/active_record/tasks/generate.rb

@@ -0,0 +1,28 @@
+namespace :generate do
+  
+    desc 'Generate an ActiveRecord model, with name=<name>'
+    task :model do |task|
+      name = ENV['name']
+      model_name = name.camel_case
+      raise "Cannot generate Default yet" if model_name == 'Default'
+
+      filename = File.expand_path "models/#{model_name}.rb"
+      if File.exist?(filename)
+        $stderr.puts "#{filename} already exists" 
+        exit
+      end
+
+      model = <<TEXT
+module #{app_name}
+  module Models
+    class #{model_name} < Default
+
+    end
+  end
+end
+TEXT
+
+      File.write( filename, model )
+    end
+  
+end

data/lib/layers/orm/providers/active_record/tasks/schema.rb

@@ -0,0 +1,22 @@
+require "#{File.dirname(__FILE__)}/../../../migration"
+
+namespace :schema do
+
+  desc "Create ActiveRecord migration with name=<name>"
+  task :migration do |task|
+    Waves::Layers::ORM.create_migration_for(ActiveRecord)
+  end
+
+  desc "Performs ActiveRecord migrations to version=<version>"
+  task :migrate => :connect do |task|
+    version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+    ActiveRecord::Migrator.migrate(Waves::Layers::ORM.migration_directory, version)
+  end
+
+  task :connect do
+    Waves.main.database
+    ActiveRecord::Base.logger = Logger.new($stdout)
+  end
+
+end
+

data/lib/layers/orm/providers/data_mapper.rb

@@ -0,0 +1,37 @@
+module Waves
+  module Layers
+    module ORM
+      
+      # Work in Progress
+      module DataMapper
+        
+        def self.included(app)
+          gem 'dm-core', '=0.9.0'
+
+          require 'data_mapper'
+          
+          def app.database
+            @adapter ||= ::DataMapper.setup(:main_repository, config.database[:database])
+          end
+          
+          app.auto_eval :Models do
+            auto_load true, :directories => [:models]
+          end
+
+          app.auto_eval :Configurations do
+            auto_eval :Mapping do
+              before true do
+                app.database #force adapter init if not already done
+                ::DataMapper::Repository.context.push(::DataMapper::Repository.new(:main_repository))
+              end
+              always true do
+                ::DataMapper::Repository.context.pop
+              end
+            end
+          end
+            
+        end
+      end
+    end
+  end
+end

data/lib/layers/orm/providers/filebase.rb

@@ -0,0 +1,25 @@
+module Waves
+  module Layers
+    module ORM
+      
+      # The Filebase ORM layer configures model classes to use Filebase with a datastore located in
+      # <tt>db/model_name</tt>, where @model_name@ is the snakecased version of the class name.
+      #
+      # The Filebase store for Blog::Models::Entry would be located in <tt>db/entry</tt>, for example.
+      module Filebase
+        
+        def self.included(app)
+          app.module_eval do
+            auto_eval( :Models ) do
+              auto_eval( true ) { include ::Filebase::Model[ :db / self.basename.snake_case ] }
+            end
+          end
+        end
+        
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/layers/orm/providers/sequel.rb

@@ -0,0 +1,87 @@
+module Waves
+  module Layers
+    module ORM # :nodoc:
+      
+      # 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
+        # - defines Sequel-specific helper methods on Waves::Controllers::Base
+        # 
+        # The controller helper methdods are:
+        # - all
+        # - find(name)
+        # - create
+        # - delete(name)
+        # - update(name)
+        #
+        
+        
+        def self.included(app)
+          
+          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
+            auto_create_class :Default, ::Sequel::Model
+            auto_load :Default, :directories => [ :models ]
+            auto_create_class true, :Default
+            auto_load true, :directories => [ :models ]
+            
+            # set the Sequel dataset based on the model class name
+            # note that this is not done for app::Models::Default, as it isn't 
+            # supposed to represent a table
+            auto_eval true do
+              next if self.basename == "Default"
+              default = self.superclass.basename.snake_case.pluralize.intern
+              if @dataset && @dataset.opts[:from] != [ default ]
+                # don't clobber dataset from autoloaded file
+              elsif respond_to? :set_dataset
+                set_dataset Waves.main.database[ basename.snake_case.pluralize.intern ]
+              end
+            end
+            
+          end
+            
+          Waves::Controllers::Base.instance_eval do
+            include Waves::Layers::ORM::Sequel::ControllerMethods
+          end
+            
+        end
+
+        # Mixed into Waves::Controllers::Base.  Provides ORM-specific helper methods for model access.
+        module ControllerMethods
+          def all
+            model.all
+          end
+          
+          def find( name )
+            model[ :name => name ] or not_found
+          end
+          
+          def create
+            model.create( attributes.to_hash )
+          end
+          
+          def delete( name )
+            find( name ).destroy
+          end
+          
+          def update( name )
+            instance = find( name )
+            instance.update_with_params( attributes.to_hash )
+            instance
+          end
+        end
+        
+      end    
+    end
+  end
+end

data/lib/layers/orm/providers/sequel/migrations/empty.rb.erb

@@ -0,0 +1,9 @@
+class <%= @class_name %> < Sequel::Migration
+
+  def up
+  end
+
+  def down
+  end
+
+end

data/lib/layers/orm/providers/sequel/tasks/generate.rb

@@ -0,0 +1,30 @@
+namespace :generate do
+  
+    desc 'Generate a Sequel model, with name=<name>'
+    task :model do |task|
+
+      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/#{model_name}.rb"
+      if File.exist?(filename)
+        $stderr.puts "#{filename} already exists" 
+        exit
+      end
+
+      model = <<TEXT
+module #{app_name}
+  module Models
+    class #{model_name} < Default
+
+    end
+  end
+end
+TEXT
+
+      File.write( filename, model )
+    end
+  
+end

data/lib/layers/orm/providers/sequel/tasks/schema.rb

@@ -0,0 +1,16 @@
+require "#{File.dirname(__FILE__)}/../../../migration"
+
+namespace :schema do
+
+  desc "Create a new Sequel Migration with name=<name>"
+  task :migration do |task|
+    Waves::Layers::ORM.create_migration_for(Sequel)
+  end
+
+  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.main.database, Waves::Layers::ORM.migration_directory , version )
+  end
+
+end

data/lib/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/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/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/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