waves 0.7.6 → 0.7.7

data/lib/layers/orm/data_mapper.rb

@@ -15,27 +15,23 @@ module Waves
             @adapter ||= ::DataMapper.setup(:main_repository, config.database[:database])
           end
           
-          app.instance_eval do
-
-            auto_eval :Models do
-              auto_load true, :directories => [:models]
-            end
+          app.auto_eval :Models do
+            auto_load true, :directories => [:models]
+          end
 
-            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
+          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

data/lib/layers/orm/migration.rb

@@ -1,21 +1,30 @@
 module Waves
-  module Orm # :nodoc:
-    # Helper methods to establish an inter-ORM standard for migrations
-    module Migration
-
-      # stuff in this file largely lifted from Sequel.  Thanks, bro.
+  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.directory
+      def self.migration_directory
         :schema / :migrations
       end
 
       # Returns any found migration files in the supplied directory.
       def self.migration_files(range = nil)
-        pattern = directory / MIGRATION_FILE_PATTERN
+        pattern = migration_directory / MIGRATION_FILE_PATTERN
         files = Dir[pattern].inject([]) do |m, path|
           m[File.basename(path).to_i] = path
           m
@@ -45,20 +54,20 @@ module Waves
 
       # Returns the path to the migration template file for the given ORM.
       # <em>orm</em> can be a symbol or string
-      def self.template(orm, name=nil)
+      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.destination(name)
+      def self.migration_destination(name)
         version = next_migration_version
-        directory / "#{'%03d' % version}_#{migration_name(name)}.rb"
+        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_erb(context, source, destination)
+      def self.write_migration(context, source, destination)
         code = Erubis::Eruby.new( File.read( source ) ).evaluate( context )
         puts "Creating #{destination}"
         File.write( destination, code )

data/lib/layers/orm/sequel.rb

@@ -1,7 +1,3 @@
-gem 'sequel', '>= 2.0.0'
-require 'sequel'
-require File.dirname(__FILE__) / :sequel / :tasks / :schema if defined?(Rake)
-
 module Waves
   module Layers
     module ORM # :nodoc:
@@ -24,59 +20,67 @@ module Waves
         #
         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( config.database ) ; end
+                      
+          app.auto_create_module( :Models ) do
+            include AutoCode
+            auto_create_class :Default, ::Sequel::Model
+            auto_load :Default, :directories => [ :models ]
+          end
           
-          app.instance_eval do
-            
-            auto_create_module( :Models ) do
-              include AutoCode
-              auto_create_class :Default, ::Sequel::Model
-              auto_load :Default, :directories => [ :models ]
-            end
-            
-            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
+          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.module_eval do
-              def all #:nodoc:
-                model.all
-              end
-              
-              def find( name ) #:nodoc:
-                model[ :name => name ] or not_found
-              end
-              
-              def create #:nodoc:
-                model.create( attributes )
-              end
-              
-              def delete( name ) #:nodoc:
-                find( name ).destroy
-              end
-              
-              def update( name ) #:nodoc:
-                instance = find( name )
-                instance.update_with_params( attributes )
-                instance
-              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
 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

@@ -1,24 +1,16 @@
-require File.dirname(__FILE__) / ".." / ".." / :migration
-include Waves::Orm
+require "#{File.dirname(__FILE__)}/../../migration"
+
 namespace :schema do
 
-  desc "Create a new Sequel Migration using ENV['name']."
+  desc "Create a new Sequel Migration with name=<name>"
   task :migration do |task|
-
-    source          = Migration.template(:sequel, ENV['template'])
-    destination     = Migration.destination(ENV['name'])
-    migration_name  = Migration.migration_name(ENV['name'])
-
-    context = {:class_name => migration_name.camel_case}
-
-    Migration.write_erb(context, source, destination)
-
+    Waves::Layers::ORM.create_migration_for(Sequel)
   end
 
-  desc 'Performs migration from version, to version.'
+  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, Migration.directory , version )
+    Sequel::Migrator.apply( Waves.application.database, Waves::Layers::ORM.migration_directory , version )
   end
 
 end

data/lib/layers/simple.rb

@@ -17,20 +17,13 @@ module Waves
         def app.config ; Waves.config ; end
         def app.configurations ; self::Configurations ; end
         
-        app.instance_eval do
-
+        app.instance_eval { include AutoCode }
+        
+        app.auto_create_module( :Configurations ) do
           include AutoCode
-          
-          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
-
+          auto_create_class true, Waves::Configurations::Default
+          auto_load :Mapping, :directories => [:configurations]
+          auto_load true, :directories => [:configurations]
         end
       end
     end

data/lib/layers/simple_errors.rb

@@ -9,17 +9,14 @@ module Waves
 
       def self.included( app )
 
-        app.instance_eval do
-
-          auto_eval :Configurations do
-            auto_eval :Mapping do
-              handle(Waves::Dispatchers::NotFoundError) do
-                 response.status = 404; response.body = "404 Not Found"
-              end
+        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/renderers/haml.rb

@@ -0,0 +1,45 @@
+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
+
+      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
+
+    end
+
+  end
+
+end

data/lib/runtime/application.rb

@@ -7,10 +7,8 @@ module Waves
     attr_reader :application
 
     # Register a module as a Waves application.
-    # Also, initialize the database connection if necessary.
     def << ( app )
       @application = app if Module === app
-      # app.database if app.respond_to? 'database'
     end
 
     def instance ; Waves::Application.instance ; end

data/lib/tasks/cluster.rb

@@ -2,7 +2,7 @@ namespace :cluster do
 
   desc 'Start a cluster of waves applications.'
   task :start do |task|
-    using_waves_src = defined?(WAVES) || ENV['WAVES'] || File.exist( File.dirname(__FILE__) / :waves )
+    using_waves_src = defined?(WAVES) || ENV['WAVES'] || File.exist?( File.dirname(__FILE__) / :waves )
     script = using_waves_src ? :bin / 'waves-server' : 'waves-server'
     ( Waves::Console.config.ports || [ Waves::Console.config.port ] ).each do |port|
       cmd = "#{script} -p #{port} -c #{ENV['mode']||'development'} -d"

data/lib/utilities/inflect.rb

@@ -4,189 +4,107 @@
 # of rules for different languages
 # NOTE: this is NOT implemented yet.
 # plural and singular work directly with the English class
+module Waves
+  module Inflect # :nodoc:
+    module InflectorMethods
+      
+      # Define a general exception.
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
+      end
 
-module Inflect # :nodoc:
-  module InflectorMethods
-
-    # Define a general exception.
-    def word(singular, plural=nil)
-      plural = singular unless plural
-      singular_word(singular, plural)
-      plural_word(singular, plural)
-    end
-
-    # Define a singularization exception.
-    def singular_word(singular, plural)
-      @singular_of[plural] = singular
-    end
-
-    # Define a pluralization exception.
-    def plural_word(singular, plural)
-      @plural_of[singular] = plural
-    end
-
-    # Define a general rule.
-    def rule(singular, plural)
-      singular_rule(singular, plural)
-      plural_rule(singular, plural)
-    end
-
-    # Define a singularization rule.
-    def singular_rule(singular, plural)
-      @singular_rules << [singular, plural]
-    end
-
-    # Define a plurualization rule.
-    def plural_rule(singular, plural)
-      @plural_rules << [singular, plural]
-    end
-
-    # Read prepared singularization rules.
-    def singularization_rules
-      return @singularization_rules if @singularization_rules
-      sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
-      @singularization_rules = sorted.collect do |s, p|
-        [ /#{p}$/, "#{s}" ]
+      # Define a singularization exception.
+      def singular_word(singular, plural)
+        @singular_of ||= {}
+        @singular_of[plural] = singular
       end
-    end
 
-    # Read prepared pluralization rules.
-    def pluralization_rules
-      return @pluralization_rules if @pluralization_rules
-      sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
-      @pluralization_rules = sorted.collect do |s, p|
-        [ /#{s}$/, "#{p}" ]
+      # Define a pluralization exception.
+      def plural_word(singular, plural)
+        @plural_of ||= {}
+        @plural_of[singular] = plural
       end
-    end
 
-    #
-    def plural_of
-      @plural_of
-    end
+      # Define a general rule.
+      def rule(singular, plural)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+      end
 
-    #
-    def singular_of
-      @singular_of
-    end
+      # Define a singularization rule.
+      def singular_rule(singular, plural)
+        (@singular_rules ||= []) << [singular, plural]
+      end
 
-    # Convert an English word from plurel to singular.
-    #
-    #   "boys".singular      #=> boy
-    #   "tomatoes".singular  #=> tomato
-    #
-    def singular(word)
-      if result = singular_of[word]
-        return result.dup
+      # Define a plurualization rule.
+      def plural_rule(singular, plural)
+        (@plural_rules ||= []) << [singular, plural]
       end
-      result = word.dup
-      singularization_rules.each do |(match, replacement)|
-        break if result.gsub!(match, replacement)
+
+      # Read prepared singularization rules.
+      def singularization_rules
+        @singular_rules ||= []
+        return @singularization_rules if @singularization_rules
+        sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
+        @singularization_rules = sorted.collect do |s, p|
+          [ /#{p}$/, "#{s}" ]
+        end
       end
-      return result
-    end
 
-    # Convert an English word from singular to plurel.
-    #
-    #   "boy".plural     #=> boys
-    #   "tomato".plural  #=> tomatoes
-    #
-    def plural(word)
-      if result = plural_of[word]
-        return result.dup
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        @plural_rules ||= []
+        return @pluralization_rules if @pluralization_rules
+        sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
+        @pluralization_rules = sorted.collect do |s, p|
+          [ /#{s}$/, "#{p}" ]
+        end
       end
-      #return self.dup if /s$/ =~ self # ???
-      result = word.dup
-      pluralization_rules.each do |(match, replacement)|
-        break if result.gsub!(match, replacement)
+
+      #
+      def plural_of
+        @plural_of ||= {}
       end
-      return result
-    end
-  end
 
-  class English # :nodoc:
-    @singular_of = {}
-    @plural_of = {}
+      #
+      def singular_of
+        @singular_of ||= {}
+      end
 
-    @singular_rules = []
-    @plural_rules = []
+      # Convert an English word from plural to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        singularization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
 
-    class << self
-      include InflectorMethods
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      def plural(word)
+        if result = plural_of[word]
+          return result.dup
+        end
+        #return self.dup if /s$/ =~ self # ???
+        result = word.dup
+        pluralization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
     end
-
-    # One argument means singular and plural are the same.
-    word 'equipment'
-    word 'information'
-    word 'money'
-    word 'species'
-    word 'series'
-    word 'fish'
-    word 'sheep'
-    word 'moose'
-    word 'hovercraft'
-
-    # Two arguments defines a singular and plural exception.
-    word 'Swiss'     , 'Swiss'
-    word 'life'      , 'lives'
-    word 'wife'      , 'wives'
-    word 'cactus'    , 'cacti'
-    word 'goose'     , 'geese'
-    word 'criterion' , 'criteria'
-    word 'alias'     , 'aliases'
-    word 'status'    , 'statuses'
-    word 'axis'      , 'axes'
-    word 'crisis'    , 'crises'
-    word 'testis'    , 'testes'
-    word 'child'     , 'children'
-    word 'person'    , 'people'
-    word 'potato'    , 'potatoes'
-    word 'tomato'    , 'tomatoes'
-    word 'buffalo'   , 'buffaloes'
-    word 'torpedo'   , 'torpedoes'
-    word 'quiz'      , 'quizes'
-    word 'matrix'    , 'matrices'
-    word 'vertex'    , 'vetices'
-    word 'index'     , 'indices'
-    word 'ox'        , 'oxen'
-    word 'mouse'     , 'mice'
-    word 'louse'     , 'lice'
-    word 'thesis'    , 'theses'
-    word 'thief'     , 'thieves'
-    word 'analysis'  , 'analyses'
-
-    # One-way singularization exception (convert plural to singular).
-    singular_word 'cactus', 'cacti'
-
-    # General rules.
-    rule 'hive' , 'hives'
-    rule 'rf'   , 'rves'
-    rule 'af'   , 'aves'
-    rule 'ero'  , 'eroes'
-    rule 'man'  , 'men'
-    rule 'ch'   , 'ches'
-    rule 'sh'   , 'shes'
-    rule 'ss'   , 'sses'
-    rule 'ta'   , 'tum'
-    rule 'ia'   , 'ium'
-    rule 'ra'   , 'rum'
-    rule 'ay'   , 'ays'
-    rule 'ey'   , 'eys'
-    rule 'oy'   , 'oys'
-    rule 'uy'   , 'uys'
-    rule 'y'    , 'ies'
-    rule 'x'    , 'xes'
-    rule 'lf'   , 'lves'
-    rule 'us'   , 'uses'
-    rule ''     , 's'
-
-    # One-way singular rules.
-    singular_rule 'of' , 'ofs' # proof
-    singular_rule 'o'  , 'oes' # hero, heroes
-    singular_rule 'f'  , 'ves'
-
-    # One-way plural rules.
-    plural_rule 'fe' , 'ves' # safe, wife
-    plural_rule 's'  , 'ses'
   end
 end
-