spiderfw 0.5

data/lib/spiderfw/templates/template_blocks.rb

@@ -0,0 +1,185 @@
+module Spider
+    
+    module TemplateBlocks
+        
+        def self.parse_element(el, allowed_blocks=nil, template=nil)
+            return nil if (el.class == ::Hpricot::BogusETag)
+            block = get_block_type(el)
+            return nil unless (!allowed_blocks || allowed_blocks.include?(block))
+            return const_get(block).new(el, template, allowed_blocks)
+        end
+        
+        def self.get_block_type(el, skip_attributes=false)
+            if (el.class == ::Hpricot::Text)
+                block = :Text
+            elsif (el.class == ::Hpricot::Comment)
+                block = :Comment
+            elsif (!skip_attributes && (el.attributes['sp:if'] || el.attributes['sp:run-if']))
+                block = :If
+            elsif (!skip_attributes && el.attributes['sp:tag-if'])
+                block = :TagIf
+            elsif (!skip_attributes && el.attributes['sp:attr-if'])
+                block = :AttrIf
+            elsif (!skip_attributes && (el.attributes['sp:each'] || el.attributes['sp:each_index']))
+                block = :Each
+            elsif (el.name == 'sp:render')
+                block = :Render
+            elsif (el.name == 'sp:run')
+                block = :Run
+            elsif (el.name == 'sp:yield')
+                block = :Yield
+            elsif (el.name == 'sp:pass' || el.name == 'sp:template')
+                block = :Pass
+            elsif (el.name == 'sp:debugger')
+                block = :Debugger
+            elsif (Spider::Template.registered?(el.name))
+                klass = Spider::Template.get_registered_class(el.name)
+                if (klass < ::Spider::Widget)
+                    block = :Widget
+                elsif (klass < Spider::Tag)
+                    block = :Tag
+                else
+                    Spider.logger.error("Could not parse #{el.name} tag")
+                end
+            else
+                block = :HTML
+            end
+            return block
+        end
+        
+        class Block
+            
+            def initialize(el, template=nil, allowed_blocks=nil)
+                @el = el
+                @template = template
+                @allowed_blocks = allowed_blocks
+                @content_blocks = []
+            end
+            
+            def parse_content(el)
+                content_blocks = []
+                last_block = nil
+                el.each_child do |ch|
+                    #Spider.logger.debug "TRAVERSING CHILD #{ch}"
+                    # Gives the preceding block the chance to "eat" the next elements
+                    next if (last_block && last_block.get_following(ch))
+                    last_block = TemplateBlocks.parse_element(ch, @allowed_blocks, @template)
+                    content_blocks << last_block if (last_block)
+                end
+                return content_blocks
+            end
+            
+            def compile_content(c='', init='', options={})
+                c ||= ""
+                init ||= ""
+                blocks = parse_content(@el)
+                blocks.each do |block|
+                    compiled = block.compile(options)
+                    next unless compiled
+                    # if (compiled.run_code =~ /nil/)
+                    #     Spider::Logger.debug("NIL BLOCK")
+                    #     Spider::Logger.debug(block)
+                    #     Spider::Logger.debug(compiled.run_code)
+                    # end
+                    c += compiled.run_code if (compiled.run_code)
+                    init += compiled.init_code if (compiled.init_code)
+                end
+                return [c, init]
+            end
+            
+            def get_following(el)
+                return false
+            end
+            
+            def escape_text(text)
+                res = text.gsub(/_(\\*)\\\((.+?)\)/, '_\1(\2)') \
+                    .gsub('\\', '\\\\\\').gsub("'", "\\\\'")
+                return res
+            end
+            
+            def self.vars_to_scene(str, container='self')
+                res = ""
+                scanner = ::StringScanner.new(str)
+                pos = 0
+                while scanner.scan_until(/@(\w[\w\d_]+)/)
+                    text = scanner.pre_match[pos..-1]
+                    pos = scanner.pos
+                    res += text
+                    res += "#{container}[:#{scanner.matched[1..-1]}]"
+                end
+                res += scanner.rest
+                return res
+            end
+            
+            def vars_to_scene(str, container='self')
+                self.class.vars_to_scene(str, container)
+            end
+            
+            def scan_vars(str, &block)
+                res = ""
+                scanner = ::StringScanner.new(str)
+                pos = 0
+                while scanner.scan_until(/\{ ([^}]+) \}/)
+                    text = scanner.pre_match[pos..-1]
+                    pos = scanner.pos
+                    yield text, scanner.matched[2..-3]
+                end
+                return scanner.rest
+            end
+            
+            
+            def inspect
+                @el
+            end
+            
+            def self.var_to_scene(var, container='self')
+                first, rest = var.split('.', 2)
+                if (first =~ /([^\[]+)(\[.+)/)
+                    var_name = $1
+                    array_rest = $2
+                else
+                    var_name = first
+                end
+                if (var[0].chr == '@')
+                    scene_var = "#{container}[:#{var_name[1..-1]}]"
+                else
+                    scene_var = var_name
+                end
+                scene_var += array_rest if (array_rest)
+                scene_var += '.'+rest if (rest)
+                return scene_var
+            end
+            
+            def var_to_scene(var, container='self')
+                self.class.var_to_scene(var, container)
+            end
+            
+        end
+        
+        class CompiledBlock
+            attr_accessor :init_code, :run_code
+            
+            def initialize(init_code, run_code)
+                @init_code = init_code
+                @run_code = run_code
+            end
+            
+        end
+        
+    end
+    
+end
+require 'spiderfw/templates/blocks/html'
+require 'spiderfw/templates/blocks/comment'
+require 'spiderfw/templates/blocks/text'
+require 'spiderfw/templates/blocks/each'
+require 'spiderfw/templates/blocks/if'
+require 'spiderfw/templates/blocks/tag_if'
+require 'spiderfw/templates/blocks/attr_if'
+require 'spiderfw/templates/blocks/render'
+require 'spiderfw/templates/blocks/yield'
+require 'spiderfw/templates/blocks/pass'
+require 'spiderfw/templates/blocks/tag'
+require 'spiderfw/templates/blocks/widget'
+require 'spiderfw/templates/blocks/run'
+require 'spiderfw/templates/blocks/debugger'

data/lib/spiderfw/utils/annotations.rb

@@ -0,0 +1,201 @@
+# Module to allow annotations on methods. When included into a Class or Module,
+# will make the Annotations::ClassMethods.__ and Annotations::ClassMethods.\___ methods available. 
+# These can be used before a method to add annotations.
+# The including class can also use Annotations::ClassMethods.define_annotation to define code
+# that will be executed when an annotation is encountered.
+#
+# Example:
+#   class A
+#     include Annotations
+#
+#     def self.cool_methods; @cool_methods ||= []; end
+#     
+#     define_annotation :method_rating do |klass, method, args|
+#       klass.cool_methods << method if args[0] == :cool
+#     end
+#     
+#     __.is_first_method
+#     def method1
+#     end
+#
+#   ___.is_other_method
+#     def method2
+#     end
+#     
+#     __.method_rating :cool
+#     def method3
+#     end
+#
+#   end
+#   
+#   p A.annotations[:method1] => {:is_first_method => true} 
+#   p A.annotations[:method3] => {:is_other_method => true, :method_rating => :cool}
+#   p A.cool_methods => [:method3]
+#
+# *Warning*: annotations are *not* thread safe; if more than one file is being loaded at the same time for
+# the same Module, annotations may end up wrong.
+# You should ensure that all code using annotations is loaded in a single thread (this is usually a good idea anyway).
+
+module Annotations
+
+    def self.included(klass)
+        klass.extend(ClassMethods)
+        unless klass.is_a?(Class)
+            klass.instance_eval do
+                alias annotations_original_append_features append_features
+                def append_features(kl)
+                    result = annotations_original_append_features(kl)
+                    if (@defined_annotations)
+                        @defined_annotations.each do |name, proc|
+                            kl.define_annotation(name, &proc)
+                        end
+                    end
+                    @annotations.each do |method, vals|
+                        vals.each do |k, args|
+                            args = [args] unless args.is_a?(Array)
+                            kl.annotate(method, k, *args)
+                        end
+                    end
+                    result
+                end
+            end
+        end
+        super
+    end
+
+    class Annotator #:nodoc:
+
+        def initialize(owner) 
+            @owner = owner
+            @annotations = {}
+            @pending_annotations = []
+            @m_pending_annotations = []
+            @pending = @pending_annotations
+        end
+        
+        def pending
+            r = @m_pending_annotations + @pending_annotations
+            return r
+        end
+        
+        def clear_pending
+            @pending_annotations.clear
+        end
+
+        def method_missing(name, *args)
+            @pending << [name, args]
+        end
+
+        def annotate(method_name, *args)
+            @owner.annotations[method_name] = args
+        end
+        
+        def single
+            @pending = @pending_annotations
+            return self
+        end
+        
+        def multiple
+            @pending = @m_pending_annotations
+            return self
+        end
+
+    end
+
+
+    module ClassMethods
+        
+        def inherited(subclass)
+            if (@annotations)
+                @annotations.each do |method, vals|
+                    vals.each do |k, args|
+                        subclass.annotate(method, k, *args)
+                    end
+                end
+            end
+            super
+        end
+        
+        # Returns the @annotations Hash.
+        def annotations
+            @annotations
+        end
+
+        # Annotates the next method.
+        def __()
+            @annotator ||= Annotator.new(self).single
+        end
+        
+        # Annotates all the following methods, until the end of the Class/Module.
+        def ___()
+            @annotator ||= Annotator.new(self).multiple
+        end
+
+        def method_added(name) # :nodoc:
+            return super unless @annotator
+            @annotations ||= {}
+            @annotations[name] ||= {}
+            @annotator.pending.each do |key, args|
+                annotate(name, key, *args)
+            end
+            @annotator.clear_pending
+            # debugger
+            # self.method(name).annotations = @annotations[name]
+            super
+        end
+        
+        # Explicitly annotates a method
+        def annotate(method, name, *args)
+            @annotations ||= {}
+            @annotations[method] ||= {}
+            if (args.length == 0)
+                @annotations[method][name] = true
+            elsif (args[0].is_a?(Hash))
+                @annotations[method][name] = args[0]
+            else
+                @annotations[method][name] = args
+            end
+            ann = find_defined_annotation(name)
+            if (ann)
+                ann.call(self, method, *args)
+            end
+        end
+        
+        # Defines an annotation. The given block will be called whenever the name annotation
+        # is encountered; it will be passed the current Class, the annotated Method, and the annotation arguments.
+        def define_annotation(name, &proc)
+            @defined_annotations ||= {}
+            @defined_annotations[name] = proc
+            if (@annotations)
+                @annotations.each do |method, n|
+                    proc.call(self, method, *@annotations[method][n]) if n == name
+                end
+            end
+        end
+        
+        # Returns the Hash of defined annotations.
+        def defined_annotations
+            @defined_annotations
+        end
+
+        # Searches for a defined annotation in class and ancestors.
+        def find_defined_annotation(name)
+            return nil if self.class == Module
+            k = self
+            while (k != Object)
+                return nil unless k < Annotations
+                return k.defined_annotations[name] if k.defined_annotations && k.defined_annotations[name]
+                k = k.superclass
+            end
+        end
+
+
+
+    end
+
+
+end
+# 
+# class Method
+#     attr_accessor :annotations
+# end

data/lib/spiderfw/utils/fork.rb

@@ -0,0 +1,75 @@
+module Spider
+    
+    # A safe fork keeping track of resources needing to be closed.
+    module Fork
+        
+        # Adds a list of resources. Resources must respond to :close.
+        def self.resources_to_close(*list)
+            @resources ||= []
+            @resources += list
+        end
+        
+        # Closes all resources.
+        def self.close_resources
+            return unless @resources
+            @mutex ||= Mutex.new
+            @mutex.synchronize do
+                @resources.each do |res|
+                    @resource.close if resource && resource.respond_to?(:close) && !resource.closed?
+                end
+                @resources.clear
+            end
+        end
+        
+        # Closes resources, than forks.
+        def self.fork(&proc)
+            child = Kernel.fork do
+                Spider::Fork.close_resources
+                yield
+            end
+            return child
+        end
+        
+    end
+    
+    # Calls Spider::Fork.fork
+    def self.fork(&proc)
+        Spider::Fork.fork(&proc)
+    end
+    
+    
+end
+
+# Patches, taken from spawn Rails plugin (http://github.com/tra/spawn/)
+
+if defined? Mongrel::HttpServer
+  class Mongrel::HttpServer
+    # redefine Montrel::HttpServer::process_client so that we can intercept
+    # the socket that is being used so Spawn can close it upon forking
+    alias_method :spider_orig_process_client, :process_client
+    def process_client(client)
+      Spider::Fork.resources_to_close(client, @socket)
+      spider_orig_process_client(client)
+    end
+  end
+end
+ 
+need_passenger_patch = true
+if defined? PhusionPassenger::VERSION_STRING
+  # The VERSION_STRING variable was defined sometime after 2.1.0.
+  # We don't need passenger patch for 2.2.2 or later.
+  pv = PhusionPassenger::VERSION_STRING.split('.').collect{|s| s.to_i}
+  need_passenger_patch = pv[0] < 2 || (pv[0] == 2 && (pv[1] < 2 || (pv[1] == 2 && pv[2] < 2)))
+end
+ 
+if need_passenger_patch
+  if defined? PhusionPassenger::Rack::RequestHandler
+    class PhusionPassenger::Rack::RequestHandler
+      alias_method :spider_orig_process_request, :process_request
+      def process_request(headers, input, output)
+        Spider::Fork.resources_to_close(input, output)
+        spider_orig_process_request(headers, input, output)
+      end
+    end
+  end
+end

data/lib/spiderfw/utils/hash_comparison.rb

@@ -0,0 +1,8 @@
+module HashComparison
+    def eql?(h)
+        self == h
+    end
+    def hash
+        self.to_a.hash
+    end
+end

data/lib/spiderfw/utils/inflector.rb

@@ -0,0 +1,42 @@
+module Spider
+
+    module Inflector
+
+        #--
+        # From ActiveSupport
+        def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+            if first_letter_in_uppercase
+                lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+            else
+                lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+            end
+        end
+
+        #--
+        # From ActiveSupport
+        def self.underscore(camel_cased_word)
+            camel_cased_word.to_s.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+        end
+        
+        def self.underscore_to_upcasefirst(str)
+            upcasefirst(str.gsub(/_+/, ' '))
+        end
+        
+        def self.upcasefirst(str)
+            # FIXME: move to language specific!
+            no_upcase = ['di', 'da', 'a']
+            res = str.split(' ').map do | p | 
+                l = p.downcase
+                l.gsub(/^[a-z]/){ |a| a.upcase } unless no_upcase.include?(l)
+            end
+            res.join(' ')
+        end
+        
+
+    end
+
+end

data/lib/spiderfw/utils/logger.rb

@@ -0,0 +1,92 @@
+require 'logger'
+
+module Spider
+    
+    # Utility to consolidate many loggers into one. Can be used as a simple Logger,
+    # and will pass log messages to each of its child.
+    
+    module Logger
+        
+        class << self
+            
+            # def [](dest)
+            #     @@loggers ||= {}
+            #     @@loggers[dest]
+            # end
+        
+            # Open a new logger.
+            def open(dest, level= :WARN)
+                @loggers ||= {}
+                logger = ::Logger.new(dest, Spider.conf.get('log.rotate.age'), Spider.conf.get('log.rotate.size'))
+                logger.level = ::Logger.const_get(level)
+                @loggers[dest] = logger
+            end
+            
+            # Close the given logger
+            def close(dest)
+                #raise RuntimeError, "No open logger for #{dest}" unless @loggers && @loggers[dest]
+                @loggers.delete(dest)
+            end
+            
+            # Closes all loggers.
+            def close_all
+                @loggers = {}
+            end
+            
+            # Closes and reopens a logger.
+            def reopen(dest, level= :WARN)
+                raise RuntimeError, "No open logger for #{dest}" unless @loggers && @loggers[dest]
+                @loggers.delete(dest)
+                self.open(dest, level)
+            end
+                
+            # Sends a method to all loggers.
+            def send_to_loggers(action, *args)
+                return if $SAFE > 1
+                return unless @loggers
+                @loggers.each do |dest, logger| 
+                    begin
+                        logger.send(action, *args) 
+                    rescue => exc
+                    end
+                end
+            end
+            
+            def debug(*args)
+                send_to_loggers(:debug, *args)
+            end
+        
+            def info(*args)
+                send_to_loggers(:info, *args)
+            end
+        
+            def warn(*args)
+                send_to_loggers(:warn, *args)
+            end
+            
+            def error(*args)
+                send_to_loggers(:error, *args)
+            end
+
+        end
+        
+        def debug(*args)
+            Spider::Logger.debug(*args)
+        end
+        
+        def info(*args)
+            Spider::Logger.info(*args)
+        end
+        
+        def warn(*args)
+            Spider::Logger.warn(*args)
+        end
+        
+        def error(*args)
+            Spider::Logger.error(*args)
+        end
+        
+        
+    end
+    
+end

data/lib/spiderfw/utils/monkey/class.rb

@@ -0,0 +1,59 @@
+class Class
+    
+    # def parent_module(n=1)
+    #     return const_get_full(self.to_s.reverse.split('::', n+1)[n].reverse)
+    # end
+    
+    def subclass_of?(klass)
+        self < klass
+    end
+    
+    # From ActiveSupport 2.3.4
+    #Copyright (c) 2004-2009 David Heinemeier Hansson
+    
+    def cattr_reader(*syms)
+      syms.flatten.each do |sym|
+        next if sym.is_a?(Hash)
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          unless defined? @@#{sym}  # unless defined? @@hair_colors
+            @@#{sym} = nil          #   @@hair_colors = nil
+          end                       # end
+                                    #
+          def self.#{sym}           # def self.hair_colors
+            @@#{sym}                #   @@hair_colors
+          end                       # end
+                                    #
+          def #{sym}                # def hair_colors
+            @@#{sym}                #   @@hair_colors
+          end                       # end
+        EOS
+      end
+    end
+
+    def cattr_writer(*syms)
+      options = syms.last.is_a?(::Hash) ? syms.pop : {}
+      syms.flatten.each do |sym|
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          unless defined? @@#{sym}                       # unless defined? @@hair_colors
+            @@#{sym} = nil                               #   @@hair_colors = nil
+          end                                            # end
+                                                         #
+          def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+            @@#{sym} = obj                               #   @@hair_colors = obj
+          end                                            # end
+                                                         #
+          #{"                                            #
+          def #{sym}=(obj)                               # def hair_colors=(obj)
+            @@#{sym} = obj                               #   @@hair_colors = obj
+          end                                            # end
+          " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+        EOS
+      end
+    end
+
+    def cattr_accessor(*syms)
+      cattr_reader(*syms)
+      cattr_writer(*syms)
+    end
+    
+end

data/lib/spiderfw/utils/monkey/date_time.rb

@@ -0,0 +1,34 @@
+# A couple of monkey-patched utility methods.
+#--
+# (partially from Rails)
+class Date
+
+    # Converts to a Time object in the GMT timezone.
+    def to_gm_time
+        to_time(new_offset, :gm)
+    end
+
+    # Converts to a Time object in the local timezone.
+    def to_local_time
+        to_time(new_offset(DateTime.now.offset), :local)
+    end
+    
+    def lformat(format = :default, locale=nil, options={})
+        locale ||= Spider.locale
+        Spider::I18n.localize(locale, self, format, options)
+    end
+    
+    def self.lparse(string, format = :default, locale=nil, options={})
+        locale ||= Spider.locale
+        options[:return] = self <= DateTime ? :datetime : :date 
+        Spider::I18n.parse_dt(locale, string, format, options)
+    end
+
+    private
+    def to_time(dest, method)
+        #Convert a fraction of a day to a number of microseconds
+        usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i
+        Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min,
+        dest.sec, usec)
+    end
+end