waves-stable 0.7.7

data/lib/tasks/cluster.rb

@@ -0,0 +1,26 @@
+namespace :cluster do
+
+  desc 'Start a cluster of waves applications.'
+  task :start do |task|
+    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}`
+    end
+  end
+
+  desc 'Stop a cluster of waves applications.'
+  task :stop do |task|
+     Dir[ :log / '*.pid' ].each do |pidfile|
+       pid = File.read(pidfile).to_i
+       puts "Stopping process #{pid} ..."
+       Process.kill( 'INT', pid ) rescue nil
+    end
+  end
+
+  desc 'Restart a cluster of waves applications.'
+  task :restart => [ :stop, :start ] do |task|
+  end
+
+end

data/lib/tasks/gem.rb

@@ -0,0 +1,31 @@
+namespace :gem do
+  desc "freeze a gem using gem=<gem name> [version=<gem version>]"
+  task :freeze do
+    raise "No gem specified" unless gem_name = ENV['gem']
+
+    require 'rubygems'
+    Gem.manage_gems
+
+    gem = (version = ENV['version']) ?
+      Gem.cache.search(gem_name, "= #{version}").first :
+      Gem.cache.search(gem_name).sort_by { |g| g.version }.last
+
+    version ||= gem.version.version rescue nil
+
+    target_dir = File.join(Waves::Configurations::Default.root, 'gems')
+    mkdir_p target_dir
+    sh "gem install #{gem_name} --version #{version} -i #{target_dir} --no-rdoc --no-ri"
+
+    puts "Unpacked #{gem_name} #{version} to '#{target_dir}'"
+  end
+
+  desc "unfreeze a gem using gem=<gem>"
+  task :unfreeze do
+    raise "No gem specified" unless gem_name = ENV['gem']
+
+    target_dir = File.join(Waves::Configurations::Default.root, 'gems')
+    ENV['GEM_HOME'] = target_dir # no install_dir option for gem uninstall
+
+    sh "gem uninstall #{gem_name}"
+  end
+end

data/lib/tasks/generate.rb

@@ -0,0 +1,80 @@
+namespace :generate do
+
+  desc 'Generate a new controller, with name=<name>'
+  task :controller do |task|
+    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

@@ -0,0 +1,110 @@
+# Much love to Facets (more specifically English) for this module
+# http://english.rubyforge.org/
+# changed slightly in the hopes of one day implementing a different set
+# 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
+
+      # Define a singularization exception.
+      def singular_word(singular, plural)
+        @singular_of ||= {}
+        @singular_of[plural] = singular
+      end
+
+      # Define a pluralization exception.
+      def plural_word(singular, plural)
+        @plural_of ||= {}
+        @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
+        @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
+
+      # 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
+
+      #
+      def plural_of
+        @plural_of ||= {}
+      end
+
+      #
+      def singular_of
+        @singular_of ||= {}
+      end
+
+      # 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
+
+      # 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
+  end
+end

data/lib/utilities/integer.rb

@@ -0,0 +1,24 @@
+module Waves
+  module Utilities
+    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
+    end
+  end
+end
+
+class Integer # :nodoc:
+  include Waves::Utilities::Integer
+end

data/lib/utilities/module.rb

@@ -0,0 +1,21 @@
+module Waves
+  module Utilities
+    module Module
+      # This comes in handy when you are trying to do meta-programming with modules / classes
+      # that may be nested within other modules / classes. I think I've seen it defined in
+      # facets, but I'm not relying on facets just for this one method.
+      def basename
+        self.name.split('::').last || ''
+      end
+
+      # Just a convenience method for accessing a const within a Module
+      def []( cname )
+        const_get( cname.to_s.camel_case )
+      end
+    end
+  end  
+end
+
+class Module # :nodoc:
+  include Waves::Utilities::Module
+end

data/lib/utilities/object.rb

@@ -0,0 +1,25 @@
+module Waves
+  module Utilities
+    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. This means you can define a block
+      # intended for use with instance_eval, pass it to another method, which can then
+      # invoke with parameters. This is used quite a bit by the Waves::Mapping code.
+      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
+    end
+  end
+end
+
+class Object # :nodoc:
+  include Waves::Utilities::Object
+end

data/lib/utilities/proc.rb

@@ -0,0 +1,16 @@
+module Waves
+  module Utilities
+    module Proc
+      # calls the given lambda with the receiver as its argument
+      def |(lambda)
+        lambda do
+          lambda.call( self.call )
+        end
+      end
+    end
+  end
+end
+
+class Proc # :nodoc:
+  include Waves::Utilities::Proc
+end

data/lib/utilities/string.rb

@@ -0,0 +1,49 @@
+module Waves
+  module Utilities
+    
+    # Utility methods mixed into String.
+        
+    module 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::Utilities::Symbol defines the same method, allowing for :files / 'afilename.txt'
+      
+      def / ( string )
+        File.join(self,string.to_s)
+      end
+
+      # produces stringsLikeThis
+      def lower_camel_case
+        gsub(/(_)(\w)/) { $2.upcase }
+      end
+
+      # produces StringsLikeThis
+      def camel_case
+        lower_camel_case.gsub(/^([a-z])/) { $1.upcase }
+      end
+
+      # produces strings_like_this
+      def snake_case
+        gsub(/\s+/,'').gsub(/([a-z\d])([A-Z])/){ "#{$1}_#{$2}"}.tr("-", "_").downcase
+      end
+
+      def title_case
+        gsub(/(^|\s)\s*([a-z])/) { $1 + $2.upcase }
+      end
+
+      def text
+        gsub(/[\_\-\.\:]/,' ')
+      end
+      
+    end
+  end
+end
+
+class ::String # :nodoc:
+  include Waves::Utilities::String
+end

data/lib/utilities/symbol.rb

@@ -0,0 +1,10 @@
+class Symbol
+  # Does File.join on self and string, converting self to string before invocation.
+  # See String#/ for more.  
+  #
+  # Note:  This overrides any definitions done politely in modules, such as
+  # {Sequel::SQL::ComplexExpressionMethods}[http://sequel.rubyforge.org/classes/Sequel/SQL/ComplexExpressionMethods.html]
+  def / ( string )
+    self.to_s / string
+  end
+end

data/lib/utilities/tempfile.rb

@@ -0,0 +1,9 @@
+# Patch Ruby's Tempfile class to work around a problem uploading files with Rack.
+# 
+# The fix came from here: http://sinatra.lighthouseapp.com/projects/9779/tickets/1
+# 
+# This is fixed in Rack already, but it hasn't made it into a gem.
+class Tempfile
+  # Make == act like eql?
+  def ==(other) ; eql?(other) || super ; end
+end