waves-edge 2009.03.10.13.14

data/lib/ext/float.rb

@@ -0,0 +1,13 @@
+module Waves
+  module Ext
+    module Float
+      def to_delimited(delim=',')
+        self.to_s.gsub(/(\d)(?=(\d\d\d)+\.)/, "\\1#{delim}")
+      end
+    end
+  end
+end
+
+class Float # :nodoc:
+  include Waves::Ext::Float
+end

data/lib/ext/hash.rb

@@ -0,0 +1,31 @@
+module Waves
+  module Ext # :nodoc:
+    
+    # Utility methods mixed into Hash.
+    module Hash
+      
+      # Return a copy of the hash where all keys have been converted to strings.
+      def stringify_keys
+        inject({}) do |options, (key, value)|
+          options[key.to_s] = value
+          options
+        end
+      end
+
+      # Destructively convert all keys to symbols.
+      def symbolize_keys!
+        keys.each do |key|
+          unless key.is_a?(Symbol)
+            self[key.to_sym] = self[key]
+            delete(key)
+          end
+        end
+        self
+      end
+    end
+  end
+end
+
+class Hash # :nodoc:
+  include Waves::Ext::Hash
+end

data/lib/ext/integer.rb

@@ -0,0 +1,27 @@
+module Waves
+  module Ext
+    module Integer
+      def seconds ; self ; end
+      def minutes ; self * 60 ; end
+      def hours ; self * 60.minutes ; end
+      def days ; self * 24.hours ; end
+      def weeks ; self * 7.days ; end
+      def bytes ; self ; end
+      def kilobytes ; self * 1024 ; end
+      def megabytes ; self * 1024.kilobytes ; end
+      def gigabytes ; self * 1024.megabytes ; end
+      def terabytes ; self * 1024.gigabytes ; end
+      def petabytes ; self * 1024.terabytes ; end
+      def exabytes ; self * 1024.petabytes ; end
+      def zettabytes ; self * 1024.exabytes ; end
+      def yottabytes ; self * 1024.zettabytes ; end
+      def to_delimited(delim=',')
+        self.to_s.gsub(/(\d)(?=(\d\d\d)+$)/, "\\1#{delim}")
+      end
+    end
+  end
+end
+
+class Integer # :nodoc:
+  include Waves::Ext::Integer
+end

data/lib/ext/kernel.rb

@@ -0,0 +1,20 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call waves-server --debugger to do load it).
+    def debugger
+      Waves::Logger.info "Debugger invoked but not loaded. Start server with --debugger to enable."
+    end
+  end
+
+  unless respond_to?(:engine)
+    # 'engine' exists to provide a quick and easy (and MRI-compatible!) interface to the RUBY_ENGINE constant
+    def engine; defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'; end
+  end
+  
+  def safe_trap(*signals)
+    signals.each { |s| trap(s) { yield } }
+    Thread.new { loop { sleep 1 } } if RUBY_PLATFORM =~ /mswin32/
+  end
+      
+  
+end

data/lib/ext/module.rb

@@ -0,0 +1,20 @@
+module Waves
+  module Ext
+    module Module
+
+      def basename ; self.name.split('::').last || '' ; end
+      def rootname ; self.name.split('::').first ; end
+      def root ; eval( "::#{self.rootname}" ) ; end
+
+      # Just a convenience method for dynamically referencing submodules. Note that
+      # you cannot do const_get, because that will also attempt to deref the cname
+      # at global scope. So it is more efficient to just use eval.
+      def []( cname ) ; eval( "self::#{cname.to_s.camel_case}" ) ; end
+      
+    end
+  end  
+end
+
+class Module # :nodoc:
+  include Waves::Ext::Module
+end

data/lib/ext/object.rb

@@ -0,0 +1,33 @@
+module Waves
+  module Ext
+    module Object
+      # This is an extremely powerful little function that will be built-in to Ruby 1.9.
+      # This version is from Mauricio Fernandez via ruby-talk. Works like instance_eval
+      # except that you can pass parameters to the block.
+      def instance_exec(*args, &block)
+        mname = "__instance_exec_#{Thread.current.object_id.abs}"
+        class << self; self end.class_eval{ define_method(mname, &block) }
+        begin
+          ret = send(mname, *args)
+        ensure
+          class << self; self end.class_eval{ undef_method(mname) } rescue nil
+        end
+        ret
+      end
+      
+      def cache_method_missing(name, method_body, *args, &block)
+        self.class.module_eval <<-METHOD
+          def #{name}(*args, &block)
+            #{method_body}
+          end
+        METHOD
+        self.send(name, *args, &block)
+      end
+      
+    end
+  end
+end
+
+class Object # :nodoc:
+  include Waves::Ext::Object
+end

data/lib/ext/string.rb

@@ -0,0 +1,20 @@
+# Utility methods mixed into String.
+    
+class String
+  
+  # Syntactic sugar for using File.join to concatenate the argument to the receiver.
+  #
+  #   require "lib" / "utilities" / "string"
+  #
+  # The idea is not original, but we can't remember where we first saw it.
+  # Waves::Ext::Symbol defines the same method, allowing for :files / 'afilename.txt'
+  #
+  
+  def / ( s ) ; File.join( self, s.to_s ); end
+  
+  alias_method :lower_camel_case, :subcamelcase
+  alias_method :camel_case, :camelcase
+  alias_method :snake_case, :snakecase
+  alias_method :title_case, :titlecase
+
+end

data/lib/ext/symbol.rb

@@ -0,0 +1,11 @@
+class Symbol
+
+  # Syntactic sugar for using File.join to concatenate the argument to the receiver.
+  #
+  #   require :lib / :utilities / :string
+  #
+  # The idea is not original, but we can't remember where we first saw it.
+  # Waves::Ext::Symbol defines the same method, allowing for :files / 'afilename.txt'
+
+  def / ( s ) ; File.join( self.to_s, s.to_s ) ; end
+end

data/lib/ext/tempfile.rb

@@ -0,0 +1,5 @@
+require 'tempfile'
+class Tempfile
+  # override method to prevent problem uploading files with Rack
+  def ==(other) ; eql?(other) || super ; end
+end

data/lib/foundations/classic.rb

@@ -0,0 +1,59 @@
+module Waves
+  module Foundations
+    
+    # Provides Sun MVC features for your application.
+    # Includes ERb-style templates. You can also include others via Renderer Layers.
+    # It does NOT include a default ORM. Use an ORM Layer for that.
+    
+    module Classic
+
+      def self.included( app )
+
+        gem 'dyoder-autocode', '~> 1.0.1'
+        require 'autocode'
+        require 'layers/mvc'
+        require 'layers/inflect/english'
+        require 'helpers/extended'
+        require 'layers/renderers/erubis'
+        require 'layers/renderers/markaby'
+        
+        app.module_eval do
+
+          include AutoCode
+          
+          app.auto_create_module( :Configurations ) do
+            auto_create_class :Default, Waves::Configurations::Default
+            auto_load :Default, :directories => [ :configurations ]
+            auto_create_class true, :Default
+            auto_load true, :directories => [ :configurations ]
+          end
+
+          app.auto_create_module( :Resources ) do
+            auto_create_class :Default, Waves::Resources::Base
+            auto_load :Default, :directories => [ :resources ]
+            auto_create_class true, :Default
+            auto_load true, :directories => [ :resources ]
+            auto_eval :Map do
+              
+              handler( Waves::Dispatchers::NotFoundError ) do
+                app::Views::Errors.new( request ).not_found_404
+              end
+
+            end
+          end
+
+          include Waves::Layers::Inflect::English
+          include Waves::Layers::MVC
+          include Waves::Renderers::Erubis   
+          include Waves::Renderers::Markaby   
+          
+        end
+        
+        Waves << app
+        
+      end
+    end
+  end
+end
+
+

data/lib/foundations/compact.rb

@@ -0,0 +1,52 @@
+module Waves
+  module Foundations
+    module Compact
+      def self.included( app )
+        app.module_eval {
+          const_set( :Resources, Module.new {
+            const_set( :Map, Class.new { 
+              include Waves::Resources::Mixin
+              
+              handler( Exception ) do |e|
+                Waves.debug? ? raise( e ) : Waves::Views::Errors.new( request ).server_error_500
+              end
+              
+              handler( Waves::Dispatchers::NotFoundError ) do |e|
+                Waves.debug? ? raise( e ) : Waves::Views::Errors.new( request ).not_found_404
+              end
+              
+            })
+          })
+          const_set( :Configurations, Module.new {
+            const_set( :Development, Class.new( Waves::Configurations::Default ) {
+              log :level => :debug
+              host '127.0.0.1'
+              port 3000
+              server Waves::Servers::Mongrel
+              resource app::Resources::Map
+            })
+            const_set( :Production, Class.new( self::Development ) {
+              log :level => :error, :output => ( "log.#{$$}" ), :rotation => :weekly
+              port 80
+              host '0.0.0.0'
+              server Waves::Servers::Mongrel
+              application {
+                use Rack::Session::Cookie, :key => 'rack.session',
+                  # :domain => 'foo.com',
+                  :path => '/',
+                  :expire_after => 2592000,
+                  :secret => 'Change it'
+
+                run ::Waves::Dispatchers::Default.new
+              }
+              
+            })
+          })
+        }
+        Waves << app
+      end
+    end
+  end
+end
+
+

data/lib/helpers/basic.rb

@@ -0,0 +1,11 @@
+module Waves
+  module Helpers
+    module Basic
+      attr_reader :request
+      include Waves::ResponseMixin
+      
+      def app ; Waves.main ; end
+      
+    end
+  end
+end

data/lib/helpers/doc_type.rb

@@ -0,0 +1,34 @@
+module Waves
+  
+  module Helpers
+
+    module DocType
+
+      DOCTYPES = {
+        :html3 => "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">\n",
+        :html4_transitional =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" " <<
+           "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
+        :html4_strict =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" " <<
+            "\"http://www.w3.org/TR/html4/strict.dtd\">\n",
+        :html4_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/html4/frameset.dtd\">\n",
+        :xhtml1_transitional =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n",
+        :xhtml1_strict =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
+        :xhtml1_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">\n",
+        :xhtml2 => "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
+      }
+
+      def doctype(type) ; self << DOCTYPES[type||:html4_strict] ; end
+      
+    end
+  end
+end

data/lib/helpers/extended.rb

@@ -0,0 +1,21 @@
+require 'helpers/basic'
+require 'helpers/doc_type'
+require 'helpers/layouts'
+require 'helpers/formatting'
+require 'helpers/model'
+require 'helpers/view'
+require 'helpers/form'
+
+module Waves
+  module Helpers
+    module Extended
+      include Waves::Helpers::Basic
+      include Waves::Helpers::DocType
+      include Waves::Helpers::Layouts
+      include Waves::Helpers::Formatting
+      include Waves::Helpers::Model
+      include Waves::Helpers::View
+      include Waves::Helpers::Form
+    end
+  end
+end

data/lib/helpers/form.rb

@@ -0,0 +1,42 @@
+module Waves
+
+  module Helpers
+
+    # Form helpers are used in generating forms. Since Markaby already provides Ruby
+    # methods for basic form generation, the focus of this helper is on providing templates
+    # to handle things that go beyond the basics. You must define a form template
+    # directory with templates for each type of form element you wish to use. The names
+    # of the template should match the +type+ option provided in the property method.
+    #
+    # For example, this code:
+    #
+    #   property :name => 'blog.title', :type => :text, :value => @blog.title
+    #
+    # will invoke the +text+ form view (the template in +templates/form/text.mab+),
+    # passing in the name ('blog.title') and the value (@blog.title) as instance variables.
+    #
+    # These helpers work best with Markaby, but may work for other Renderers.
+    # 
+    
+    module Form
+
+      # This method really is a place-holder for common wrappers around groups of
+      # properties. You will usually want to override this. As is, it simply places
+      # a DIV element with class 'properties' around the block.
+      def properties(&block)
+        div.properties do
+          yield
+        end
+      end
+
+      # Invokes the form view for the +type+ given in the option.
+      def property( options )
+        self << view( :form, options[:type], options )
+      end
+
+
+    end
+
+  end
+
+end

data/lib/helpers/formatting.rb

@@ -0,0 +1,30 @@
+require 'redcloth'
+module Waves
+  module Helpers
+
+    # Formatting helpers are used to convert specialized content, like Markaby or
+    # Textile, into valid HTML. It also provides common escaping functions.
+    module Formatting
+
+      # Escape a string as HTML content.
+      def escape_html(s); Rack::Utils.escape_html(s); end
+
+      # Escape a URI, converting quotes and spaces and so on.
+      def escape_uri(s); Rack::Utils.escape(s); end
+
+      # Treat content as Markaby and evaluate (only works within a Markaby template).
+      # Used to pull Markaby content from a file or database into a Markaby template.
+      def markaby( content ); self << eval( content ); end
+
+      # 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
+        self << ::RedCloth.new( content ).to_html
+      end
+
+    end
+  end
+end