dyoder-waves 0.7.3

data/lib/tasks/cluster.rb

@@ -0,0 +1,25 @@
+namespace :cluster do
+
+  desc 'Start a cluster of waves applications.'
+  task :start do |task|
+    script = USE_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,15 @@
+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'
+  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}") )
+  end
+end

data/lib/utilities/inflect.rb

@@ -0,0 +1,194 @@
+# 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 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}" ]
+      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}" ]
+      end
+    end
+
+    #
+    def plural_of
+      @plural_of
+    end
+
+    #
+    def singular_of
+      @singular_of
+    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
+      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
+
+  class English
+    @singular_of = {}
+    @plural_of = {}
+
+    @singular_rules = []
+    @plural_rules = []
+
+    class << self
+      include InflectorMethods
+    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
+

data/lib/utilities/integer.rb

@@ -0,0 +1,17 @@
+# Added methods to Integer for commonly used "numeric phrases" like 6.days or 30.megabytes.
+class 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

data/lib/utilities/kernel.rb

@@ -0,0 +1,34 @@
+module Kernel
+  #
+  # From Rails. This comes in handy when you want to return a value that you need to modify.
+  # So instead of the awkward:
+  #
+  #   foo = Foo.new
+  #   foo.bar = 'bar'
+  #   foo
+  #
+  # You can just say
+  #
+  #   returning Foo.new { |foo| foo.bar = 'bar' }
+  #
+  def returning( object, &block )
+    yield object; object
+  end
+
+  #
+  # Inspired by a question on comp.lang.ruby. Sort of like returning, except
+  # you don't need to pass in the returnee as an argument. The drawback is that,
+  # since this relies on instance_eval, you can't access in methods in the local
+  # scope. You can work around this by assigning values to variables, but in that
+  # case, you might be better off using returning.
+  #
+  # Our above example would look like this:
+  #
+  #   with( Foo.new ) { bar = 'bar' }
+  #
+  def with( object, &block )
+    object.instance_eval(&block); object
+  end
+
+
+end

data/lib/utilities/module.rb

@@ -0,0 +1,17 @@
+class 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

data/lib/utilities/object.rb

@@ -0,0 +1,17 @@
+class 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

data/lib/utilities/proc.rb

@@ -0,0 +1,9 @@
+class Proc
+
+  def |(lambda)
+    lambda do
+      lambda.call( self.call )
+    end
+  end
+
+end

data/lib/utilities/string.rb

@@ -0,0 +1,47 @@
+# Waves extends String with a variety of methods for changing from singular to plural and back, and switching to different types of case and word separators. These methods are similar to those found in Rails and other frameworks, but some (all?) of the names are different. The names here were chosen for increased clarity and are hopefully easy to adjust to ...
+
+class String
+
+  # Does a File.join on the two arguments joined by the /. Very handy
+  # for doing platform-safe paths without having to use File.join.
+  #
+  # I unfortunately don't recall where i first saw this ... see
+  # Symbol extension as well, allowing for :files / 'afilename.txt'
+
+  def / ( string )
+    File.join(self,string.to_s)
+  end
+
+  def singular
+    Inflect::English.singular(self)
+  end
+
+  alias_method(:singularize, :singular)
+
+  def plural
+    Inflect::English.plural(self)
+  end
+
+  alias_method(:pluralize, :plural)
+
+  def lower_camel_case
+    gsub(/(_)(\w)/) { $2.upcase }
+  end
+
+  def camel_case
+    lower_camel_case.gsub(/^([a-z])/) { $1.upcase }
+  end
+
+  def snake_case
+    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

data/lib/utilities/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  # Does File.join on self and string, converting self to string before invocation.
+  # See String#/ for more.
+  def / ( string )
+    self.to_s / string
+  end
+end

data/lib/verify/mapping.rb

@@ -0,0 +1,29 @@
+module Waves
+  module Verify
+    module Helpers
+      module Mapping
+
+        def mapping
+          ::Waves::Application.instance.mapping
+        end
+
+        def path(*args,&block)
+          mapping.path(*args,&block)
+        end
+
+        def url(*args,&block)
+          mapping.url(*args,&block)
+        end
+
+        def handle(*args,&block)
+          mapping.handle(*args,&block)
+        end
+
+        def threaded(*args,&block)
+          mapping.threaded(*args,&block)
+        end
+
+      end
+    end
+  end
+end