waves 0.7.6 → 0.7.7

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

data/verify/foundations/default.rb

@@ -0,0 +1,86 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+Dir.chdir File.dirname(__FILE__) / "default_application" do
+module DefaultApplication
+  include Waves::Foundations::Default
+end
+Waves::Console.load( :mode => :development )
+DA = DefaultApplication
+
+
+  describe "An application module which includes the Default foundation" do
+
+    it "defines basic namespaces" do
+      DA::Configurations::Mapping
+      DA::Configurations::Default.host.should == nil
+      DA::Configurations::Development.host.should == '127.0.0.1'
+      DA::Models::Default
+      DA::Views::Default
+      DA::Controllers::Default
+      DA::Helpers::Default
+      DA::Helpers::Testing
+    end
+
+    # it "**leftover tests of Default to be reapportioned**" do
+    #   Waves::Application.instance.mapping.send(:mapping).should.not.be.empty
+    #   DA::Helpers::Default.instance_methods.should.include "layout"
+    # 
+    #   DA::Models::Default.should.respond_to :crayola
+    #   DA::Controllers::Default.instance_methods.should.include "attributes"
+    #   DA::Controllers::Default.instance_methods.should.include "destroy_all"
+    #   
+    #   DA::Views::Default.instance_methods.should.include "renderer"
+    #   DA::Views::Default.instance_methods.should.include "from_default"
+    # end
+    
+    it "auto_creates Models when their files do not exist" do
+      DA::Models::Created.superclass.should == DA::Models::Default
+    end
+    
+    it "auto_loads Models when their files exist" do
+      DA::Models::Loaded.instance_methods.should.include "from_loaded"
+    end
+    
+    it "auto_creates Controllers when their files do not exist" do
+      DA::Controllers::Created.superclass.should == DA::Controllers::Default
+    end
+    
+    it "auto_loads Controllers when their files exist" do
+      DA::Controllers::Loaded.instance_methods.should.include "from_loaded"
+    end
+    
+    it "auto_creates Views when their files do not exist" do
+      DA::Views::Created.superclass.should == DA::Views::Default
+    end
+    
+    it "auto_loads Views when their files exist" do
+      DA::Views::Loaded.instance_methods.should.include "from_loaded"
+    end
+    
+    it "auto_creates Helpers when their files do not exist" do
+      DA::Helpers::Created.included_modules.should.include Waves::Helpers::Default
+    end
+    
+    it "auto_loads Helpers when their files exist" do
+      DA::Helpers::Loaded.instance_methods.should.include "doctype"
+    end
+    
+
+    it "should have accessors defined" do
+      [ :config, :configurations, :controllers, :models, :helpers, :views ].each do |method|
+        DA.should.respond_to method
+      end
+    end
+
+    it "should define [] method for appropriate submodules" do
+      DA::Configurations.should.respond_to :[]
+      DA::Models.should.respond_to :[]
+      DA::Views.should.respond_to :[]
+      DA::Controllers.should.respond_to :[]
+    end
+
+  end
+  
+
+end