waves-edge 2009.03.10.13.14

data/lib/helpers/layouts.rb

@@ -0,0 +1,37 @@
+module Waves
+  
+  module Helpers
+
+    module Layouts
+
+      # Invokes a layout view (i.e., a view from the layouts template directory), using
+      # the assigns parameter to define instance variables for the view. The block is
+      # evaluated and also passed into the view as the +layout_content+ instance variable.
+      #
+      # You can define a layout just by creating a template and then calling the
+      # +layout_content+ accessor when you want to embed the caller's content.
+      #
+      # == Example
+      #
+      #   doctype :html4_transitional
+      #   html do
+      #     title @title # passed as an assigns parameter
+      #   end
+      #   body do
+      #     layout_content
+      #   end
+      #
+      def layout( name, assigns = {}, &block )
+        assigns[ :layout_content ] = capture(&block)
+        self << Waves.main::Views[:layouts].process( request ) do
+          send( name, assigns )
+        end
+      end
+      
+      def layout_content
+        self << @layout_content
+      end
+
+    end
+  end
+end

data/lib/helpers/model.rb

@@ -0,0 +1,37 @@
+module Waves
+  module Helpers
+
+    # Model helpers allow you to directly access a model from within a view.
+    # This is useful when creating things like select boxes that need data
+    # from anther model. For example, a Markaby select box for authors might look like:
+    #
+    #   select do
+    #     all(:user).each do |user|
+    #       option user.full_name, :value => user.id
+    #     end
+    #   end
+    #
+    # You could also use these within a view class to keep model-based logic out
+    # of the templates themselves. For example, in the view class you might define
+    # a method called +authors+ that returns an array of name / id pairs. This could
+    # then be called from the template instead of the model helper.
+    #
+    module Model
+      
+      def model( name )
+        Waves.main::Models[ name ][ domain ]
+      end
+      
+      # Just like model.all. Returns all the instances of that model.
+      def all( model )
+        model( model ).all
+      end
+      
+      # Finds a specific instance using the name field
+      def find( model, name )
+        model( model )[name ] rescue nil
+      end
+
+    end
+  end
+end

data/lib/helpers/view.rb

@@ -0,0 +1,22 @@
+module Waves
+  module Helpers
+
+    # View helpers are intended to help reuse views from within other views.
+    # Both the +layout+ method in the common helpers and the +property+ method
+    # of the form helpers are specialized instance of this.
+    #
+    # The star of our show here is the +view+ method. This takes a model, view,
+    # and assigns hash (which are converted into instance variables in the target
+    # view) and returns the result of evaluating the view as content in the current
+    # template.
+    module View
+      
+      # Invokes the view for the given model, passing the assigns as instance variables.
+      def view( model, view, assigns = {} )
+        self << Waves.main::Views[ model ].new( request ).send( view, assigns )
+      end
+
+
+    end
+  end
+end

data/lib/layers/inflect/english.rb

@@ -0,0 +1,35 @@
+module Waves
+  module Layers
+    module Inflect
+      
+      # Adds plural/singular methods for English to String
+      module English
+        
+        def self.included(app)
+          
+          require 'english/inflect'
+                    
+          Waves::Resources::Mixin::ClassMethods.module_eval do
+            def singular ; basename.snake_case.singular ; end
+            def plural ; basename.snake_case.plural ; end
+          end
+            
+          Waves::Resources::Mixin.module_eval do
+            def singular ; self.class.singular ; end
+            def plural ; self.class.plural ; end
+          end
+          
+          Waves::Resources::Paths.module_eval do
+            def resource ; self.class.resource.singular ; end
+            def resources ; self.class.resource.plural ; end
+          end
+          
+        end
+        
+      end
+    end
+  end
+end
+
+
+

data/lib/layers/mvc.rb

@@ -0,0 +1,41 @@
+module Waves
+  module Layers
+    module MVC
+
+      def self.included( app )
+        
+        require 'layers/mvc/extensions'
+        require 'layers/mvc/controllers'
+        
+        app.auto_create_module( :Models ) do
+          auto_create_class :Default
+          auto_load :Default, :directories => [ :models ]
+          auto_create_class true, :Default
+          auto_load true, :directories => [ :models ]
+        end
+
+        app.auto_create_module( :Views ) do
+          auto_create_class :Default, Waves::Views::Base
+          auto_load :Default, :directories => [ :views ]
+          auto_create_class true, :Default
+          auto_load true, :directories => [ :views ]
+        end
+
+        app.auto_create_module( :Controllers ) do
+          auto_create_class :Default, Waves::Controllers::Base
+          auto_load :Default, :directories => [ :controllers ]
+          auto_create_class true, :Default
+          auto_load true, :directories => [ :controllers ]          
+        end
+
+        app.auto_create_module( :Helpers ) do
+          auto_create_module( :Default ) { include Waves::Helpers::Extended }
+          auto_load :Default, :directories => [ :helpers ]
+          auto_create_module( true ) { include app::Helpers::Default }
+          auto_load true, :directories => [ :helpers ]
+        end
+        
+      end
+    end
+  end
+end

data/lib/layers/mvc/controllers.rb

@@ -0,0 +1,41 @@
+module Waves
+
+  module Controllers
+
+    module Mixin
+
+      attr_reader :request
+
+      include Waves::ResponseMixin
+
+      def initialize( request )
+        @request = request
+      end
+      
+      def find( name )
+        model.find( name )
+      end
+      
+      def create( attributes )
+        model.create( attributes )
+      end
+      
+      def update( name, attributes )
+        find( name ).attributes = attributes
+      end
+      
+      def delete( name )
+        model.delete( name )
+      end
+      
+      def list
+        model.all
+      end
+
+    end
+
+    class Base ; include Mixin ; end 
+
+  end
+
+end

data/lib/layers/mvc/extensions.rb

@@ -0,0 +1,52 @@
+module Waves
+  
+  module Resources
+    
+    module Mixin
+      
+      def controller( resource = nil )
+        resource ||= self.class.basename
+        @controller ||= app::Controllers[ resource ].new( @request )
+      end
+      
+      def view( resource = nil )
+        resource ||= self.class.basename
+        @view ||= app::Views[ resource ].new( @request )
+      end
+  
+    end
+    
+  end
+  
+  module ResponseMixin
+
+    # Returns the name of the model corresponding to this controller by taking the basename
+    # of the module and converting it to snake case. If the model plurality is different than
+    # the controller, this will not, in fact, be the model name.
+    def model_name; self.class.basename.snake_case; end
+
+    # Returns the model corresponding to this controller by naively assuming that 
+    # +model_name+ must be correct. This allows you to write generic controller methods such as:
+    #
+    #   model.find( name )
+    #
+    # to find an instance of a given model. Again, the plurality of the controller and
+    # model must be the same for this to work.
+    def model; app::Models[ model_name.intern ]; end
+
+    # MVC Params get automatically destructured with the keys as accessors methods.
+    # You can still access the original query by calling request.query
+    def query
+      @query ||= Waves::Request::Query.new( 
+        Waves::Request::Utilities.destructure( request.query ) )
+    end
+
+    # Attributes are just the query elements specific to the model associated with
+    # the current resource.
+    def attributes
+      query[ model_name ]
+    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__) / :providers / 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/providers/active_record.rb

@@ -0,0 +1,84 @@
+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)
+
+          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
+            auto_create_class :Default, ::ActiveRecord::Base
+            auto_load :Default, :directories => [ :models ]
+            auto_create_class true, app::Models::Default
+            auto_load true, :directories => [ :models ]
+
+            auto_eval true do
+              next if self.basename == "Default"
+              app.database
+              set_table_name self.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( name )
+            model.find_by_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_attributes( attributes )
+            instance
+          end
+        end
+        
+      end
+    end
+  end
+end
+

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

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