waves-stable 0.7.7

data/samples/blog/templates/comment/list.mab

@@ -0,0 +1,6 @@
+@comments.each do |comment|
+  p "Posted on #{comment.updated_on.strftime('%b %d, %Y') if comment.updated_on} by 
+    #{( ( comment.name.nil? or comment.name.empty? ) ?
+      'anonymous coward' : comment.name )}"
+  textile comment.content
+end

data/samples/blog/templates/entry/editor.mab

@@ -0,0 +1,13 @@
+layout :default, :title => 'Edit Entry' do
+  form :action => "/entry/#{@entry.name}/", :method => 'POST' do
+    input :name => '_method', :type => 'hidden', :value => 'put'
+    label 'Title'; br
+    input :type => :text, :value => @entry.title, :name => 'entry.title'; br
+    label 'Summary'; br
+    textarea @entry.summary, :name => 'entry.summary', :rows => 10, :cols => 80; br
+    label 'Content'; br
+    textarea @entry.content, :name => 'entry.content', :rows => 20, :cols => 80; br
+    input :type => :submit, :value => 'Save'
+    a.delete 'Delete', :href => "/entry/#{@entry.name}"
+  end
+end

data/samples/blog/templates/entry/list.mab

@@ -0,0 +1,11 @@
+layout :default, :title => 'Blog Entries' do
+  h1 'My Blog'
+  form :action => '/entries', :method => 'post' do
+    label 'Name'
+    input :type => :text, :name => 'entry.name'
+    input :type => :submit, :value => 'Add'
+  end
+  @entries.each do |entry|
+    view :entry, :summary, :entry => entry
+  end
+end

data/samples/blog/templates/entry/show.mab

@@ -0,0 +1,9 @@
+layout :default, :title => @entry.title do
+  a 'Show All Entries', :href => '/entries'
+  a 'Edit This Entry', :href => "/entry/#{@entry.name}/editor"
+  h1 @entry.title
+  textile @entry.content
+  h1 'Comments'
+  view :comment, :add, :entry => @entry
+  view :comment, :list, :comments => @entry.comments
+end

data/samples/blog/templates/entry/summary.mab

@@ -0,0 +1,5 @@
+h2 do
+  a @entry.title, :href => "/entry/#{@entry.name}"
+end
+textile @entry.summary
+a 'Read more ...', :href => "/entry/#{@entry.name}"

data/samples/blog/templates/errors/not_found_404.mab

@@ -0,0 +1,2 @@
+h1 '404'
+p %q( That URL does not exist on this server. )

data/samples/blog/templates/errors/server_error_500.mab

@@ -0,0 +1,2 @@
+h1 '500'
+p %q( Internal server error. Sorry, but your request could not be processed. )

data/samples/blog/templates/layouts/default.mab

@@ -0,0 +1,17 @@
+doctype :html4_strict
+
+html do
+
+  head do
+    title @title
+    script :src => 'http://jqueryjs.googlecode.com/files/jquery-1.2.2.min.js',
+      :type => 'text/javascript'
+    script :src => '/javascript/site.js', :type => 'text/javascript'
+    link :href => '/css/site.css', :rel => 'stylesheet', :type => 'text/css'
+  end
+
+  body do
+    layout_content
+  end
+
+end

data/verify/app_generation/helpers.rb

@@ -0,0 +1,24 @@
+%w( rubygems bacon open3 extensions/all).each { |f| require f }
+
+Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit
+
+require File.join(File.dirname(__FILE__), "..", "..", "lib", "utilities", "string")
+
+
+AppPath = File.expand_path(File.dirname(__FILE__) / "sandbox")
+FrameworkPath = File.expand_path(File.dirname(__FILE__) / ".." / "..")
+
+def generate_test_app(path)
+  command = File.dirname(__FILE__) / ".." / ".." / :bin / "waves"
+  system "#{command} #{path}"
+end
+
+def clobber_test_app(path)
+  FileUtils.rm_rf(path) if File.exist?(path)
+end
+
+def set_framework_path(path)
+  text = File.read(path / 'startup.rb').split("\n").unshift("WAVES = '#{FrameworkPath}'").join("\n")
+  File.write(path / 'startup.rb', text)
+end

data/verify/app_generation/startup.rb

@@ -0,0 +1,39 @@
+# require 'test_helper' because RubyMate needs help
+
+require File.join(File.dirname(__FILE__) , "helpers")
+
+clobber_test_app(AppPath)
+generate_test_app(AppPath)
+
+describe "A generated application" do
+  
+  it "has executable script files" do
+    File.executable?(File.join(AppPath, "bin", "waves-console")).should.be.true
+  end
+
+  it "will fail to find waves framework, if the gem is not available" do
+    Dir.chdir(AppPath) do
+      stdin, stdout, stderr = Open3.popen3("ruby startup.rb")
+      stderr.gets.should =~ %r{no such file to load -- waves \(LoadError\)}
+    end
+  end
+
+  it "will find and use waves framework source when WAVES is defined" do
+    set_framework_path(AppPath)
+    Dir.chdir(AppPath) do
+      stdin, stdout, stderr = Open3.popen3("ruby startup.rb")
+      stderr.gets.should == nil
+    end
+  end
+  
+  it "has the directories we expect it to have" do
+    dirs = %w{  bin/ configurations/ controllers/ doc/ helpers/ lib/ 
+                log/ models/ public/ schema/ templates/ tmp/ views/ }
+    Dir.chdir(AppPath) do
+      Dir.glob("*/").should == dirs
+    end
+  end
+  
+end
+
+clobber_test_app(AppPath)

data/verify/blackboard/blackboard_verify.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "Blackboard" do
+
+  it 'should create a blackboard' do
+    request = mock(:request)
+    Waves::Blackboard.new(request).should.not == nil
+  end
+
+  it 'should allow adding a value, and reading from it' do
+    request = mock(:request)
+    bb = Waves::Blackboard.new(request)
+    bb.test = 2
+    bb.test.should == 2
+    
+    bb["test"].should == 2
+    
+    bb["test2"] = 3
+    bb["test2"].should == 3
+    bb.test2.should == 3
+  end
+
+  it 'should not have a value if never set' do
+    request = mock(:request)
+    bb = Waves::Blackboard.new(request)
+    bb.never_set.should == nil
+    bb["never_set"].should == nil
+  end
+
+  it 'should iterate over all defined values' do
+    request = mock(:request)
+    bb = Waves::Blackboard.new(request)
+    bb.value1 = 1
+    bb.value2 = 2
+    a = []
+    bb.each do |value|
+      a << value
+    end
+    a.should == [["value1", 1], ["value2", 2]]
+  end
+  
+end
+
+module BlackBoardVerify
+  module Controllers
+    class Test
+      include Waves::Controllers::Mixin
+    end
+  end
+end
+
+module BlackBoardVerify
+  module Configurations
+    module Mapping
+      extend Waves::Mapping
+    end
+  end
+end
+
+module BlackBoardVerify
+  module Helpers
+    module Test
+      extend Waves::Helpers::Default
+    end
+  end
+end
+
+module BlackBoardVerify
+  module Views
+    module Test
+      extend Waves::Views::Mixin
+    end
+  end
+end
+
+specification "Blackboard included in other classes" do
+
+  before do
+  end
+
+  after do
+  end
+
+  it 'should be included in other classes' do
+    request = mock(:request)
+    BlackBoardVerify::Controllers::Test.instance_methods.should.include "blackboard"
+    Waves::Helpers::Default.instance_methods.should.include "blackboard"
+    Waves::ResponseProxy.instance_methods.should.include "blackboard"
+    BlackBoardVerify::Views::Test.methods.should.include "blackboard"
+  end
+
+end

data/verify/blackboard/helpers.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__) , "..", "helpers")
+
+module BlackBoardVerify ; include Waves::Foundations::Simple ; end
+# Waves << BlackBoardVerify
+# Waves::Console.load( :mode => :development )

data/verify/configurations/attributes.rb

@@ -0,0 +1,37 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+describe "Configuration attributes" do
+  
+  class Basic < Waves::Configurations::Base; end
+  
+  it "can be declared by developers" do
+    Basic.attribute :smurf
+    Basic.smurf("smurfy") 
+    Basic.smurf.should == "smurfy"
+  end
+  
+  
+  it "must be declared before use" do
+    Basic.should.not.respond_to :gnome
+  end
+  
+end
+
+describe "Waves::Configurations::Default" do
+  
+  class Default < Waves::Configurations::Default; end
+  
+  it "declares certain attributes necessary to run a Waves app" do
+    %w( host port ports log reloadable database session debug root synchronize? ).each do |attr|
+      Default.should.respond_to attr
+    end
+  end
+  
+  it "sets default values for important attributes" do
+    [ :debug, :synchronize?, :session, :log, :reloadable ].each do |attr|
+      Default[attr].should.not.be.nil
+    end
+  end
+  
+end

data/verify/configurations/helpers.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__) , "..", "helpers")

data/verify/configurations/rack_integration.rb

@@ -0,0 +1,29 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+describe "A Waves Configuration" do
+  
+  class Default < Waves::Configurations::Default; end
+  
+  it "can specify a Rack handler" do
+    class Default
+      handler(::Rack::Handler::Mongrel, :Host => '0.0.0.0', :Port => 8080)
+    end
+    Default.handler.should == [ ::Rack::Handler::Mongrel, { :Host => '0.0.0.0', :Port => 8080 } ]
+  end
+  
+  it "provides an accessor for a hash of mime types" do
+    Waves::MimeTypes.should.receive(:[]).with('foo.png').and_return('image/png')
+    Default.mime_types['foo.png'].should == 'image/png'
+  end
+  
+  it "must define the application for use with Rack" do
+    app = Rack::Builder.new() {}
+    Rack::Builder.should.receive(:new).with().and_return(app)
+    Default.application do
+      "stuff"
+    end
+    Default.application.should.be.a.kind_of Rack::Builder
+  end
+  
+end

data/verify/controllers/base.rb

@@ -0,0 +1,37 @@
+# # require 'test_helper' because RubyMate needs help
+# require File.join(File.dirname(__FILE__) , "helpers")
+# 
+# # Nota bene, y'all:  These model helper methods are very ORM specific, and should probably 
+# # get moved into the ORM layers.
+# 
+# describe "The base Waves controller" do
+#   
+#   before do
+#     Waves.application.stub!(:models).and_return(VerifyControllers::Models)
+#     @request = mock('request')
+#     @dc = VerifyControllers::Controllers::Default.new(@request)
+#   end
+#   
+#   it "can isolate its model's attributes from the request params" do
+#     @dc.should.receive(:params).and_return({:foo => 'bar', :default => {:one => 'one', :two => 'two'}})
+#     @dc.attributes.should == {:one => 'one', :two => 'two'}
+#   end
+#   
+#   it "provides shortcut methods for common model interactions" do
+#     VerifyControllers::Models::Default.should.receive(:all)
+#     @dc.all
+#     
+#     VerifyControllers::Models::Default.should.receive(:[]).with(:name => 'This').and_return('That')
+#     @dc.find('This').should == 'That'
+#     
+#     VerifyControllers::Models::Default.should.receive(:create).with("Does it work?").and_return('It worked!')
+#     @dc.should.receive(:attributes).and_return("Does it work?")
+#     @dc.create.should == 'It worked!'
+#     
+#     # @dc.update('This')
+#     
+#     # @dc.delete('This')
+#     
+#   end
+#   
+# end

data/verify/controllers/helpers.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__) , "..", "helpers")
+
+module VerifyControllers
+  module Models
+    class Default
+    end
+  end
+  module Controllers
+    class Default < Waves::Controllers::Base; end
+  end
+end
+
+VerifyControllers::Models.stub!(:[]).with(:default).and_return(VerifyControllers::Models::Default)

data/verify/controllers/interface.rb

@@ -0,0 +1,51 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+describe "A Waves controller" do
+    
+  before do
+    Waves.application.stub!(:models).and_return(VerifyControllers::Models)
+    @request = mock('request')
+    @dc = VerifyControllers::Controllers::Default.new(@request)
+  end
+  
+  it "initializes with and can access a request" do
+    @dc.request.should == @request
+  end
+  
+  it "can access a destructured version of the request params" do
+    request_hash =      { 'beer.name' => 'Pale Rye Ale', 
+                          'beer.brew.kind' => 'mini-mash', 
+                          'beer.brew.yeast' => 'White Labs British Ale' ,
+                          'beer.brew.hops.variety' => 'Fuggles' }
+    destructured_hash = { :beer =>  
+                            { :name => 'Pale Rye Ale', 
+                              :brew => {  :kind => 'mini-mash', 
+                                          :yeast => 'White Labs British Ale',
+                                          :hops => { :variety => 'Fuggles' }}}}
+                              
+    @request.should.receive(:params).and_return(request_hash)
+    @dc.params.should == destructured_hash
+  end
+
+  
+  it "has reflective model helpers to allow generalizing" do
+    # Waves.application handwaving done in ./helpers
+    
+    @dc.model_name.should == 'default'
+    @dc.model.should == VerifyControllers::Models::Default
+  end  
+  
+end
+
+describe "The process method of a Waves controller class" do
+  
+  it "executes a block within the scope of a controller instance" do
+    @request = mock('request')
+    result = VerifyControllers::Controllers::Default.process(@request) do
+      self.class.name
+    end
+    result.should == "VerifyControllers::Controllers::Default"
+  end
+  
+end

data/verify/core/helpers.rb

@@ -0,0 +1,3 @@
+%w( rubygems bacon facon ).each { |f| require f }
+Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit

data/verify/core/utilities.rb

@@ -0,0 +1,177 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+UTILITIES = "#{File.dirname(__FILE__)}/../../lib/utilities"
+
+require "#{UTILITIES}/module"
+require "#{UTILITIES}/inflect"
+require "#{UTILITIES}/string"
+require "#{UTILITIES}/symbol"
+require "#{UTILITIES}/object"
+require "#{UTILITIES}/integer"
+require "#{UTILITIES}/proc"
+require "#{UTILITIES}/hash"
+
+
+describe "Waves::Utilities::Module" do
+  
+  before do
+    module Eenie; module Meenie; module Miney; end; end ; end
+  end
+  
+  it "defines a basename method" do
+    Eenie::Meenie.basename.should == "Meenie"
+    Eenie::Meenie::Miney.basename.should == "Miney"
+  end
+  
+  it "defines [] for easy access to namespaced constants" do
+    Eenie[:Meenie].should == Eenie::Meenie
+  end
+  
+end
+
+describe "a language extended with Waves::Utilities::Inflect" do
+  
+  before do
+    # Nominative only, of course.
+    module Latin
+      extend Waves::Inflect::InflectorMethods
+      rule 'us', 'i'
+      rule 'u', 'ua'
+      rule 'x', 'gis'
+      
+      word 'deus', 'di'
+      word 'cultus'
+      
+      singular_rule 'inuum', 'inua'
+      plural_rule 'ix', 'ices'
+    end
+  end
+  
+  it "can define general pluralization rules" do
+    Latin.plural('servus').should == 'servi'
+  end
+  
+  it "can register two-way exceptions for specific words" do
+    Latin.plural('deus').should == 'di'
+    Latin.plural('cultus').should == 'cultus'
+  end
+  
+  it "can register rules for singularization exceptions" do
+    Latin.singular('cornua').should == 'cornu'
+    Latin.singular('continua').should == 'continuum'
+  end
+  
+  it "can register rules for pluralization exceptions" do
+    Latin.plural('phoenix').should == 'phoenices'
+  end
+  
+  
+end
+
+describe "Waves::Utilities::String" do
+
+  # ** API Change **
+  # it "delegates singular and plural inflection methods" do
+  #   Waves::Inflect::English.should.receive(:singular).and_return("boring")
+  #   Waves::Inflect::English.should.receive(:plural).and_return("still boring")
+  #   "boring".singular.plural
+  # end
+  
+  it "defines / as syntactic sugar for File.join" do
+    ( "lib" / "utilities" ).should == File.join( "lib", "utilities" )
+    ( "lib" / :utilities ).should == File.join( "lib", "utilities" )
+    ( "lib" / 3 ).should == File.join( "lib", "3" )
+  end
+  
+  it "defines a snake_case method" do
+    "MilchCow".snake_case.should == "milch_cow"
+    "Milch Cow".snake_case.should == "milch_cow"
+    "milchCow".snake_case.should == "milch_cow"
+    "StrangeFaceMilchCow".snake_case.should == "strange_face_milch_cow"
+  end
+  
+  it "defines a camel_case method" do
+    "siege_engine".camel_case.should == "SiegeEngine"
+    "ineffective_siege_engine".camel_case.should == "IneffectiveSiegeEngine"
+  end
+  
+  it "defines a lower_camel_case method" do
+    "siege_engine".lower_camel_case.should == "siegeEngine"
+    "ineffective_siege_engine".lower_camel_case.should == "ineffectiveSiegeEngine"
+  end
+  
+  it "defines a title_case method" do
+    # Yes, we know that this is naive title casing.
+    "sing ho! for the life of a bear".title_case.should == "Sing Ho! For The Life Of A Bear"
+  end
+  
+end
+
+describe "A monkeypatch to Symbol" do
+  
+  it "defines / as syntactic sugar for File.join" do
+    ( :lib / :utilities ).should == File.join( "lib", "utilities")
+  end
+  
+end
+
+
+describe "Waves::Utilities::Object" do
+  
+  before do |variable|
+    @foo = [ :a, :b, :c ]
+  end
+  
+  it "defines instance_exec, to allow instance_eval-ing a block with parameters" do
+    result = @foo.instance_exec(2)  do |i|
+      self[i]
+    end
+    result.should == :c
+    
+    result = @foo.instance_exec(0,2) do |*args|
+      self.slice(*args)
+    end
+    result.should == [:a, :b]
+  end
+  
+end
+
+describe "Waves::Utilities::Integer" do
+  # pedantic, no?
+  1.kilobytes.should == "1,024".to_i
+  1.megabytes.should == "1,048,576".to_i
+  1.gigabytes.should == "1,073,741,824".to_i
+  1.terabytes.should == "1,099,511,627,776".to_i
+  1.petabytes.should == "1,125,899,906,842,624".to_i
+  1.exabytes.should == "1,152,921,504,606,846,976".to_i
+  1.zettabytes.should == "1,180,591,620,717,411,303,424".to_i
+  1.yottabytes.should == "1,208,925,819,614,629,174,706,176".to_i
+end
+
+describe "Waves::Utilities::Proc" do
+  
+   it "defines | as syntactic sugar for passing the result of a proc to a lambda" do
+     p = Proc.new { "smurf" }
+     l = lambda { |data| data.reverse }
+     result = p | l
+     result.call.should == "frums"
+   end
+   
+end
+
+describe "Waves::Utilities::Hash" do
+  
+  it "adds a non-destructive method for converting all hash keys to strings" do
+    h = { :a => 1, 'b' => 2, 3 => 3}
+    h.stringify_keys.should == { 'a' => 1, 'b' => 2, '3' => 3}
+    h.should == { :a => 1, 'b' => 2, 3 => 3}
+  end
+  
+  it "adds a destructive method for converting hash keys to symbols" do
+    h = { "two" => 2, :three => 3}
+    h.symbolize_keys!
+    h.should == { :two => 2, :three => 3 }
+  end
+  
+end