waves-stable 0.7.7

data/lib/layers/inflect/english/string.rb

@@ -0,0 +1,24 @@
+module Waves
+  module Layers
+    module Inflect
+      module English
+        module StringMethods
+        
+          def singular
+            English::Rules.singular(self)
+          end
+
+          alias_method(:singularize, :singular)
+
+          def plural
+            English::Rules.plural(self)
+          end
+
+          alias_method(:pluralize, :plural)
+        
+        end
+      end
+    end
+  end
+end
+

data/lib/layers/mvc.rb

@@ -0,0 +1,54 @@
+module Waves
+  module Layers
+    # The MVC layer establishes the Models, Views, Controllers, and Helpers namespaces inside 
+    # a Waves application.  In each namespace, undefined constants are handled by AutoCode, which
+    # loads the constant from the correct file in the appropriate directory if it exists, or creates
+    # from default otherwise.
+    module MVC
+
+      def self.included( app )
+        
+        def app.models ; self::Models ; end
+        def app.views ; self::Views ; end
+        def app.controllers ; self::Controllers ; end
+        def app.helpers ; self::Helpers ; end
+        
+        app.auto_create_module( :Models ) do
+          include AutoCode
+          auto_create_class :Default
+          auto_load :Default, :directories => [:models]
+        end
+        
+        app.auto_eval( :Models ) do
+          auto_create_class true, app::Models::Default
+          auto_load true, :directories => [ :models ]
+        end
+
+        app.auto_create_module( :Views ) { include AutoCode }
+        
+        app.auto_eval( :Views ) do
+          auto_create_class :Default, Waves::Views::Base
+          auto_load :Default, :directories => [:views]
+          auto_create_class true, app::Views::Default
+          auto_load true, :directories => [ :views ]
+        end
+
+        app.auto_create_module( :Controllers ) { include AutoCode }
+        
+        app.auto_eval( :Controllers ) do
+          auto_create_class :Default, Waves::Controllers::Base
+          auto_load :Default, :directories => [:controllers]
+          auto_create_class true, app::Controllers::Default
+          auto_load true, :directories => [ :controllers ]          
+        end
+
+        app.auto_create_module( :Helpers ) do
+          include AutoCode
+          auto_create_module { include Waves::Helpers::Default }
+          auto_load true, :directories => [ :helpers ]
+        end          
+
+      end
+    end
+  end
+end

data/lib/layers/orm/active_record.rb

@@ -0,0 +1,92 @@
+module Waves
+  module Layers
+    module ORM
+
+      # Sets up the ActiveRecord connection and configures AutoCode on Models, so that constants in that
+      # namespace get loaded from file or created as subclasses of Models::Default
+      module ActiveRecord
+        
+        # On inclusion, this module:
+        # - creates on the application module a database method that establishes and returns the ActiveRecord connection
+        # - arranges for autoloading/autocreation of missing constants in the Models namespace
+        # - defines ActiveRecord-specific helper methods on Waves::Controllers::Base
+        # 
+        # The controller helper methdods are:
+        # - all
+        # - find(name)
+        # - create
+        # - delete(name)
+        # - update(name)
+        
+        def self.included(app)
+          
+          class Symbol
+            # Protect ActiveRecord from itself by undefining the to_proc method.
+            # Don't worry, AR will redefine it.
+            alias :extensions_to_proc :to_proc
+            remove_method :to_proc
+          end
+          require 'active_record'
+          require "#{File.dirname(__FILE__)}/active_record/tasks/schema"    if defined?(Rake)
+          require "#{File.dirname(__FILE__)}/active_record/tasks/generate"  if defined?(Rake)
+          
+          def app.database
+            unless @database
+              ::ActiveRecord::Base.establish_connection(config.database)
+              @database = ::ActiveRecord::Base.connection
+            end
+            @database
+          end
+                      
+          app.auto_create_module( :Models ) do
+            include AutoCode
+            auto_create_class :Default, ::ActiveRecord::Base
+            auto_load :Default, :directories => [ :models ]
+          end
+          
+          app.auto_eval :Models do
+            auto_create_class true, app::Models::Default
+            auto_load true, :directories => [ :models ]
+
+            auto_eval true do
+              app.database
+              set_table_name basename.snake_case.pluralize.intern
+            end
+          end
+          
+          Waves::Controllers::Base.instance_eval do
+            include Waves::Layers::ORM::ActiveRecord::ControllerMethods
+          end
+          
+        end
+        
+        # Mixed into Waves::Controllers::Base.  Provides ORM-specific helper methods for model access.
+        module ControllerMethods
+          def all
+            model.find(:all)
+          end
+          
+          def find( id )
+            model.find(id) or not_found
+          end
+          
+          def create
+            model.create( attributes )
+          end
+          
+          def delete( id )
+            find( id ).destroy
+          end
+          
+          def update( id )
+            instance = find( id )
+            instance.update_attributes( attributes )
+            instance
+          end
+        end
+        
+      end
+    end
+  end
+end
+

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 @@
+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)
+          
+          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.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