dyoder-waves 0.7.3 → 0.7.6

data/lib/runtime/response_proxy.rb

@@ -1,12 +1,15 @@
 module Waves
 
+  # Mapping actions are evaluated in the context of a ResponseProxy.
   class ResponseProxy
 
     attr_reader :request
 
     include ResponseMixin
 
-    def initialize(request); @request = request; end
+    def initialize(request)
+      @request = request
+    end
 
     def resource( resource, &block )
       @resource = resource; yield.call

data/lib/runtime/server.rb

@@ -1,5 +1,5 @@
 module Waves
-  # You can run the Waves::Server via the +waves-server+ command or via <tt>rake cluster:start</tt>. Run <tt>waves-server --help</tt> for options on the <tt>waves-server</tt> command. The <tt>cluster.start</tt> task use the +mode+ environment parameter to determine which configuration to use. You can define +port+ to run on a single port, or +ports+ (taking an array) to run on multiple ports.
+  # You can run the Waves::Server via the +waves-server+ command or via <tt>rake cluster:start</tt>. Run <tt>waves-server --help</tt> for options on the <tt>waves-server</tt> command. The <tt>cluster:start</tt> task uses the +mode+ environment variable to determine the active configuration. You can define +port+ to run on a single port, or +ports+ (taking an array) to run on multiple ports.
   #
   # *Example*
   #
@@ -17,6 +17,8 @@ module Waves
   #   waves-server -c development -p 2021 -d
   #   waves-server -c development -p 2022 -d
   #
+  # The +cluster:stop+ task stops all of the instances.
+  #
   class Server < Application
 
     # Access the server thread.
@@ -36,8 +38,15 @@ module Waves
       File.write( :log / "#{port}.pid", $$ )
     end
 
+    def trap(signal)
+      Kernel::trap(signal) { yield }
+      Thread.new { loop {sleep 1} } if RUBY_PLATFORM =~ /mswin32/
+    end
+
     # Start and / or access the Waves::Logger instance.
-    def log ; @log ||= Waves::Logger.start ; end
+    def log
+      @log ||= Waves::Logger.start
+    end
 
     # Start the server.
     def start
@@ -47,7 +56,7 @@ module Waves
       handler, options = config.handler
       handler.run( config.application.to_app, options ) do |server|
         @server = server
-        trap('INT') { puts; stop } if @server.respond_to? :stop
+        self.trap('INT') { puts; stop } if @server.respond_to? :stop
       end
     end
 
@@ -70,9 +79,13 @@ module Waves
       def run( options={} )
         @server.stop if @server; @server = new( options ); @server.start
       end
+      
       # Allows us to access the Waves::Server instance.
-      def method_missing(*args); @server.send(*args); end
-      # Probably wouldn't need this if I added a block parameter to method_missing.
+      def method_missing(*args)
+        @server.send(*args)
+      end
+      
+      #-- Probably wouldn't need this if I added a block parameter to method_missing.
       def synchronize(&block) ; @server.synchronize(&block) ; end
     end
 

data/lib/runtime/session.rb

@@ -1,10 +1,16 @@
 module Waves
 
   # Encapsulates the session associated with a given request. A session has an expiration
-  # and path. You must set these in your configuration file. See Waves::Configuration for
-  # more information.
-  #
+  # and path, which must be provided in a Waves::Configuration. Sensible defaults are defined
+  # in Waves::Configurations::Default
   class Session
+    
+    # Concoct a (probably) unique session id
+    def self.generate_session_id 
+      # from Camping ...
+      chars = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+      (0..48).inject(''){|s,x| s+=chars[ rand(chars.length) ] }
+    end
 
     # Create a new session object using the given request. This is not necessarily the
     # same as constructing a new session. The session_id cookie for the request domain
@@ -14,6 +20,15 @@ module Waves
       @request = request
       @data ||= ( File.exist?( session_path  ) ? load_session : {} )
     end
+    
+    # Return the session data as a hash
+    def to_hash
+      @data.to_hash
+    end
+    
+    def self.base_path
+      Waves::Application.instance.config.session[:path]
+    end
 
     # Save the session data. You shouldn't typically have to call this directly, since it
     # is called by Waves::Response#finish.
@@ -34,16 +49,11 @@ module Waves
     private
 
     def session_id
-      @session_id ||= ( @request.cookies['session_id'] || generate_session_id )
-    end
-
-    def generate_session_id # from Camping ...
-      chars = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
-      (0..48).inject(''){|s,x| s+=chars[ rand(chars.length) ] }
+      @session_id ||= ( @request.cookies['session_id'] || Waves::Session.generate_session_id )
     end
 
     def session_path
-      Waves::Application.instance.config.session[:path] / session_id
+      Waves::Session.base_path / session_id
     end
 
     def load_session

data/lib/tasks/cluster.rb

@@ -2,7 +2,8 @@ namespace :cluster do
 
   desc 'Start a cluster of waves applications.'
   task :start do |task|
-    script = USE_WAVES_SRC ? 'bin/waves-server' : 'waves-server'
+    using_waves_src = defined?(WAVES) || ENV['WAVES'] || File.exist( File.dirname(__FILE__) / :waves )
+    script = using_waves_src ? :bin / 'waves-server' : 'waves-server'
     ( Waves::Console.config.ports || [ Waves::Console.config.port ] ).each do |port|
       cmd = "#{script} -p #{port} -c #{ENV['mode']||'development'} -d"
       puts cmd ; `#{cmd}`

data/lib/tasks/generate.rb

@@ -1,15 +1,80 @@
 namespace :generate do
-  desc 'Generate a new model'
-  task :model do |task|
-    template = File.read :models / 'default.rb'
-    File.write( :models / ENV['name'] + '.rb',
-      template.gsub('class Default < Sequel::Model',
-      "class #{ENV['name'].camel_case} < Sequel::Model(:#{ENV['name'].plural})") )
-  end
-  desc 'Generate a new controller'
+
+  desc 'Generate a new controller, with name=<name>'
   task :controller do |task|
-    template = File.read :controllers / 'default.rb'
-    File.write( :controllers / ENV['name'] + '.rb',
-      template.gsub('class Default',"class #{ENV['name'].camel_case}") )
+    name = ENV['name']
+    controller_name = name.camel_case
+    raise "Cannot generate Default yet" if controller_name == 'Default'
+    
+    filename = File.expand_path "controllers/#{name}.rb"
+    if File.exist?(filename)
+      $stderr.puts "#{filename} already exists" 
+      exit
+    end
+
+    controller = <<TEXT
+module #{Waves.application.name}
+  module Controllers
+    class #{controller_name} < Default
+
+    end
   end
 end
+TEXT
+
+    File.write( filename, controller )
+  end
+  
+  desc 'Generate new view, with name=<name>'
+  task :view do |task|
+    name = ENV['name']
+    view_name = name.camel_case
+    raise "Cannot generate Default yet" if view_name == 'Default'
+    
+    filename = File.expand_path "views/#{name}.rb"
+    if File.exist?(filename)
+      $stderr.puts "#{filename} already exists" 
+      exit
+    end
+
+    view = <<TEXT
+module #{Waves.application.name}
+  module Views
+    class #{view_name} < Default
+
+    end
+  end
+end
+TEXT
+
+    File.write( filename, view )
+  end
+ 
+  desc 'Generate a new helper, with name=<name>'
+  task :helper do |task|
+    name = ENV['name']
+    helper_name = name.camel_case
+    raise "Cannot generate Default yet" if helper_name == 'Default'
+    
+    filename = File.expand_path "helpers/#{name}.rb"
+    if File.exist?(filename)
+      $stderr.puts "#{filename} already exists" 
+      exit
+    end
+    
+    helper = <<TEXT
+module #{Waves.application.name}
+  module Helpers
+    module #{helper_name}
+      include Waves::Helpers::Default
+      
+    end
+  end
+end
+TEXT
+
+    File.write( filename, helper )
+  end
+  
+  
+end

data/lib/utilities/hash.rb

@@ -0,0 +1,31 @@
+module Waves
+  module Utilities # :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::Utilities::Hash
+end

data/lib/utilities/inflect.rb

@@ -4,191 +4,107 @@
 # of rules for different languages
 # NOTE: this is NOT implemented yet.
 # plural and singular work directly with the English class
+module Waves
+  module Inflect # :nodoc:
+    module InflectorMethods
+      
+      # Define a general exception.
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
+      end
 
-module Inflect
-  module InflectorMethods
-
-    # Define a general exception.
-    def word(singular, plural=nil)
-      plural = singular unless plural
-      singular_word(singular, plural)
-      plural_word(singular, plural)
-    end
-
-    # Define a singularization exception.
-    def singular_word(singular, plural)
-      @singular_of[plural] = singular
-    end
-
-    # Define a pluralization exception.
-    def plural_word(singular, plural)
-      @plural_of[singular] = plural
-    end
-
-    # Define a general rule.
-    def rule(singular, plural)
-      singular_rule(singular, plural)
-      plural_rule(singular, plural)
-    end
-
-    # Define a singularization rule.
-    def singular_rule(singular, plural)
-      @singular_rules << [singular, plural]
-    end
-
-    # Define a plurualization rule.
-    def plural_rule(singular, plural)
-      @plural_rules << [singular, plural]
-    end
-
-    # Read prepared singularization rules.
-    def singularization_rules
-      return @singularization_rules if @singularization_rules
-      sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
-      @singularization_rules = sorted.collect do |s, p|
-        [ /#{p}$/, "#{s}" ]
+      # Define a singularization exception.
+      def singular_word(singular, plural)
+        @singular_of ||= {}
+        @singular_of[plural] = singular
       end
-    end
 
-    # Read prepared pluralization rules.
-    def pluralization_rules
-      return @pluralization_rules if @pluralization_rules
-      sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
-      @pluralization_rules = sorted.collect do |s, p|
-        [ /#{s}$/, "#{p}" ]
+      # Define a pluralization exception.
+      def plural_word(singular, plural)
+        @plural_of ||= {}
+        @plural_of[singular] = plural
       end
-    end
 
-    #
-    def plural_of
-      @plural_of
-    end
+      # Define a general rule.
+      def rule(singular, plural)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+      end
 
-    #
-    def singular_of
-      @singular_of
-    end
+      # Define a singularization rule.
+      def singular_rule(singular, plural)
+        (@singular_rules ||= []) << [singular, plural]
+      end
 
-    # Convert an English word from plurel to singular.
-    #
-    #   "boys".singular      #=> boy
-    #   "tomatoes".singular  #=> tomato
-    #
-    def singular(word)
-      if result = singular_of[word]
-        return result.dup
+      # Define a plurualization rule.
+      def plural_rule(singular, plural)
+        (@plural_rules ||= []) << [singular, plural]
       end
-      result = word.dup
-      singularization_rules.each do |(match, replacement)|
-        break if result.gsub!(match, replacement)
+
+      # Read prepared singularization rules.
+      def singularization_rules
+        @singular_rules ||= []
+        return @singularization_rules if @singularization_rules
+        sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
+        @singularization_rules = sorted.collect do |s, p|
+          [ /#{p}$/, "#{s}" ]
+        end
       end
-      return result
-    end
 
-    # Convert an English word from singular to plurel.
-    #
-    #   "boy".plural     #=> boys
-    #   "tomato".plural  #=> tomatoes
-    #
-    def plural(word)
-      if result = plural_of[word]
-        return result.dup
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        @plural_rules ||= []
+        return @pluralization_rules if @pluralization_rules
+        sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
+        @pluralization_rules = sorted.collect do |s, p|
+          [ /#{s}$/, "#{p}" ]
+        end
       end
-      #return self.dup if /s$/ =~ self # ???
-      result = word.dup
-      pluralization_rules.each do |(match, replacement)|
-        break if result.gsub!(match, replacement)
+
+      #
+      def plural_of
+        @plural_of ||= {}
       end
-      return result
-    end
-  end
 
-  class English
-    @singular_of = {}
-    @plural_of = {}
+      #
+      def singular_of
+        @singular_of ||= {}
+      end
 
-    @singular_rules = []
-    @plural_rules = []
+      # Convert an English word from plural to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        singularization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
 
-    class << self
-      include InflectorMethods
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      def plural(word)
+        if result = plural_of[word]
+          return result.dup
+        end
+        #return self.dup if /s$/ =~ self # ???
+        result = word.dup
+        pluralization_rules.each do |(match, replacement)|
+          break if result.gsub!(match, replacement)
+        end
+        return result
+      end
     end
-
-    # One argument means singular and plural are the same.
-    word 'equipment'
-    word 'information'
-    word 'money'
-    word 'species'
-    word 'series'
-    word 'fish'
-    word 'sheep'
-    word 'moose'
-    word 'hovercraft'
-
-    # Two arguments defines a singular and plural exception.
-    word 'Swiss'     , 'Swiss'
-    word 'life'      , 'lives'
-    word 'wife'      , 'wives'
-    word 'virus'     , 'viri'
-    word 'octopus'   , 'octopi'
-    word 'cactus'    , 'cacti'
-    word 'goose'     , 'geese'
-    word 'criterion' , 'criteria'
-    word 'alias'     , 'aliases'
-    word 'status'    , 'statuses'
-    word 'axis'      , 'axes'
-    word 'crisis'    , 'crises'
-    word 'testis'    , 'testes'
-    word 'child'     , 'children'
-    word 'person'    , 'people'
-    word 'potato'    , 'potatoes'
-    word 'tomato'    , 'tomatoes'
-    word 'buffalo'   , 'buffaloes'
-    word 'torpedo'   , 'torpedoes'
-    word 'quiz'      , 'quizes'
-    word 'matrix'    , 'matrices'
-    word 'vertex'    , 'vetices'
-    word 'index'     , 'indices'
-    word 'ox'        , 'oxen'
-    word 'mouse'     , 'mice'
-    word 'louse'     , 'lice'
-    word 'thesis'    , 'theses'
-    word 'thief'     , 'thieves'
-    word 'analysis'  , 'analyses'
-
-    # One-way singularization exception (convert plural to singular).
-    singular_word 'cactus', 'cacti'
-
-    # General rules.
-    rule 'hive' , 'hives'
-    rule 'rf'   , 'rves'
-    rule 'af'   , 'aves'
-    rule 'ero'  , 'eroes'
-    rule 'man'  , 'men'
-    rule 'ch'   , 'ches'
-    rule 'sh'   , 'shes'
-    rule 'ss'   , 'sses'
-    rule 'ta'   , 'tum'
-    rule 'ia'   , 'ium'
-    rule 'ra'   , 'rum'
-    rule 'ay'   , 'ays'
-    rule 'ey'   , 'eys'
-    rule 'oy'   , 'oys'
-    rule 'uy'   , 'uys'
-    rule 'y'    , 'ies'
-    rule 'x'    , 'xes'
-    rule 'lf'   , 'lves'
-    rule 'us'   , 'uses'
-    rule ''     , 's'
-
-    # One-way singular rules.
-    singular_rule 'of' , 'ofs' # proof
-    singular_rule 'o'  , 'oes' # hero, heroes
-    singular_rule 'f'  , 'ves'
-
-    # One-way plural rules.
-    plural_rule 'fe' , 'ves' # safe, wife
-    plural_rule 's'  , 'ses'
   end
 end
-