waves 0.8.2 → 0.9.0

data/lib/{ext → waves/ext}/integer.rb

@@ -1,20 +1,35 @@
 module Waves
   module Ext
     module Integer
+      # @todo: we need to credit where this code came from originally, if anywhere.
       def seconds ; self ; end
+      alias_method :second, :seconds
       def minutes ; self * 60 ; end
+      alias_method :minute, :minutes
       def hours ; self * 60.minutes ; end
+      alias_method :hour, :hours
       def days ; self * 24.hours ; end
+      alias_method :day, :days
       def weeks ; self * 7.days ; end
+      alias_method :week, :weeks
       def bytes ; self ; end
+      alias_method :byte, :bytes
       def kilobytes ; self * 1024 ; end
+      alias_method :kilobyte, :kilobytes
       def megabytes ; self * 1024.kilobytes ; end
+      alias_method :megabyte, :megabytes
       def gigabytes ; self * 1024.megabytes ; end
+      alias_method :gigabyte, :gigabytes
       def terabytes ; self * 1024.gigabytes ; end
+      alias_method :terabyte, :terabytes
       def petabytes ; self * 1024.terabytes ; end
+      alias_method :petabyte, :petabytes
       def exabytes ; self * 1024.petabytes ; end
+      alias_method :exabyte, :exabytes
       def zettabytes ; self * 1024.exabytes ; end
+      alias_method :zettabyte, :zettabytes
       def yottabytes ; self * 1024.zettabytes ; end
+      alias_method :yottabyte, :yottabytes
       def to_delimited(delim=',')
         self.to_s.gsub(/(\d)(?=(\d\d\d)+$)/, "\\1#{delim}")
       end
@@ -22,6 +37,6 @@ module Waves
   end
 end
 
-class Integer # :nodoc:
+class Integer  # :nodoc:
   include Waves::Ext::Integer
 end

data/lib/{ext → waves/ext}/kernel.rb

@@ -1,20 +1,16 @@
 module Kernel
-  unless respond_to?(:debugger)
+  
+  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)
+  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 → waves/ext}/module.rb

@@ -10,11 +10,11 @@ module Waves
       # 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
 end
 
 class Module # :nodoc:
   include Waves::Ext::Module
-end
+end

data/lib/{ext → waves/ext}/object.rb

@@ -1,6 +1,7 @@
 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.
@@ -14,6 +15,7 @@ module Waves
         end
         ret
       end
+            
     end
   end
 end

data/lib/waves/ext/string.rb

@@ -0,0 +1,73 @@
+# Utility methods mixed into String.
+module Waves::Ext::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
+  
+  #
+  # Originally based on English gem. That code was (a) deprecated,
+  # (b) used confusing naming conventions (based on Rails original
+  # names, like 'camelize' instead of 'camel_case'), and (c) was
+  # not thread-safe (making use of $ variables in gsub).
+  #
+  # I have dispensed with things like "modulize" since (a) the 
+  # meaning of that is sort of vague and (b) it is easy (and
+  # considerably clearer) to just use a method chain, like
+  # this: module.name.snake_case.fqn2path or (the reverse):
+  # path.camel_case.path2fqn
+  #
+  
+  def lowercase ; downcase ; end
+  alias_method :lower_case, :lowercase
+  def uppercase ; upcase ; end
+  alias_method :upper_case, :uppercase
+  def titlecase ; gsub( /\b\w/ ) { |x| x.upcase } ; end
+  alias_method :title_case, :titlecase
+  def fqn2path ; gsub(/::/, '/') ; end
+  def basename ; gsub(%r{^.*(::|/)}, '') ; end
+  def in_words ; gsub(%r{_|/|::}, ' ') ; end
+  def path2fqn ; gsub(%r{/}, '::') ; end
+
+  def snakecase
+    gsub( /(^|\W)[A-Z]/) { |x| x.downcase }.
+    gsub(/[A-Z]/) { |x| "_#{x.downcase}" }
+  end
+  alias_method :snake_case, :snakecase
+
+  def camelcase( style = :upper )
+    if style == :upper
+      gsub( /_\w/ ) { |x| x[1,1].upcase }.gsub(/(^|\W)\w/) { |x| x.upcase }
+    else
+      gsub( /_\w/ ) { |x| x[1,1].upcase }.gsub(/(^|\W)\w/) { |x| x.downcase }
+    end
+  end
+  alias_method :camel_case, :camelcase
+
+  def ordinal
+    gsub(/\d+$/) { |x|
+      x = x.to_i
+      if (11..13).include?(x % 100)
+        "#{i}th"
+      else
+        case x % 10
+        when 1 then "#{x}st"
+        when 2 then "#{x}nd"
+        when 3 then "#{x}rd"
+        else "#{x}th"
+        end
+      end
+    }
+  end
+
+end
+
+class String  # :nodoc:
+  include Waves::Ext::String
+end

data/lib/{ext → waves/ext}/symbol.rb

@@ -5,7 +5,6 @@ class Symbol
   #   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/waves/ext/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def to_http_timestamp
+    clone.gmtime.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+  end
+end

data/lib/{foundations → waves/foundations}/classic.rb

@@ -10,49 +10,37 @@ module Waves
       def self.included( app )
 
         require 'autocode'
-        require 'layers/mvc'
-        require 'layers/inflect/english'
-        require 'helpers/extended'
-        require 'layers/renderers/erubis'
-        require 'layers/renderers/markaby'
+        require 'waves/layers/mvc'
+        require 'waves/layers/text/inflect/english'
+        require 'waves/views/templated'
+        require 'waves/layers/renderers/erubis'
         
         app.module_eval do
 
           include AutoCode
           
           app.auto_create_module( :Configurations ) do
-            include AutoCode
             auto_create_class :Default, Waves::Configurations::Default
             auto_load :Default, :directories => [ :configurations ]
-          end
-
-          app.auto_eval( :Configurations ) do
-            auto_create_class true, app::Configurations::Default
+            auto_create_class true, :Default
             auto_load true, :directories => [ :configurations ]
           end
 
           app.auto_create_module( :Resources ) do
-            include AutoCode
             auto_create_class :Default, Waves::Resources::Base
             auto_load :Default, :directories => [ :resources ]
-          end
-
-          app.auto_eval( :Resources ) do
-            auto_create_class true, app::Resources::Default
+            auto_create_class true, :Default
             auto_load true, :directories => [ :resources ]
-            auto_eval :Map do
-              
-              handler( Waves::Dispatchers::NotFoundError ) do
+            auto_eval :Server do
+              handler( Waves::Response::ClientErrors::NotFound ) do
                 app::Views::Errors.new( request ).not_found_404
               end
-
             end
           end
 
-          include Waves::Layers::Inflect::English
+          include Waves::Layers::Text::Inflect::English
           include Waves::Layers::MVC
           include Waves::Renderers::Erubis   
-          include Waves::Renderers::Markaby   
           
         end
         

data/lib/{foundations → waves/foundations}/compact.rb

@@ -4,15 +4,18 @@ module Waves
       def self.included( app )
         app.module_eval {
           const_set( :Resources, Module.new {
-            const_set( :Map, Class.new { 
+            const_set( :Server, Class.new {
+
               include Waves::Resources::Mixin
-              handler( Exception ) {
-                Waves::Views::Errors.new( request ).server_error_500
-              }
 
-              handler( Waves::Dispatchers::NotFoundError ) {
-                Waves::Views::Errors.new( request ).not_found_404
-              }
+              handler( Exception ) do |e|
+                Waves.debug? ? raise( e ) : Waves::Views::Errors.new( request ).server_error_500
+              end
+
+              handler( Waves::Response::ClientErrors::NotFound ) do |e|
+                Waves.debug? ? raise( e ) : Waves::Views::Errors.new( request ).not_found_404
+              end
+
             })
           })
           const_set( :Configurations, Module.new {
@@ -20,25 +23,17 @@ module Waves
               log :level => :debug
               host '127.0.0.1'
               port 3000
+              use Rack::Session::Pool, :expire_after => 1.day
+              resource app::Resources::Server
+              dispatcher ::Waves::Dispatchers::Default
               server Waves::Servers::Mongrel
-              resource app::Resources::Map
             })
             const_set( :Production, Class.new( self::Development ) {
+              debug false
               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

data/lib/waves/foundations/rest.rb

@@ -0,0 +1,311 @@
+require "ostruct"
+
+require "waves/ext/string"
+require "waves/resources/mixin"
+
+module Waves
+  module Foundations
+
+    module REST
+
+      # Some kind of a malformed resource definition
+      #
+      class BadDefinition < StandardError; end
+
+
+      # Applications are formal, rather than ad-hoc Waves apps.
+      #
+      class Application
+
+        class << self
+
+          # File that this Application is currently loading if any.
+          attr_reader   :loading
+
+          # Resources this application is composed of.
+          attr_reader   :resources
+
+        end
+
+        # Associate mountpoint with a file path for resource.
+        #
+        # Path is stored expanded to absolute for matching.
+        # You can leave the .rb out if you really like.
+        #
+        # @see  .look_in
+        #
+        def self.at(mountpoint, path)
+          @composition << [path, mountpoint]
+        end
+
+        # Resource composition block.
+        #
+        # In this block, the Application defines all of the
+        # resources it is composed of (and their prefixes or
+        # "mountpoints.") The resources themselves are not
+        # defined here.
+        #
+        # The order of composition is stored and used.
+        #
+        # @see  .at
+        # @see  ConvenienceMethods#resource
+        #
+        def self.composed_of(&block)
+          @composition ||= []
+          instance_eval &block
+
+          mounts = const_set :Mounts, Class.new(Waves::Resources::Base)
+
+          # Only construct the Hash here to retain order for .on()s
+          @resources ||= {}
+
+          @composition.each {|path, mountpoint|
+            path = path.to_s.snake_case if Symbol === path
+
+            path << ".rb" unless path =~ /\.rb$/
+
+            found = if @look_in
+                      @look_in.find {|prefix|
+                        candidate = File.expand_path File.join(prefix, path)
+                        break candidate if File.exist? candidate
+                      }
+                    else
+                      path = File.expand_path path
+                      path if File.exist?(path)
+                    end
+
+            raise ArgumentError, "Path #{path} does not exist!" unless found
+
+            # Resource will register itself when loaded
+            @resources[found] = OpenStruct.new  :mountpoint => mountpoint,
+                                                :actual => nil
+
+            # This, ladies and gentlemen, is evil.
+            mounts.on(true, mountpoint) {
+              res = Waves.main.load(found)
+
+              # TODO: This must be deterministically inserted as
+              #       a replacement of the old one.
+              mounts.on(true, mountpoint) { to res }
+              to res
+            }
+          }
+        end
+
+        # Declare and load layout rendering support.
+        #
+        # For each MIME type given, / are treated as directory
+        # separators and + are converted to spaces (just in case.)
+        #
+        # Pattern for constant conversion is replacing any \W
+        # with :: and capitalising all resulting names.
+        #
+        # TODO: Provide a way to give some root to load from.
+        #       Just as last parameter being hash probably OK. --rue
+        #
+        def self.layouts_for(*types)
+          @layouts ||= {}
+
+          const_set :Layouts, Module.new unless const_defined? :Layouts
+
+          basedir = if Hash === types.last
+                      types.pop[:in]
+                    else
+                      File.join Dir.pwd, "layouts"
+                    end
+
+          types.each {|t|
+            require File.expand_path(File.join(basedir, *t.split("/")) + ".rb")
+            @layouts[t] = t.split(/\W+/).inject(const_get :Layouts) {|mod, name|
+                            mod.const_get name.capitalize
+                          }
+          }
+        end
+
+        # Override normal loading to access file being loaded.
+        #
+        # Used by the first-load hook, see .composed_of.
+        # Returns the newly loaded resource.
+        #
+        def self.load(path)
+          @loading = path
+          Kernel.load path
+
+          @resources[path].actual
+
+        ensure
+          @loading = nil
+        end
+
+        # Path prefixes to look for resource files under.
+        #
+        # Optional trailing /, one or more needed. Each is
+        # checked in the order given.
+        #
+        def self.look_in(*prefixes)
+          @look_in = prefixes
+        end
+
+        # Allow resource to register itself when loaded.
+        #
+        # The path-indexed entry is completed with the actual resource
+        # and a mirror version is created, indexed by the resource itself.
+        #
+        # @todo Is there any point trying to add better failure
+        #       if the path is unknown? Probably not. --rue
+        #
+        def self.register(resource)
+          entry = @resources[@loading]
+          entry.actual = resource
+
+          # Mirror
+          @resources[resource] = OpenStruct.new :mountpoint => entry.mountpoint,
+                                                :path => @loading
+        end
+
+        # Construct and possibly override URL for a resource.
+        #
+        # @todo This may be obsolete, move to registration? --rue
+        #
+        def self.url_for(resource, pathspec)
+          info = Waves.main.resources[resource]
+          info.mountpoint + pathspec
+        end
+
+      end
+
+      # Base class to use for resources.
+      #
+      # Mainly here for simple access to some convenience
+      # methods.
+      #
+      # @todo Should maybe insulate the term -> HTTP method
+      #       mapping a bit more. Or less. --rue
+      #
+      class Resource
+        # @todo Direct include/extend to avoid having to use
+        #       Mixin. It is cumbersome to glue in at this
+        #       stage. --rue
+        include ResponseMixin, Functor::Method
+        extend  Resources::Mixin::ClassMethods
+
+        # Creatability definition block (POST)
+        #
+        # @see  .representation
+        #
+        def self.creatable(&block)
+          raise BadDefinition, "No .url_of_form specified!" unless @pathspec
+
+          @method = :post
+          instance_eval &block
+        ensure
+          @method = nil
+        end
+
+        # Introduce new MIME type and its extension(s)
+        #
+        # This is used to allow resources to differentiate between
+        # different kinds of representations (or content types.)
+        # For example, a Wiki page resource may introduce a MIME
+        # type for an "editable" representation, which then allows
+        # producing the appropriate editor interface. The MIME types
+        # added thusly should follow the normal semantics, which means
+        # that usually they will be of the form "application/vnd.somestring".
+        # As an example, the Unspecified MIME type is defined in Waves
+        # as "vnd.com.rubywaves.unspecified".
+        #
+        # The users can communicate the desired MIME type either the
+        # correct way of using the Accept header or, commonly with a
+        # web browser, by using the extension.
+        #
+        def self.introduce_mime(type, options)
+          exts = Array(options[:exts])
+          raise ArgumentError, "Must give file extensions for MIME!" if exts.empty?
+
+          Waves::MimeExts[type] += exts
+          Waves::MimeExts[type].uniq!
+
+          exts.each {|ext|
+            Waves::MimeTypes[ext] << type
+            Waves::MimeTypes[ext].uniq!
+          }
+        end
+
+        # Representation definition block
+        #
+        def self.representation(*types, &block)
+          # @todo Faking it.
+          on(@method, @pathspec, :requested => types) {}
+        end
+
+        # URL format specification.
+        #
+        # The resource defines its own parts, but the app
+        # may provide a prefix or even completely override
+        # its selection (so long as it can provide all the
+        # named captures the resource is expecting, which
+        # means that type of override is rare in practice.
+        #
+        def self.url_of_form(spec)
+          @pathspec = Application.url_for self, spec
+        end
+
+        # Viewability definition block (GET)
+        #
+        # @see  .representation
+        #
+        def self.viewable(&block)
+          raise BadDefinition, "No .url_of_form specified!" unless @pathspec
+
+          @method = :get
+          instance_eval &block
+        ensure
+          @method = nil
+        end
+      end
+
+      # Discrete set of methods to include globally.
+      #
+      module ConvenienceMethods
+
+        # Application definition block.
+        #
+        def application(name, &block)
+          app = Class.new Application, &block
+
+          if app.resources.nil? or app.resources.empty?
+            raise BadDefinition, "No resource composition!"
+          end
+
+          mod = if Module === self then self else Object end
+          mod.const_set name, app
+
+          Waves << app
+        end
+
+        # Resource definition block.
+        #
+        # @todo Must change the Waves.main to *current* app. --rue
+        #
+        def resource(name, &block)
+          mod = if Module === self then self else Object end
+
+          res = mod.const_set name, Class.new(Resource)
+
+          Waves.main.register res
+
+          # We must eval this, because the constant really needs
+          # to be defined at the point we are running the body
+          # code. --rue
+          res.instance_eval &block
+        end
+
+      end
+
+    end   # REST
+
+  end
+end
+
+include Waves::Foundations::REST::ConvenienceMethods
+