serverside 0.3.1 → 0.4.1

data/lib/serverside/js.rb

@@ -0,0 +1,173 @@
+require 'metaid'
+require 'json'
+
+module ServerSide
+  # Serializes data into a Javscript literal hash format. For example:
+  # ServerSide::JS.new {|j| j}
+  class JS
+    # blank slate
+    instance_methods.each do |m|
+      undef_method m unless (m =~ /^__|instance_eval|meta|respond_to|nil|is_a/)
+    end
+  
+    # Initializes a new document. A callback function name can be supplied to
+    # wrap the hash.
+    def initialize(callback = nil, &block)
+      @callback = callback
+      @stack = [self]
+      block.call(self) if block
+    end
+    
+    # Catches calls to define keys and creates methods on the fly.
+    def method_missing(key, *args, &block)
+      value = nil
+      if block
+        @stack.push JS.new
+        block.call(self)
+        value = @stack.pop.__content
+      else
+        value = args.first
+      end
+      @stack.last.__add_hash_value(key, value)
+      self
+    end
+    
+    def __add_hash_value(key, value)
+      @content ||= {}
+      @content[key] = value
+    end
+    
+    def __add_array_value(value)
+      @content ||= []
+      @content << value
+    end
+    
+    def <<(value)
+      value = value.__content if value.respond_to?(:__content)
+      @stack.last.__add_array_value(value)
+    end
+    
+    # Returns the current document content.
+    def __content
+      @content
+    end
+    
+    NULL = 'null'.freeze
+    
+    # Serializes the specified object into JS/JSON format. 
+    def __serialize(obj, quote_keys)
+      case obj
+      when Time: JSON.generate(obj.to_f)
+      else
+        JSON.generate(obj)
+      end
+    end
+    
+    # Returns the document content as a literal Javascript object. If a callback was specified,
+    # the object is wrapped in a Javascript function call.
+    def to_s
+      j = __serialize(@content, false)
+      @callback ? "#{@callback}(#{j});" : j
+    end
+    
+    # Returns the content in JSON format.
+    def to_json
+      __serialize(@content, true)
+    end
+    
+    alias_method :inspect, :to_s
+  end
+end
+
+__END__
+
+module ServerSide
+  # Serializes data into a Javscript literal hash format. For example:
+  # ServerSide::JS.new {|j| j}
+  class JS
+    # blank slate
+    instance_methods.each do |m|
+      undef_method m unless (m =~ /^__|instance_eval|meta|respond_to|nil|is_a/)
+    end
+  
+    # Initializes a new document. A callback function name can be supplied to
+    # wrap the hash.
+    def initialize(callback = nil, &block)
+      @callback = callback
+      @stack = [self]
+      block.call(self) if block
+    end
+    
+    # Catches calls to define keys and creates methods on the fly.
+    def method_missing(key, *args, &block)
+      value = nil
+      if block
+        @stack.push JS.new
+        block.call(self)
+        value = @stack.pop.__content
+      else
+        value = args.first
+      end
+      @stack.last.__add_hash_value(key, value)
+      self
+    end
+    
+    def __add_hash_value(key, value)
+      @content ||= {}
+      @content[key] = value
+    end
+    
+    def __add_array_value(value)
+      @content ||= []
+      @content << value
+    end
+    
+    def <<(value)
+      value = value.__content if value.respond_to?(:__js)
+      @stack.last.__add_array_value(value)
+    end
+    
+    # Returns the current document content.
+    def __content
+      @content
+    end
+    
+    NULL = 'null'.freeze
+    
+    # Serializes the specified object into JS/JSON format. 
+    def __serialize(obj, quote_keys)
+      if obj.nil?
+        NULL
+      elsif obj.is_a? Array
+        "[#{obj.map{|v| __serialize(v, quote_keys)}.join(', ')}]"
+      elsif obj.is_a? Hash
+        if quote_keys
+          fields = obj.to_a.map{|kv| "\"#{kv[0]}\": #{__serialize(kv[1], quote_keys)}"}
+        else
+          fields = obj.to_a.map{|kv| "#{kv[0]}: #{__serialize(kv[1], quote_keys)}"}
+        end
+        "{#{fields.join(', ')}}"
+      elsif obj.is_a? Symbol
+        obj.to_s
+      elsif obj.is_a? Time
+        obj.to_f
+      else
+        obj.inspect
+      end
+    end
+    
+    # Returns the document content as a literal Javascript object. If a callback was specified,
+    # the object is wrapped in a Javascript function call.
+    def to_s
+      j = __serialize(@content, false)
+      @callback ? "#{@callback}(#{j});" : j
+    end
+    
+    # Returns the content in JSON format.
+    def to_json
+      __serialize(@content, true)
+    end
+    
+    alias_method :inspect, :to_s
+  end
+end

data/lib/serverside/log.rb

@@ -0,0 +1,79 @@
+require 'logger'
+
+module ServerSide
+  @@logger = nil
+  
+  def self.logger
+    @@logger
+  end
+  
+  def self.logger=(l)
+    @@logger = l
+  end
+  
+  def self.setup_stock_logger(logdev, shift_age = 0, shift_size = 1048576)
+    @@logger = Logger.new(logdev, shift_age, shift_size)
+    @@logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+    @@logger
+  end
+  
+  def self.logger_level=(level)
+    @@logger.level = level if @@logger
+  end
+
+  def self.log(level, text)
+    @@logger.log(level, text) if @@logger
+  end
+  
+  def self.debug(text)
+    @@logger.debug(text) if @@logger
+  end
+  
+  def self.info(text)
+    @@logger.info(text) if @@logger
+  end
+  
+  def self.warn(text)
+    @@logger.warn(text) if @@logger
+  end
+  
+  def self.error(text)
+    @@logger.error(text) if @@logger
+  end
+  
+  def self.fatal(text)
+    @@logger.fatal(text) if @@logger
+  end
+  
+  def self.log_error(e)
+    if @@logger
+      @@logger.error("#{e.message}:\r\n" + e.backtrace.join("\r\n"))
+    end
+  end
+  
+  REFERER = "Referer".freeze
+  USER_AGENT = "User-Agent".freeze
+  HOST = "Host".freeze
+  HOST_REGEXP = /([^\:]*)(\:(.*))?$/
+  
+  def self.log_request(c)
+    if @@logger
+      return unless request_line = c.request_line
+      req_line.chomp!
+      if c.method == :post && c.content_type == HTTP::Request::CONTENT_TYPE_URL_ENCODED
+        req_line << " (#{r.body})"
+      end
+      host = (r.request_headers[HOST] || "") =~ HOST_REGEXP ? $1 : ""
+      msg = "%s %s %s %s %s %s %s" % [
+        r.client_name,
+        host.inspect,
+        request_line.inspect,
+        r.status || '?',
+        r.content_length || '?',
+        (r.headers[REFERER] || "").inspect,
+        (r.headers[USER_AGENT] || "").inspect
+      ]
+      @@logger.info(msg)
+    end
+  end
+end

data/lib/serverside/template.rb

@@ -1,8 +1,9 @@
-require 'erb'
+require 'rubygems'
+require 'erubis'
 
 module ServerSide
-  # The Template module implements an ERB template rendering system. Templates
-  # are cached and automatically reloaded if the file changes.
+  # The Template module implements an Erubis template rendering system. 
+  # Templates are cached and automatically reloaded if the file changes.
   class Template
     # The @@templates variable caches templates in use. The values are
     # arrays containing 2 objects: a file stamp (if the template comes from a 
@@ -12,7 +13,7 @@ module ServerSide
     # Caches a template for later use. The stamp parameter is used only when
     # the content of a template file is stored.
     def self.set(name, body, stamp = nil)
-      @@templates[name] = [stamp, ERB.new(body)]
+      @@templates[name] = [stamp, Erubis::Eruby.new(body)]
     end
 
     # Validates the referenced template by checking its stamp. If the name

data/lib/serverside/xml.rb

@@ -0,0 +1,84 @@
+require 'metaid'
+
+module ServerSide
+  class XML
+    # blank slate
+    instance_methods.each {|m|
+      undef_method m unless (m =~ /^__|instance_eval|meta|respond_to/)}
+  
+    TAG_LEFT_OPEN = '<'.freeze
+    TAG_LEFT_CLOSE = '</'.freeze
+    TAG_RIGHT = '>'.freeze
+  
+    def __open_tag(tag, atts)
+      @doc << TAG_LEFT_OPEN
+      @doc << tag.to_s
+      @doc << __fmt_atts(atts) if atts
+      @doc << TAG_RIGHT
+    end
+  
+    def __close_tag(tag)
+      @doc << TAG_LEFT_CLOSE
+      @doc << tag.to_s
+      @doc << TAG_RIGHT
+    end
+  
+    def __value(value)
+      @doc << value.to_s
+    end
+  
+    INSTRUCT_LEFT = '<?xml'.freeze
+    INSTRUCT_RIGHT = '?>'.freeze
+
+    def __instruct(arg)
+      @doc << INSTRUCT_LEFT
+      @doc << __fmt_atts(arg)
+      @doc << INSTRUCT_RIGHT
+    end
+  
+    SPACE = ' '.freeze
+
+    def __fmt_atts(atts)
+      atts.inject('') {|m, i| m << " #{i[0]}=#{i[1].to_s.inspect}"}
+    end
+  
+  
+    def initialize(tag = nil, atts = nil, &block)
+      @doc = ''
+      __open_tag(tag, atts) if tag
+      block.call(self) if block
+      __close_tag(tag) if tag
+    end
+  
+    def method_missing(tag, *args, &block)
+      if block
+        __open_tag(tag, args.first)
+        block.call(self)
+        __close_tag(tag)
+      else
+        value, atts = args.pop, args.pop
+        subtags, atts = atts, nil if atts.is_a?(Array)
+        if subtags
+          __open_tag(tag, atts)
+          subtags.each {|k| __send__(k, value[k])}
+          __close_tag(tag)
+        else
+          __open_tag(tag, atts)
+          __value(value)
+          __close_tag(tag)
+        end
+      end
+      self
+    end
+
+    def instruct!(atts = nil)
+      __instruct(atts || {:version => "1.0", :encoding => "UTF-8"})
+    end
+
+    def to_s
+      @doc
+    end
+    
+    alias_method :inspect, :to_s
+  end
+end

data/lib/serverside.rb

@@ -9,5 +9,14 @@
 module ServerSide
 end
 
-path = File.join(File.dirname(__FILE__), 'serverside')
-Dir.foreach(path) {|fn| require File.join(path, fn) if fn =~ /\.rb$/}
+lib_dir = File.join(File.dirname(__FILE__), 'serverside')
+
+require File.join(lib_dir, 'core_ext')
+require File.join(lib_dir, 'http')
+require File.join(lib_dir, 'daemon')
+require File.join(lib_dir, 'cluster')
+require File.join(lib_dir, 'log')
+require File.join(lib_dir, 'template')
+require File.join(lib_dir, 'js')
+require File.join(lib_dir, 'xml')
+

data/spec/core_ext_spec.rb

@@ -21,72 +21,27 @@ context "String" do
     ('touch'/'/me/'/'hold'/'/me').should == 'touch/me/hold/me'
   end
   
-  specify ".underscore should turn camel-cased phrases to underscored ones" do
+  specify "#underscore should turn camel-cased phrases to underscored ones" do
     'CamelCase'.underscore.should == 'camel_case'
     'Content-Type'.underscore.should == 'content_type'
   end
-end
-
-# Symbol extensions
-
-class Symbol
-  attr_reader :_to_s
-end
-
-context "Symbol.to_s" do
-  specify "should convert the symbol to a string" do
-    :abc_def.to_s.should == 'abc_def'
-    :def_ghi.to_s.should_be_instance_of String
-    :ghi_jkl.to_s.should == :ghi_jkl.id2name
-  end
-  
-  specify "should cache the id2name value" do
-    :kwantz_mit_krantz._to_s.should_be_nil
-    :kwantz_mit_krantz.to_s
-    :kwantz_mit_krantz._to_s.should == :kwantz_mit_krantz.id2name
-  end
-  
-  specify "should always return the same cached value" do
-    :item.to_s.should_be :item.to_s
-  end
-end
-
-context "Proc.proc_tag" do
-  setup do
-    @l1 = lambda {1 + 1}
-    @l2 = lambda {1 + 1}
-  end
-  
-  specify "should return a unique tag for the proc object" do
-    @l1.proc_tag.should_not_equal @l2.proc_tag
-  end
- 
-  specify "should return the same tag always" do
-    @l1.proc_tag.should == @l1.proc_tag
-  end
   
-  specify "should return the object id in base 36 prefixed with 'proc_'" do
-    @l1.proc_tag.should == 'proc_' + @l1.object_id.to_s(36).sub('-', '_')
+  specify "#camelize should turn an underscore name to camelcase" do
+    'wowie_zowie'.camelize.should == 'WowieZowie'
   end
 end
 
-context "Object.const_tag" do
-  setup do
-    @o1 = Object.new
-    @o2 = Object.new
-  end
-
-  specify "should return a unique tag for the object" do
-    @o1.const_tag.should_not_equal @o2.const_tag
-  end
-  
-  specify "should return the same tag always" do
-    @o1.const_tag.should == @o1.const_tag
-    @o2.const_tag.should == @o2.const_tag
+context "Process.exists?" do
+  specify "should return false for a non-existing process" do
+    # bogus pid   
+    pid = nil
+    while pid = rand(10000)
+      break if `ps #{pid}` !~ /#{pid}/
+    end
+    Process.exists?(pid).should be_false
   end
   
-  specify "should return the object id in base 36 (upcase) prefixed with 'C'" do
-    @o1.const_tag.should == 'C' + @o1.object_id.to_s(36).upcase.sub('-', '_')
-    @o2.const_tag.should == 'C' + @o2.object_id.to_s(36).upcase.sub('-', '_')
+  specify "should return true for an existing process" do
+    Process.exists?(Process.pid).should be_true
   end
 end

data/spec/daemon_spec.rb

@@ -1,3 +1,5 @@
+__END__
+
 require File.join(File.dirname(__FILE__), '../lib/serverside')
 
 class TestDaemon < Daemon::Base
@@ -62,38 +64,69 @@ context "Daemon::PidFile" do
 end
 
 context "Daemon.control" do
-#  teardown {Daemon.control(TestDaemon, :stop) rescue nil}
+  teardown {Daemon.control(TestDaemon, :stop) rescue nil}
   
-#  specify "should start and stop the daemon" do
-#    Daemon::PidFile.remove(TestDaemon)
-#    Daemon.control(TestDaemon, :start)
-#    sleep 0.2
-#    File.file?(TestDaemon.pid_fn).should == true
-#    sleep 0.5
-#    proc {Daemon::PidFile.recall(TestDaemon)}.should_not_raise
-#    Daemon.control(TestDaemon, :stop)
-#    sleep 0.2
-#    File.file?(TestDaemon.result_fn).should == false
-#  end
+  specify "should start and stop the daemon" do
+    Daemon::PidFile.remove(TestDaemon)
+    Daemon.control(TestDaemon, :start)
+    sleep 0.2
+    File.file?(TestDaemon.pid_fn).should == true
+    sleep 0.5
+    proc {Daemon::PidFile.recall(TestDaemon)}.should_not_raise
+    Daemon.control(TestDaemon, :stop)
+    sleep 0.2
+    File.file?(TestDaemon.result_fn).should == false
+  end
   
-#  specify "should restart the daemon" do
-#    Daemon::PidFile.remove(TestDaemon)
-#    Daemon.control(TestDaemon, :start)
-#    begin
-#      sleep 1
-#      pid1 = Daemon::PidFile.recall(TestDaemon)
-#      Daemon.control(TestDaemon, :restart)
-#      sleep 1
-#      pid2 = Daemon::PidFile.recall(TestDaemon)
-#      pid1.should_not == pid2
-#    ensure
-#      Daemon.control(TestDaemon, :stop)
-#      Daemon::PidFile.remove(TestDaemon)
-#    end
-#  end
+  specify "should restart the daemon" do
+    Daemon::PidFile.remove(TestDaemon)
+    Daemon.control(TestDaemon, :start)
+    begin
+      sleep 1
+      pid1 = Daemon::PidFile.recall(TestDaemon)
+      Daemon.control(TestDaemon, :restart)
+      sleep 1
+      pid2 = Daemon::PidFile.recall(TestDaemon)
+      pid1.should_not == pid2
+    ensure
+      Daemon.control(TestDaemon, :stop)
+      Daemon::PidFile.remove(TestDaemon)
+    end
+  end
   
   specify "should raise RuntimeError for invalid command" do
-    proc {Daemon.control(TestDaemon, :invalid)}.should_raise RuntimeError
+    proc {Daemon.control(TestDaemon, :invalid)}.should_raise
+  end
+end
+
+context "Daemon.alive?" do
+  teardown {Daemon.control(TestDaemon, :stop) rescue nil}
+  
+  specify "should return false if not running" do
+    Daemon.alive?(TestDaemon).should_be false
+  end
+  
+  specify "should return true if running" do
+    Daemon.control(TestDaemon, :start)
+    sleep 1
+    Daemon.alive?(TestDaemon).should_be true
+    sleep 1
+    Daemon.control(TestDaemon, :stop)
+    sleep 1
+    Daemon.alive?(TestDaemon).should_be false
+  end
+  
+  specify "should return false if the daemon process is killed" do
+    Daemon.control(TestDaemon, :start)
+    sleep 1
+    pid = Daemon::PidFile.recall(TestDaemon)
+    Daemon.alive?(TestDaemon).should_be true
+    Process.kill("TERM", pid)
+    while `ps #{pid}` =~ /#{pid}/
+      sleep 0.2
+    end
+    Daemon.alive?(TestDaemon).should_be false
+    Daemon.control(TestDaemon, :stop)
   end
 end