zorglub 0.1.0 → 0.1.2

data/lib/zorglub/session.rb

@@ -1,152 +1,148 @@
-# -*- 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
+      @sessions = sessions
+      @sid = nil
+      @options = options
+      super()
+    end
+
+    def [](key)
+      load_data!
+      super key
+    end
+
+    def key?(key)
+      load_data!
+      super key
+    end
+    alias include? key?
+
+    def []=(key, value)
+      load_data!
+      super key, value
+    end
+
+    def clear
+      load_data!
+      # @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
+      else
+        "#<#{self.class}:0x#{object_id.to_s(16)} not yet loaded>"
+      end
+    end
+
+    def exists?
+      loaded? ? @sessions.key?(@sid) : false
+    end
+
+    def loaded?
+      !@sid.nil?
+    end
+
+    def empty?
+      load_data!
+      super
+    end
+
+    private
+
+    def load_data!
+      return if loaded?
+      return unless @options[:enabled]
+
+      sid = @request.cookies[@options[:key]]
+      if sid.nil?
+        sid = generate_sid!
+        @response.set_cookie @options[:key], sid
+      end
+      replace @sessions[sid] ||= {}
+      @sessions[sid] = self
+      @sid = sid
+    end
+
+    def stringify_keys(other)
+      hash = {}
+      other.each do |key, value|
+        hash[key] = value
+      end
+      hash
+    end
+
+    def generate_sid!
+      begin sid = sid_algorithm end while @sessions.key? sid
+      sid
+    end
 
-    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
-            @sessions = sessions
-            @sid = nil
-            @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
-            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
-            else
-                "#<#{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]
-                sid = @request.cookies[@options[:key]]
-                if sid.nil?
-                    sid = generate_sid!
-                    @response.set_cookie @options[:key], sid
-                end
-                replace @sessions[sid] ||={}
-                @sessions[sid] = self
-                @sid = sid
-            end
-        end
-
-        def stringify_keys other
-            hash = {}
-            other.each do |key, value|
-                hash[key] = value
-            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.
-            # SecureRandom is available since Ruby 1.8.7.
-            # For Ruby versions earlier than that, you can require the uuidtools gem,
-            # which has a drop-in replacement for SecureRandom.
-            def sid_algorithm; SecureRandom.hex(@options[:sid_len]); end
-        rescue LoadError
-            require 'openssl'
-            # Using OpenSSL::Random for generation, this is comparable in performance
-            # with stdlib SecureRandom and also allows for optional length, it should
-            # have the same behaviour as the SecureRandom::hex method of the
-            # uuidtools gem.
-            def sid_algorithm
-                OpenSSL::Random.random_bytes(@options[:sid_len] / 2).unpack('H*')[0]
-            end
-        rescue LoadError
-            # Digest::SHA2::hexdigest produces a string of length 64, although
-            # collisions are not very likely, the entropy is still very low and
-            # length is not optional.
-            #
-            # Replacing it with OS-provided random data would take a lot of code and
-            # won't be as cross-platform as Ruby.
-            def sid_algorithm
-                entropy = [ srand, rand, Time.now.to_f, rand, $$, rand, object_id ]
-                Digest::SHA2.hexdigest(entropy.join)
-            end
-        end
+    begin
+      require 'securerandom'
+      # Using SecureRandom, optional length.
+      # SecureRandom is available since Ruby 1.8.7.
+      # For Ruby versions earlier than that, you can require the uuidtools gem,
+      # which has a drop-in replacement for SecureRandom.
+      def sid_algorithm
+        SecureRandom.hex(@options[:sid_len])
+      end
+    rescue LoadError
+      require 'openssl'
+      # Using OpenSSL::Random for generation, this is comparable in performance
+      # with stdlib SecureRandom and also allows for optional length, it should
+      # have the same behaviour as the SecureRandom::hex method of the
+      # uuidtools gem.
+      def sid_algorithm
+        OpenSSL::Random.random_bytes(@options[:sid_len] / 2).unpack1('H*')[0]
+      end
+    rescue LoadError
+      # Digest::SHA2::hexdigest produces a string of length 64, although
+      # collisions are not very likely, the entropy is still very low and
+      # length is not optional.
+      #
+      # Replacing it with OS-provided random data would take a lot of code and
+      # won't be as cross-platform as Ruby.
+      def sid_algorithm
+        entropy = [srand, rand, Time.now.to_f, rand, $$, rand, object_id]
+        Digest::SHA2.hexdigest(entropy.join)
+      end
     end
+  end
 end

data/lib/zorglub.rb

@@ -1,11 +1,8 @@
 #! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
 
 module Zorglub
-    VERSION = '0.1.0'
+  VERSION = '0.1.2'.freeze
 end
 
 require 'zorglub/node'
 require 'zorglub/app'
-
-# EOF

data/spec/app_spec.rb

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

data/spec/data/view/node0/engines.haml

@@ -1 +1 @@
-%h1="Hello world"
+%h1="Hello #{@name}"