waves-stable 0.7.7 → 2009.3.10

data/lib/helpers/formatting.rb

@@ -19,9 +19,9 @@ module Waves
       # Treat content as Textile.
       def textile( content )
         return if content.nil? or content.empty?
-        ( ::RedCloth::TEXTILE_TAGS  << [ 96.chr, '&8216;'] ).each do |pat,ent|
-          content.gsub!( pat, ent.gsub('&','&#') )
-        end
+        #( ::RedCloth::TEXTILE_TAGS  << [ 96.chr, '&8216;'] ).each do |pat,ent|
+        #  content.gsub!( pat, ent.gsub('&','&#') )
+        #end
         self << ::RedCloth.new( content ).to_html
       end
 

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

@@ -17,15 +17,19 @@ module Waves
     # 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 )
-        Waves.application.models[ model ].all( domain )
+        model( model ).all
       end
-
+      
       # Finds a specific instance using the name field
       def find( model, name )
-        Waves.application.models[ model ][ :name => name ] rescue nil
+        model( model )[name ] rescue nil
       end
 
     end

data/lib/helpers/view.rb

@@ -10,12 +10,10 @@ module Waves
     # 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.application.views[ model ].process( request ) do
-          send( view, assigns )
-        end
+        self << Waves.main::Views[ model ].new( request ).send( view, assigns )
       end
 
 

data/lib/layers/inflect/english.rb

@@ -1,16 +1,59 @@
-require 'layers/inflect/english/rules'
-require 'layers/inflect/english/string'
 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
           
-          String.class_eval do
-            include Waves::Layers::Inflect::English::StringMethods
+          Waves::Resources::Paths.module_eval do
+            def resource ; self.class.resource.singular ; end
+            def resources ; self.class.resource.plural ; end
+
+            # TODO: be nice to DRY this up ... basically the same code 
+            # as the mixin except with the singular / plural stuff
+            # mixed in ...
+            def generate( template, args )
+              return "/#{ args * '/' }" unless template.is_a?( Array ) and not template.empty?
+              path = []
+              ( "/#{ path * '/' }" ) if template.all? do | want |
+                case want
+                when true then path += args
+                when String then path << want
+                when Symbol
+                  case want
+                  when :resource then path << resource
+                  when :resources then path << resources
+                  else path << args.shift
+                  end
+                when Regexp then path << args.shift
+                when Hash
+                  key, value = want.to_a.first
+                  case key
+                  when :resource then path << resource
+                  when :resources then path << resources
+                  else 
+                    case value
+                    when true then path += args
+                    when String, Symbol, RegExp then path << args.unshift
+                    end
+                  end
+                end
+              end
+            end
           end
           
         end

data/lib/layers/mvc.rb

@@ -1,22 +1,16 @@
 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
+        require 'layers/mvc/extensions'
+        require 'layers/mvc/controllers'
         
         app.auto_create_module( :Models ) do
           include AutoCode
           auto_create_class :Default
-          auto_load :Default, :directories => [:models]
+          auto_load :Default, :directories => [ :models ]
         end
         
         app.auto_eval( :Models ) do
@@ -24,30 +18,36 @@ module Waves
           auto_load true, :directories => [ :models ]
         end
 
-        app.auto_create_module( :Views ) { include AutoCode }
+        app.auto_create_module( :Views ) do
+          include AutoCode
+          auto_create_class :Default, Waves::Views::Base
+          auto_load :Default, :directories => [ :views ]
+        end
         
         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_create_module( :Controllers ) do
+          include AutoCode
+          auto_create_class :Default, Waves::Controllers::Base
+          auto_load :Default, :directories => [ :controllers ]
+        end
         
         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_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

@@ -56,7 +56,7 @@ module Waves
       # <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
+        source = File.dirname(__FILE__) / :providers / orm / :migrations / file
       end
 
       # Given a migration name, returns the path of the file that would be created.

data/lib/layers/orm/{active_record.rb → providers/active_record.rb}

@@ -17,15 +17,10 @@ module Waves
         # - 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)
@@ -66,20 +61,20 @@ module Waves
             model.find(:all)
           end
           
-          def find( id )
-            model.find(id) or not_found
+          def find( name )
+            model.find_by_name(name) or not_found
           end
           
           def create
             model.create( attributes )
           end
           
-          def delete( id )
-            find( id ).destroy
+          def delete( name )
+            find( name ).destroy
           end
           
-          def update( id )
-            instance = find( id )
+          def update( name )
+            instance = find( name )
             instance.update_attributes( attributes )
             instance
           end

data/lib/layers/orm/{active_record → providers/active_record}/tasks/generate.rb

@@ -13,7 +13,7 @@ namespace :generate do
       end
 
       model = <<TEXT
-module #{Waves.application.name}
+module #{app_name}
   module Models
     class #{model_name} < Default
 

data/lib/layers/orm/{active_record → providers/active_record}/tasks/schema.rb

@@ -14,7 +14,7 @@ namespace :schema do
   end
 
   task :connect do
-    Waves.application.database
+    Waves.main.database
     ActiveRecord::Base.logger = Logger.new($stdout)
   end
 

data/lib/layers/orm/{data_mapper.rb → providers/data_mapper.rb}

@@ -1,7 +1,3 @@
-gem 'dm-core', '=0.9.0'
-
-require 'data_mapper'
-
 module Waves
   module Layers
     module ORM
@@ -10,6 +6,9 @@ module Waves
       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])

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