zorglub 0.0.9 → 0.1.0

data/lib/zorglub/rack_session.rb

@@ -1,13 +1,9 @@
 # -*- coding: UTF-8 -*-
-#
+
 module Zorglub
-    #
     class Node
-        #
         def session
             @request.session
         end
-        #
     end
-    #
 end

data/lib/zorglub/session.rb

@@ -1,24 +1,24 @@
 # -*- coding: UTF-8 -*-
-#
+
 require 'securerandom'
-#
+
 module Zorglub
-    #
+
     class Node
-        #
+
         @sessions = {}
-        #
+
         class << self
             attr_reader :sessions
         end
-        #
+
         def session
             @session ||= SessionHash.new @request, @response, Node.sessions, app.opt(:session_options)
         end
     end
-    #
+
     class SessionHash < Hash
-        #
+
         def initialize req, resp, sessions, options
             @request = req
             @response = resp
@@ -27,49 +27,49 @@ module Zorglub
             @options = options
             super()
         end
-        #
+
         def [] key
             load_data!
             super key
         end
-        #
+
         def has_key? key
             load_data!
             super key
         end
         alias :key? :has_key?
         alias :include? :has_key?
-        #
+
         def []= key, value
             load_data!
             super key, value
         end
-        #
+
         def clear
             load_data!
-#            @response.delete_cookie @options[:key]
-#            @sessions.delete @sid
-#            @sid = nil
+            # @response.delete_cookie @options[:key]
+            # @sessions.delete @sid
+            # @sid = nil
             super
         end
-        #
+
         def to_hash
             load_data!
             h = {}.replace(self)
             h.delete_if { |k,v| v.nil? }
             h
         end
-        #
+
         def update hash
             load_data!
             super stringify_keys(hash)
         end
-        #
+
         def delete key
             load_data!
             super key
         end
-        #
+
         def inspect
             if loaded?
                 super
@@ -77,22 +77,22 @@ module Zorglub
                 "#<#{self.class}:0x#{self.object_id.to_s(16)} not yet loaded>"
             end
         end
-        #
+
         def exists?
             ( loaded? ? @sessions.has_key?(@sid) : false )
         end
-        #
+
         def loaded?
             not @sid.nil?
         end
-        #
+
         def empty?
             load_data!
             super
         end
-        #
+
         private
-        #
+
         def load_data!
             return if loaded?
             if @options[:enabled]
@@ -106,7 +106,7 @@ module Zorglub
                 @sid = sid
             end
         end
-        #
+
         def stringify_keys other
             hash = {}
             other.each do |key, value|
@@ -114,12 +114,12 @@ module Zorglub
             end
             hash
         end
-        #
+
         def generate_sid!
             begin sid = sid_algorithm end while @sessions.has_key? sid
             sid
         end
-        #
+
         begin
             require 'securerandom'
             # Using SecureRandom, optional length.
@@ -148,9 +148,5 @@ module Zorglub
                 Digest::SHA2.hexdigest(entropy.join)
             end
         end
-        #
     end
-    #
 end
-#
-# EOF

data/spec/app_spec.rb

@@ -1,43 +1,43 @@
 # -*- coding: UTF-8 -*-
-#
+
 require 'spec_helper'
-#
+
 describe Zorglub do
-    #
+
     describe Zorglub::App do
-        #
+
         it "map should add a mapped node" do
-            APP.at("/temp").should be_nil
+            expect(APP.at("/temp")).to be_nil
             APP.map "/temp", Temp
-            APP.at("/temp").should be Temp
+            expect(APP.at("/temp")).to be Temp
         end
-        #
+
         it "delete should delete a mapped node" do
-            APP.at("/temp").should be Temp
+            expect(APP.at("/temp")).to be Temp
             APP.delete "/temp"
-            APP.at("/temp").should be_nil
+            expect(APP.at("/temp")).to be_nil
         end
-        #
+
         it "at should return mapped node" do
-            APP.at("/node1").should be Node1
+            expect(APP.at("/node1")).to be Node1
         end
-        #
+
         it "at should return nil if no Node mapped" do
-            APP.at("/none").should be_nil
+            expect(APP.at("/none")).to be_nil
         end
-        #
+
         it "to should return path to node" do
-            APP.to(Node1).should == "/node1"
+            expect(APP.to(Node1)).to eq "/node1"
         end
-        #
+
         it "to should return nil if not an existing Node" do
-            APP.to(nil).should be_nil
+            expect(APP.to(nil)).to be_nil
         end
-        #
+
         it "to_hash should return a correct hash" do
-            APP.to_hash["/node1"].should be Node1
+            expect(APP.to_hash["/node1"]).to be Node1
         end
-        #
+
     end
-    #
+
 end

data/spec/node_spec.rb

@@ -1,307 +1,315 @@
 # -*- coding: UTF-8 -*-
-#
+
 require 'spec_helper'
-#
+
 def clean_static_path
     static_base_path = Node0.app.static_base_path
     Dir.glob( File.join(static_base_path,'**','*') ).each do |f| File.unlink f if File.file? f end
     Dir.glob( File.join(static_base_path,'*') ).each do |d| Dir.rmdir d end
     Dir.rmdir static_base_path if File.directory? static_base_path
 end
-#
+
 describe Zorglub do
-    #
+
     describe Zorglub::Node do
-        #
+
         before(:all) do
             clean_static_path
         end
-        #
+
         after(:all) do
             clean_static_path
         end
-        #
+
         it "engine should return default Node's engine" do
-            Node0.engine.should == Node0.app.opt(:engine)
+            expect(Node0.engine).to eq Node0.app.opt(:engine)
         end
-        #
+
         it "layout should return default Node's layout" do
-            Node0.layout.should == Node0.app.opt(:layout)
+            expect(Node0.layout).to eq Node0.app.opt(:layout)
         end
-        #
+
         it "engine should return class defined Node's engine" do
-            Node1.engine.should == "engine-1"
-            Node3.engine.should == "engine-2"
+            expect(Node1.engine).to eq "engine-1"
+            expect(Node3.engine).to eq "engine-2"
         end
-        #
+
         it "layout should return class defined Node's layout" do
-            Node1.layout.should == "layout-1"
-            Node3.layout.should == "layout-2"
+            expect(Node1.layout).to eq "layout-1"
+            expect(Node3.layout).to eq "layout-2"
         end
-        #
+
         it "engine should return engine inherited from Node2" do
-            Node2.engine.should == "engine-1"
+            expect(Node2.engine).to eq "engine-1"
         end
-        #
+
         it "layout should return layout inherited from Node2" do
-            Node2.layout.should == "layout-1"
+            expect(Node2.layout).to eq "layout-1"
         end
-        #
+
         it "r should build a well formed path" do
-            Node1.r(1,'arg2',"some").should == "/node1/1/arg2/some"
+            expect(Node1.r(1,'arg2',"some")).to eq "/node1/1/arg2/some"
         end
-        #
+
         it "instance level map should work" do
             r = Node0.my_call '/with_2args/1/2'
             h = YAML.load r.body[0]
-            h[:map].should == '/node0'
+            expect(h[:map]).to eq '/node0'
         end
-        #
+
         it "should return err404 response when no method found" do
-            Node0.respond_to?('noresponse').should be_false
+            expect(Node0.respond_to?('noresponse')).to be_falsey
             r = Node0.my_call '/noresponse'
-            r.status.should == 404
+            expect(r.status).to eq 404
         end
-        #
+
         it "simple method should respond" do
             r = Node0.my_call '/hello'
-            r.status.should == 200
-            r.body[0].should == 'world'
+            expect(r.status).to eq 200
+            expect(r.body[0]).to eq 'world'
         end
-        #
+
         it "instance level args should work" do
             r = Node0.my_call '/with_2args/1/2'
             h = YAML.load r.body[0]
-            h[:args][0].should == '1'
-            h[:args][1].should == '2'
+            expect(h[:args][0]).to eq '1'
+            expect(h[:args][1]).to eq '2'
         end
-        #
+
         it "should raise error when too much arguments" do
-            lambda{ r = Node0.my_call '/with_2args/1/2/3' }.should raise_error ArgumentError
+            expect(lambda{ r = Node0.my_call '/with_2args/1/2/3' }).to raise_error ArgumentError
         end
-        #
+
         it "layout proc, method level layout and engine definitions should work" do
             r = Node0.my_call '/index'
-            r.status.should == 200
+            expect(r.status).to eq 200
             h = YAML.load r.body[0]
             ly = File.join Node0.app.layout_base_path, Node0.layout
             vu = File.join Node0.app.view_base_path, Node0.r, 'index'
-            h[:path].should == ly
-            h[:layout].should == ly
-            h[:view].should == vu
+            expect(h[:path]).to eq ly
+            expect(h[:layout]).to eq ly
+            expect(h[:view]).to eq vu
         end
-        #
+
         it "layout proc, method level layout and engine definitions should work" do
             r = Node1.my_call '/index'
-            r.status.should == 200
+            expect(r.status).to eq 200
             h = YAML.load r.body[0]
             ly = File.join Node1.app.layout_base_path, 'main.spec'
             vu = File.join Node1.app.view_base_path, Node1.r, 'index.spec'
-            h[:path].should == ly
-            h[:layout].should == ly
-            h[:view].should == vu
+            expect(h[:path]).to eq ly
+            expect(h[:layout]).to eq ly
+            expect(h[:view]).to eq vu
         end
-        #
+
         it "before_all hook should work" do
             Node3.before = 0
             Node3.after = 0
-            Node3.before.should == 0
-            Node3.my_call '/index'
-            Node3.before.should == 1
-            Node3.my_call '/index'
-            Node3.before.should == 2
-            Node3.my_call '/index'
-            Node3.before.should == 3
-        end
-        #
+            expect(Node3.before).to eq 0
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 1
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 2
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 3
+        end
+
         it "after_all hook should work" do
             Node3.before = 0
             Node3.after = 0
-            Node3.after.should == 0
-            Node3.my_call '/index'
-            Node3.after.should == 1
-            Node3.my_call '/index'
-            Node3.after.should == 2
-            Node3.my_call '/index'
-            Node3.after.should == 3
-        end
-        #
+            expect(Node3.after).to eq 0
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 1
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 2
+            expect(Node3.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 3
+        end
+
         it "inherited before_all hook should work" do
             Node3.before = 0
             Node3.after = 0
-            Node3.before.should == 0
-            Node8.my_call '/index'
-            Node3.before.should == 1
-            Node8.my_call '/index'
-            Node3.before.should == 2
-            Node8.my_call '/index'
-            Node3.before.should == 3
-        end
-        #
+            expect(Node3.before).to eq 0
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 1
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 2
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.before).to eq 3
+        end
+
         it "inherited after_all hook should work" do
             Node3.before = 0
             Node3.after = 0
-            Node3.after.should == 0
-            Node8.my_call '/index'
-            Node3.after.should == 1
-            Node8.my_call '/index'
-            Node3.after.should == 2
-            Node8.my_call '/index'
-            Node3.after.should == 3
-        end
-        #
+            expect(Node3.after).to eq 0
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 1
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 2
+            expect(Node8.my_call_i('/index')).to eq 1
+            expect(Node3.after).to eq 3
+        end
+
         it "should find view and layout and render them" do
             r = Node0.my_call '/do_render'
-            r.status.should == 200
-            r.body[0].should == "layout_start view_content layout_end"
+            expect(r.status).to eq 200
+            expect(r.body[0]).to eq "layout_start view_content layout_end"
         end
-        #
+
         it "default mime-type should be text/html" do
             r = Node0.my_call '/index'
-            r.header['Content-type'].should == 'text/html'
+            expect(r.header['Content-type']).to eq 'text/html'
         end
-        #
+
         it "should be able to override mime-type" do
             r = Node0.my_call '/do_render'
-            r.header['Content-type'].should == 'text/view'
+            expect(r.header['Content-type']).to eq 'text/view'
         end
-        #
+
         it "should be able to override through rack response mime-type" do
             r = Node0.my_call '/do_content_type'
-            r.header['Content-type'].should == 'text/mine'
+            expect(r.header['Content-type']).to eq 'text/mine'
         end
-        #
+
         it "partial should render correctly" do
-            Node0.partial({},:do_partial, 1, 2).should == 'partial_content'
+            expect(Node0.partial({},:do_partial, 1, 2)).to eq 'partial_content'
         end
-        #
+
         it "method level view should work" do
-            Node0.partial({},:other_view).should == 'partial_content'
+            expect(Node0.partial({},:other_view)).to eq 'partial_content'
         end
-        #
+
         it "partial with hooks should be default" do
             Node3.before = 0
             Node3.after = 0
-            Node3.partial({},:do_partial,1,2).should == 'partial_content'
-            Node3.before.should == 1
-            Node3.after.should == 1
+            expect(Node3.partial({},:do_partial,1,2)).to eq 'partial_content'
+            expect(Node3.before).to eq 1
+            expect(Node3.after).to eq 1
         end
-        #
+
         it "partial without hooks should work" do
             Node3.before = 0
             Node3.after = 0
-            Node3.partial({:no_hooks=>true},:do_partial,1,2).should == 'partial_content'
-            Node3.before.should == 0
-            Node3.after.should == 0
+            expect(Node3.partial({:no_hooks=>true},:do_partial,1,2)).to eq 'partial_content'
+            expect(Node3.before).to eq 0
+            expect(Node3.after).to eq 0
         end
-        #
+
         it "static pages should be generated" do
             r = Node6.my_call '/do_static'
-            r.body[0].should == 'VAL 1'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 1'
+            expect(r.header['Content-type']).to eq 'text/static'
             r = Node6.my_call '/do_static'
-            r.body[0].should == 'VAL 1'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 1'
+            expect(r.header['Content-type']).to eq 'text/static'
             r = Node6.my_call '/do_static'
-            r.body[0].should == 'VAL 1'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 1'
+            expect(r.header['Content-type']).to eq 'text/static'
             r = Node6.my_call '/no_static'
-            r.body[0].should == 'VAL 4'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 4'
+            expect(r.header['Content-type']).to eq 'text/static'
             r = Node6.my_call '/do_static'
-            r.body[0].should == 'VAL 1'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 1'
+            expect(r.header['Content-type']).to eq 'text/static'
             Node6.static! true, 0.000001
             sleep 0.0001
             r = Node6.my_call '/do_static'
-            r.body[0].should == 'VAL 6'
-            r.header['Content-type'].should == 'text/static'
+            expect(r.body[0]).to eq 'VAL 6'
+            expect(r.header['Content-type']).to eq 'text/static'
         end
-        #
+
         it "redirect should work" do
             r = Node0.my_call '/do_redirect'
-            r.status.should == 302
-            r.header['location'].should == Node0.r(:do_partial,1,2,3)
+            expect(r.status).to eq 302
+            expect(r.header['location']).to eq Node0.r(:do_partial,1,2,3)
         end
-        #
+
         it "no_layout! should be inherited" do
-            Node5.layout.should be_nil
+            expect(Node5.layout).to be_nil
         end
-        #
+
         it "cli_vals should be inherited and extended" do
             r = Node5.my_call '/index'
             vars = YAML.load r.body[0]
-            vars.should == ['js0','js1','js3','jsx','css0','css1','css2']
-            vars[7].should be_nil
+            expect(vars).to eq ['js0','js1','js3','jsx','css0','css1','css2']
+            expect(vars[7]).to be_nil
         end
-        #
+
         it "cli_vals should be extended at method level" do
             r = Node4.my_call '/more'
             vars = YAML.load r.body[0]
-            vars.should == ['js0','js1','js2']
-            vars[3].should be_nil
+            expect(vars).to eq ['js0','js1','js2']
+            expect(vars[3]).to be_nil
         end
-        #
+
         it "cli_vals should be untouched" do
             r = Node4.my_call '/index'
             vars = YAML.load r.body[0]
-            vars.should == ['js0','js1']
-            vars[2].should be_nil
+            expect(vars).to eq ['js0','js1']
+            expect(vars[2]).to be_nil
             r = Node5.my_call '/index'
             vars = YAML.load r.body[0]
-            vars.should == ['js0','js1','js3','jsx','css0','css1','css2']
-            vars[7].should be_nil
+            expect(vars).to eq ['js0','js1','js3','jsx','css0','css1','css2']
+            expect(vars[7]).to be_nil
         end
-        #
+
         it "ext definition and file engine should work" do
             r = Node0.my_call '/xml_file'
-            r.body[0].should  == "<xml>file<\/xml>\n"
-            r.header['Content-type'].should == 'application/xml'
+            expect(r.body[0]).to eq "<xml>file<\/xml>\n"
+            expect(r.header['Content-type']).to eq 'application/xml'
             r = Node0.my_call '/plain_file'
-            r.body[0].should == "plain file\n"
-            r.header['Content-type'].should == 'text/plain'
+            expect(r.body[0]).to eq "plain file\n"
+            expect(r.header['Content-type']).to eq 'text/plain'
         end
-        #
+
         it "no view no layout should work as well" do
             r = Node0.my_call '/no_view_no_layout'
-            r.body[0].should  == "hello world"
+            expect(r.body[0]).to eq "hello world"
         end
-        #
+
         it "haml engine should work" do
             Node0.app.opt! :engines_cache_enabled, false
             r = Node0.my_call '/engines/haml'
-            r.body[0].should == "<h1>Hello world</h1>\n"
+            expect(r.body[0]).to eq "<h1>Hello world</h1>\n"
             Node0.app.opt! :engines_cache_enabled, true
             r = Node0.my_call '/engines/haml'
-            r.body[0].should == "<h1>Hello world</h1>\n"
+            expect(r.body[0]).to eq "<h1>Hello world</h1>\n"
         end
-        #
+
         it "sass engine should work" do
             Node0.app.opt! :engines_cache_enabled, true
             r = Node0.my_call '/engines/sass'
-            r.body[0].should == "vbar{width:80%;height:23px}vbar ul{list-style-type:none}vbar li{float:left}vbar li a{font-weight:bold}\n"
+            expect(r.body[0]).to eq "vbar{width:80%;height:23px}vbar ul{list-style-type:none}vbar li{float:left}vbar li a{font-weight:bold}\n"
             Node0.app.opt! :engines_cache_enabled, false
             r = Node0.my_call '/engines/sass'
-            r.body[0].should == "vbar{width:80%;height:23px}vbar ul{list-style-type:none}vbar li{float:left}vbar li a{font-weight:bold}\n"
+            expect(r.body[0]).to eq "vbar{width:80%;height:23px}vbar ul{list-style-type:none}vbar li{float:left}vbar li a{font-weight:bold}\n"
         end
-        #
+
         it "view_base_path! should work" do
             r = Node7.my_call '/view_path'
             h = YAML.load r.body[0]
-            h[:view].should == File.join(Node7.app.opt(:root), 'alt','do_render')
+            expect(h[:view]).to eq File.join(Node7.app.opt(:root), 'alt','do_render')
         end
-        #
+
         it "layout_base_path! should work" do
             r = Node7.my_call '/view_path'
             h = YAML.load r.body[0]
-            h[:layout].should == File.join(Node7.app.opt(:root), 'alt','layout','default')
+            expect(h[:layout]).to eq File.join(Node7.app.opt(:root), 'alt','layout','default')
         end
-        #
+
         it "debug out should work" do
-            APP.opt! :debug, true
-            Node0.my_call '/hello'
-        end
-        #
+            stderr0= $stderr.dup
+            stderrs = StringIO.new
+            $stderr = stderrs
+            begin
+                APP.opt! :debug, true
+                Node0.my_call '/hello'
+            ensure
+                $stderr = stderr0
+            end
+            expect(stderrs.string.include?('spec/data/view/node0/hello')).to be true
+        end
+
     end
-    #
+
 end