dyoder-waves 0.7.3 → 0.7.6

data/lib/layers/orm/active_record/migrations/empty.rb.erb

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

data/lib/layers/orm/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/#{name}.rb"
+      if File.exist?(filename)
+        $stderr.puts "#{filename} already exists" 
+        exit
+      end
+
+      model = <<TEXT
+module #{Waves.application.name}
+  module Models
+    class #{model_name} < Default
+
+    end
+  end
+end
+TEXT
+
+      File.write( filename, model )
+    end
+  
+end

data/lib/layers/orm/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.application.database
+    ActiveRecord::Base.logger = Logger.new($stdout)
+  end
+
+end
+

data/lib/layers/orm/data_mapper.rb

@@ -0,0 +1,38 @@
+gem 'dm-core', '=0.9.0'
+
+require 'data_mapper'
+
+module Waves
+  module Layers
+    module ORM
+      
+      # Work in Progress
+      module DataMapper
+        
+        def self.included(app)
+          
+          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/filebase.rb

@@ -0,0 +1,22 @@
+module Waves
+  module Layers
+    module ORM
+      
+      # Work in Progress
+      module Filebase
+        
+        def self.included(app)
+          app.module_eval do
+            auto_eval( :Models ) do
+              auto_eval( true ) { include Filebase::Model[ :db / self.name.snake_case ] }
+            end
+          end
+        end
+        
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/layers/orm/migration.rb

@@ -0,0 +1,79 @@
+module Waves
+  module Layers
+    
+    # Helper methods to establish inter-ORM standards
+    module ORM
+
+      # Glob pattern
+      MIGRATION_FILE_PATTERN = '[0-9][0-9][0-9]_*.rb'.freeze
+
+      def self.create_migration_for(orm)
+        source          = migration_template(orm.to_s.snake_case, ENV['template'])
+        destination     = migration_destination(ENV['name'])
+        migration_name  = migration_name(ENV['name'])
+
+        context = {:class_name => migration_name.camel_case}
+
+        write_migration(context, source, destination)
+      end
+
+      # Where Waves keeps its migration files
+      def self.migration_directory
+        :schema / :migrations
+      end
+
+      # Returns any found migration files in the supplied directory.
+      def self.migration_files(range = nil)
+        pattern = migration_directory / MIGRATION_FILE_PATTERN
+        files = Dir[pattern].inject([]) do |m, path|
+          m[File.basename(path).to_i] = path
+          m
+        end
+        filtered = range ? files[range] : files
+        filtered ? filtered.compact : []
+      end
+
+      # Use the supplied version number or determine the next in sequence
+      # based on the migration files in the migration directory
+      def self.next_migration_version
+        version = ENV['version'] || latest_migration_version
+        version.to_i + 1
+      end
+
+      # Uses the migration files in the migration directory to determine
+      # the highest numbered existing migration.
+      def self.latest_migration_version
+        l = migration_files.last
+        l ? File.basename(l).to_i : nil
+      end
+
+      # If the user doesn't pass a name, defaults to "migration"
+      def self.migration_name(name=nil)
+        name || 'migration'
+      end
+
+      # Returns the path to the migration template file for the given ORM.
+      # <em>orm</em> can be a symbol or string
+      def self.migration_template(orm, name=nil)
+        file = ( name || 'empty' ) + '.rb.erb'
+        source = File.dirname(__FILE__) / orm / :migrations / file
+      end
+
+      # Given a migration name, returns the path of the file that would be created.
+      def self.migration_destination(name)
+        version = next_migration_version
+        migration_directory / "#{'%03d' % version}_#{migration_name(name)}.rb"
+      end
+
+      # Takes an assigns hash as the Erubis context.  Keys in the hash become
+      # instance variable names.
+      def self.write_migration(context, source, destination)
+        code = Erubis::Eruby.new( File.read( source ) ).evaluate( context )
+        puts "Creating #{destination}"
+        File.write( destination, code )
+      end
+
+    end
+  end
+
+end

data/lib/layers/orm/sequel.rb

@@ -0,0 +1,86 @@
+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
+      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)
+          
+          def app.database ; @sequel ||= ::Sequel.open( config.database ) ; end
+                      
+          app.auto_create_module( :Models ) do
+            include AutoCode
+            auto_create_class :Default, ::Sequel::Model
+            auto_load :Default, :directories => [ :models ]
+          end
+          
+          app.auto_eval :Models do
+            auto_create_class true, app::Models::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
+              default = superclass.basename.snake_case.pluralize.intern
+              if @dataset && @dataset.opts[:from] != [ default ]
+                # don't clobber dataset from autoloaded file
+              else
+                set_dataset Waves.application.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 )
+          end
+          
+          def delete( name )
+            find( name ).destroy
+          end
+          
+          def update( name )
+            instance = find( name )
+            instance.update_with_params( attributes )
+            instance
+          end
+        end
+        
+      end    
+    end
+  end
+end

data/lib/layers/orm/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/sequel/tasks/generate.rb

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

data/lib/layers/orm/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.application.database, Waves::Layers::ORM.migration_directory , version )
+  end
+
+end

data/lib/layers/simple.rb

@@ -0,0 +1,35 @@
+module Waves
+  
+  # Waves uses Layers to provide discrete, stackable, interchangeable bundles of functionality.
+  # 
+  # Developers can make use of Layers by including them directly in a Waves application:
+  # 
+  #   module MyApp
+  #     include SomeLayer
+  #   end
+  module Layers
+    
+    # Creates the Configurations namespace and establishes the standard autoload-or-autocreate
+    # rules.
+    module Simple
+      def self.included( app )
+
+        def app.config ; Waves.config ; end
+        def app.configurations ; self::Configurations ; end
+        
+        app.instance_eval { include AutoCode }
+        
+        app.auto_create_module( :Configurations ) do
+          include AutoCode
+          auto_create_class true, Waves::Configurations::Default
+          auto_load :Mapping, :directories => [:configurations]
+          auto_load true, :directories => [:configurations]
+          auto_eval :Mapping do
+            extend Waves::Mapping
+          end
+        end
+      end
+    end
+  end
+end
+      

data/lib/layers/simple_errors.rb

@@ -1,16 +1,22 @@
 module Waves
   module Layers
+    # Configures Waves for minimal exception handling.  
+    # 
+    # For example,
+    # a NotFoundError results in response status of 404, with body text
+    # of "404 Not Found".
     module SimpleErrors
 
       def self.included( app )
 
-        app.instance_eval do
-
-          autoinit 'Configurations::Mapping' do
-            handle(Waves::Dispatchers::NotFoundError) { response.status = 404 }
+        app.auto_eval :Configurations do
+          auto_eval :Mapping do
+            handle(Waves::Dispatchers::NotFoundError) do
+               response.status = 404; response.body = "404 Not Found"
+            end
           end
-
         end
+
       end
     end
   end

data/lib/mapping/mapping.rb

@@ -1,11 +1,33 @@
 module Waves
 
-  # Waves::Mapping is a mixin for defining Waves URI mappings (mapping a request to Ruby code).
-  # Mappings can work against the request url, path, and elements of the request (such as the
-  # request method or accept header). Mappings may also include before, after, or wrap filters
-  # to be run if they match the request. Mappings are created using an appropriate mapping method
-  # along with a URL pattern (a string or regular expression), a hash of constraint options, and
-  # a block, which is the code to run if the pattern matches.
+  # Mappings in Waves are the interface between the request dispatcher and your
+  # application code.  The dispatcher matches each request against the mappings
+  # to determine a primary action and to collect sets of before, after, wrap, 
+  # and always actions.  The dispatcher also looks for an exception handler 
+  # registered in the mappings when attempting a rescue.
+  # 
+  # Each mapping associates a block with a set of constraints.  Mappings can be
+  # one of several types:
+  # 
+  # - action (the actual request processing and response)
+  # - handle (exception handling)
+  # - before 
+  # - after
+  # - wrap (registers its block as both a before and after action)
+  # - always (like an "ensure" clause in a rescue)
+  # 
+  # Actions are registered using path, url, or map.  The other types may be 
+  # registered using methods named after the type.
+  # 
+  # 
+  # The available constraints are:
+  # 
+  # - a string or regexp that the path or url must match
+  # - parameters to match against the HTTP request headers and the Rack-specific variables (e.g. 'rack.url_scheme')
+  # - an additional hash reserved for settings not related to the Rack request (e.g. giving Rack handers special instructions for certain requests.  See threaded? )
+  # 
+  # The dispatcher evaluates mapping blocks in an instance of ResponseProxy, 
+  # which provides access to foundational classes of a Waves application (i.e. controllers and views)
   #
   # == Examples
   #
@@ -104,6 +126,7 @@ module Waves
     end
 
     # Similar to before, except it runs its actions after any matching +url+ or +path+ actions.
+    # Note that after methods will run even if an exception is thrown during processing.
     def after( path, options = {}, &block )
       if path.is_a? Hash
         options = path
@@ -124,15 +147,26 @@ module Waves
       filters[:after] << [ options, block ]
     end
 
-    # Maps a request to a block. Don't use this method directly unless you know what
-    # you're doing. Use +path+ or +url+ instead.
-    def map( path, options = {}, params = {}, &block )
+    # Like after, but will run even when an exception is thrown. Exceptions in
+    # always mappings are simply logged and ignored.
+    def always( path, options = {}, &block )
       if path.is_a? Hash
-        params = options
         options = path
       else
         options[:path] = path
       end
+      filters[:always] << [ options, block ]
+    end
+
+    # Maps a request to a block. Don't use this method directly unless you know what
+    # you're doing. Use +path+ or +url+ instead.
+    def map( path, options = {}, params = {}, &block )
+      case path
+      when Hash
+        params = options; options = path
+      when String
+        options[:path] = path
+      end
       mapping << [ options, params, block ]
     end
 
@@ -155,7 +189,7 @@ module Waves
     def root( options = {}, params = {}, &block )
       path( %r{^/?$}, options, params, &block )
     end
-
+    
     # Maps an exception handler to a block.
     def handle(exception, options = {}, &block )
       handlers << [exception,options, block]
@@ -186,12 +220,12 @@ module Waves
       end
       return false
     end
-
+    
     # Match the given request against the defined rules. This is typically only called
     # by a dispatcher object, so you shouldn't typically use it directly.
     def []( request )
 
-      rx = { :before => [], :after => [], :action => nil, :handlers => [] }
+      rx = { :before => [], :after => [], :always => [], :action => nil, :handlers => [] }
 
       ( filters[:before] + filters[:wrap] ).each do | options, function |
         matches = match( request, options, function )
@@ -208,6 +242,11 @@ module Waves
         rx[:after] << matches if matches
       end
 
+      filters[:always].each do | options, function |
+        matches = match( request, options, function )
+        rx[:always] << matches if matches
+      end
+
       handlers.each do | exception, options, function |
         matches = match( request, options, function )
         rx[:handlers] << matches.unshift(exception) if matches
@@ -218,35 +257,33 @@ module Waves
 
     # Clear all mapping rules
     def clear
-      @mapping = @filters = nil;
+      @mapping = @filters = @handlers = nil;
     end
 
     private
 
     def mapping; @mapping ||= []; end
 
-    def filters; @filters ||= { :before => [], :after => [], :wrap => [] }; end
+    def filters; @filters ||= { :before => [], :after => [], :wrap => [], :always => [] }; end
 
     def handlers; @handlers ||= []; end
 
     def match ( request, options, function )
       return nil unless satisfy( request, options )
-      if options[:path]
-        matches = options[:path].match( request.path )
-      elsif options[:url]
-        matches = options[:url].match( request.url )
-      end
+      return [ function, nil ] if ( options[:path] == true or options[:url] == true )
+      matches = options[:path].match( request.path ) if options[:path]
+      matches = options[:url].match( request.url ) if options[:url]
       return [ function, matches ? matches[1..-1] : nil ]
     end
 
     def satisfy( request, options )
       options.nil? or options.all? do |name,wanted|
-        got = request.send( name ) rescue request.env[  ( name =~ /^rack\./ ) ?
-          name.to_s.downcase : name.to_s.upcase ]
-        ( ( wanted.is_a?(Regexp) && wanted.match( got.to_s ) ) or
-          got.to_s == wanted.to_s ) unless ( wanted.nil? or got.nil? )
+        return true if wanted == true
+        got = request.send( name ) rescue request.env[  ( name =~ /^rack\./ ) ? name.to_s.downcase : name.to_s.upcase ]
+        ( ( wanted.is_a?(Regexp) and wanted.match( got.to_s ) ) or got.to_s == wanted.to_s ) unless ( wanted.nil? or got.nil? )
       end
     end
   end
+  
 
 end