spiderfw 0.5

data/lib/spiderfw/http/http.rb

@@ -0,0 +1,297 @@
+module Spider
+    module HTTP
+        autoload :Server,   'spiderfw/http/server'
+        #autoload :Thin,     'spiderfw/http/servers/thin'
+        autoload :WEBrick,  'spiderfw/http/adapters/webrick'
+        autoload :Mongrel,  'spiderfw/http/adapters/mongrel'
+        autoload :Thin,     'spiderfw/http/adapters/thin'
+        #autoload :Rack,     'spiderfw/http/adapters/rack/rack'
+        
+        @multipart_regexp = /\Amultipart\/form-data.*boundary=\"?([^\";,]+)/n.freeze
+        
+        module StatusCodes
+        
+            CONTINUE = 100
+            SWITCHING_PROTOCOLS = 101
+            WEBDAV_PROCESSING = 102
+            OK = 200
+            CREATED = 201
+            ACCEPTED = 202
+            NON_AUTHORITATIVE = 203
+            NO_CONTENT = 204
+            RESET_CONTENT = 205
+            PARTIAL_CONTENT = 206
+            WEBDAV_MULTI_STATUS = 207
+            MULTIPLE_CHOICES = 300
+            MOVED_PERMANENTLY = 301
+            FOUND = 302
+            SEE_OTHER = 303
+            NOT_MODIFIED = 304
+            USE_PROXY = 305
+            TEMPORARY_REDIRECT = 307
+            BAD_REQUEST = 400
+            UNAUTHORIZED = 401
+            FORBIDDEN = 403
+            NOT_FOUND = 404
+            METHOD_NOT_ALLOWED = 405
+            NOT_ACCEPTABLE = 406
+            PROXY_AUTHENTICATION_REQUIRED = 407
+            REQUEST_TIMEOUT = 408
+            CONFLICT = 409
+            GONE = 410
+            LENGTH_REQUIRED = 411
+            PRECONDITION_FAILED = 412
+            REQUEST_ENTITY_TOO_LARGE = 413
+            REQUEST_URI_TOO_LONG = 414
+            UNSUPPORTED_MEDIA_TYPE = 415
+            REQUESTED_RANGE_NOT_SATISFIABLE = 416
+            EXPECTATION_FAILED = 417
+            WEBDAV_UNPROCESSABLE_ENTITY = 422
+            WEBDAV_LOCKED = 423
+            WEBDAV_FAILED_DEPENDENCY = 424
+            UPGRADE_REQUIRED = 426
+            INTERNAL_SERVER_ERROR = 500
+            NOT_IMPLEMENTED = 501
+            BAD_GATEWAY = 502
+            SERVICE_UNAVAILABLE = 503
+            GATEWAY_TIMEOUT = 504
+            HTTP_VERSION_NOT_SUPPORTED = 505
+            VARIANT_ALSO_NEGOTIATES = 506
+            WEBDAV_INSUFFICIENT_STORAGE = 507
+            BANDWIDTH_LIMIT_EXCEEDED = 509
+            NOT_EXTENDED = 510
+
+            @status_messages = {
+                CONTINUE => 'Continue',
+                SWITCHING_PROTOCOLS => 'Switching Protocols',
+                WEBDAV_PROCESSING => 'Processing',
+                OK => 'OK',
+                CREATED => 'Created',
+                ACCEPTED => 'Accepted',
+                NON_AUTHORITATIVE => 'Non Authoritative',
+                NO_CONTENT => 'No Content',
+                RESET_CONTENT => 'Reset Content',
+                PARTIAL_CONTENT => 'Partial Content',
+                WEBDAV_MULTI_STATUS => 'Multi-Status',
+                MULTIPLE_CHOICES => 'Multiple Choices',
+                MOVED_PERMANENTLY => 'Moved Permanently',
+                FOUND => 'Found',
+                SEE_OTHER => 'See Other',
+                NOT_MODIFIED => 'Not Modified',
+                USE_PROXY => 'Use Proxy',
+                TEMPORARY_REDIRECT => 'Temporary Redirect',
+                BAD_REQUEST => 'Bad Request',
+                UNAUTHORIZED => 'Unauthorized',
+                FORBIDDEN => 'Forbidden',
+                NOT_FOUND => 'Not Found',
+                METHOD_NOT_ALLOWED => 'Method Not Allowed',
+                NOT_ACCEPTABLE => 'Not Acceptable',
+                PROXY_AUTHENTICATION_REQUIRED => 'Proxy Authentication Required',
+                REQUEST_TIMEOUT => 'Request Timeout',
+                CONFLICT => 'Conflict',
+                GONE => 'Gone',
+                LENGTH_REQUIRED => 'Length Required',
+                PRECONDITION_FAILED => 'Precondition Failed',
+                REQUEST_ENTITY_TOO_LARGE => 'Request Entity Too Large',
+                REQUEST_URI_TOO_LONG => 'Request-URI Too Long',
+                UNSUPPORTED_MEDIA_TYPE => 'Unsupported Media Type',
+                REQUESTED_RANGE_NOT_SATISFIABLE => 'Requested Range Not Satisfiable',
+                EXPECTATION_FAILED => 'Expectation Failed',
+                WEBDAV_UNPROCESSABLE_ENTITY => 'Unprocessable Entity',
+                WEBDAV_LOCKED => 'Locked',
+                WEBDAV_FAILED_DEPENDENCY => 'Failed Dependency',
+                UPGRADE_REQUIRED => 'Upgrade Required',
+                INTERNAL_SERVER_ERROR => 'Internal Server Error',
+                NOT_IMPLEMENTED => 'Not Implemented',
+                BAD_GATEWAY => 'Bad Gateway',
+                SERVICE_UNAVAILABLE => 'Service Unavailable',
+                GATEWAY_TIMEOUT => 'Gateway Timeout',
+                HTTP_VERSION_NOT_SUPPORTED => 'HTTP Version Not Supported',
+                VARIANT_ALSO_NEGOTIATES => 'Variant Also Negotiates',
+                WEBDAV_INSUFFICIENT_STORAGE => 'Insufficient Storage',
+                BANDWIDTH_LIMIT_EXCEEDED => 'Bandwidth Limit Exceeded',
+                NOT_EXTENDED => 'Not Extended'
+            }
+        
+            def self.status_messages
+                @status_messages
+            end
+            
+        end
+        
+        include StatusCodes
+        
+        def self.status_messages
+            StatusCodes.status_messages
+        end
+        
+        # ==== Parameters
+        # s<String>:: String to URL escape.
+        #
+        # ==== returns
+        # String:: The escaped string.
+        #--
+        # from Merb        
+        def self.urlencode(s)
+           s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+             '%'+$1.unpack('H2'*$1.size).join('%').upcase
+           }.tr(' ', '+')
+        end
+
+        # ==== Parameter
+        # s<String>:: String to URL unescape.
+        #
+        # ==== returns
+        # String:: The unescaped string.
+        #--
+        # from Merb
+        def self.urldecode(s)
+          s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+            [$1.delete('%')].pack('H*')
+          }
+        end
+        
+        # ==== Parameters
+        # qs<String>:: The query string.
+        # d<String>:: The query string divider. Defaults to "&".
+        #
+        # ==== Returns
+        # Mash:: The parsed query string.
+        #
+        # ==== Examples
+        #   query_parse("bar=nik&post[body]=heya")
+        #     # => { :bar => "nik", :post => { :body => "heya" } }
+        #--
+        # from Merb
+        def self.parse_query(qs, d = '&;')
+          return (qs||'').split(/[#{d}] */n).inject({}) { |h,p| 
+            key, value = urldecode(p).split('=',2)
+            normalize_params(h, key, value)
+          }
+        end
+        
+        
+        # Converts a query string snippet to a hash and adds it to existing
+        # parameters.
+        #
+        # ==== Parameters
+        # parms<Hash>:: Parameters to add the normalized parameters to.
+        # name<String>:: The key of the parameter to normalize.
+        # val<String>:: The value of the parameter.
+        #
+        # ==== Returns
+        # Hash:: Normalized parameters
+        #--
+        # from Merb
+        def self.normalize_params(parms, name, val=nil)
+          name =~ %r([\[\]]*([^\[\]]+)\]*)
+          key = $1 || ''
+          after = $' || ''
+
+          if after == ""
+            parms[key] = val
+          elsif after == "[]"
+            (parms[key] ||= []) << val
+          elsif after =~ %r(^\[\])
+            parms[key] ||= []
+            parms[key] << normalize_params({}, after, val)
+          else
+            parms[key] ||= {}
+            parms[key] = normalize_params(parms[key], after, val)
+          end
+          parms
+        end
+        
+        # ==== Parameters
+        # request<IO>:: The raw request.
+        # boundary<String>:: The boundary string.
+        # content_length<Fixnum>:: The length of the content.
+        #
+        # ==== Raises
+        # ControllerExceptions::MultiPartParseError:: Failed to parse request.
+        #
+        # ==== Returns
+        # Hash:: The parsed request.
+        #--
+        # from Merb
+        # da utilizzare
+        def self.parse_multipart(request, boundary, content_length)
+          boundary = "--#{boundary}"
+          paramhsh = {}
+          buf = ""
+          input = request
+          input.binmode if defined? input.binmode
+          boundary_size = boundary.size + EOL.size
+          bufsize = 16384
+          content_length -= boundary_size
+          status = input.read(boundary_size)
+          raise ControllerExceptions::MultiPartParseError, "bad content body:\n'#{status}' should == '#{boundary + EOL}'"  unless status == boundary + EOL
+          rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/
+          loop {
+            head = nil
+            body = ''
+            filename = content_type = name = nil
+            read_size = 0
+            until head && buf =~ rx
+              i = buf.index("\r\n\r\n")
+              if( i == nil && read_size == 0 && content_length == 0 )
+                content_length = -1
+                break
+              end
+              if !head && i
+                head = buf.slice!(0, i+2) # First \r\n
+                buf.slice!(0, 2)          # Second \r\n
+                filename = head[FILENAME_REGEX, 1]
+                content_type = head[CONTENT_TYPE_REGEX, 1]
+                name = head[NAME_REGEX, 1]
+
+                if filename && !filename.empty?
+                  body = Tempfile.new(:Merb)
+                  body.binmode if defined? body.binmode
+                end
+                next
+              end
+
+              # Save the read body part.
+              if head && (boundary_size+4 < buf.size)
+                body << buf.slice!(0, buf.size - (boundary_size+4))
+              end
+
+              read_size = bufsize < content_length ? bufsize : content_length
+              if( read_size > 0 )
+                c = input.read(read_size)
+                raise ControllerExceptions::MultiPartParseError, "bad content body"  if c.nil? || c.empty?
+                buf << c
+                content_length -= c.size
+              end
+            end
+
+            # Save the rest.
+            if i = buf.index(rx)
+              body << buf.slice!(0, i)
+              buf.slice!(0, boundary_size+2)
+
+              content_length = -1  if $1 == "--"
+            end
+
+            if filename && !filename.empty?   
+              body.rewind
+              data = { 
+                :filename => File.basename(filename),  
+                :content_type => content_type,  
+                :tempfile => body, 
+                :size => File.size(body.path) 
+              }
+            else
+              data = body
+            end
+            paramhsh = normalize_params(paramhsh,name,data)
+            break  if buf.empty? || content_length == -1
+          }
+          paramhsh
+        end
+        
+        
+    end
+    
+end

data/lib/spiderfw/http/server.rb

@@ -0,0 +1,40 @@
+require 'spiderfw/controller/http_controller'
+
+module Spider; module HTTP
+    
+    class Server
+        
+        @supports = {
+            :chunked_request => false,
+            :ssl => false
+        }
+
+        def self.supports?(capability)
+            @supports[capability]
+        end
+
+        
+        def options(opts={})
+            defaults = {
+                :host => '0.0.0.0',
+                :port => 8080
+            }
+            return defaults.merge(opts)
+        end
+        
+        def start(opts={})
+            @options = opts
+            start_server(opts)
+        end
+        
+        def shutdown
+            Spider.logger.info("Webserver shutdown");
+            shutdown_server            
+        end
+        
+        def request_received
+        end
+        
+    end
+    
+end; end

data/lib/spiderfw/i18n/cldr.rb

@@ -0,0 +1,114 @@
+require 'yaml'
+require 'cldr'
+require 'locale'
+
+module Spider; module I18n
+    
+    class CLDR < Provider
+                
+        def initialize(locale)
+            @locale = locale
+            @cldr = ::CLDR::Object.new(:locale => locale.to_cldr)
+
+        end
+
+        def localize_date_time(locale, object, format = :default, options={})
+            options[:calendar] ||= 'gregorian'
+            
+            if (format == :default)
+                format = @cldr.calendar.dateformat_defaults[options[:calendar]]
+            end
+            
+            time_format = nil
+            date_format = nil
+            format_string = nil
+            if (object.respond_to?(:sec) && !options[:no_time])
+                time_format = @cldr.calendar.timeformats[options[:calendar].to_sym][format.to_s].dup
+            end
+            if (object.is_a?(Date))
+                date_format = @cldr.calendar.dateformats[options[:calendar].to_sym][format.to_s].dup
+            end
+            if (date_format && time_format)
+                dt_f = @cldr.calendar.datetimeformats[options[:calendar].to_s]
+                format_string = dt_f.sub('{1}', date_format).sub('{0}', time_format)
+            else
+                format_string = date_format ? date_format : time_format
+            end
+
+            # FIXME: handle more efficiently
+            d = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']
+            obj_d = d[object.wday]
+            days = @cldr.calendar.days[options[:calendar].to_sym]
+            months = @cldr.calendar.months[options[:calendar].to_sym]
+            replacements = [
+                [/y{1,4}/, '%Y'], # year  don't use two digits year, they cause confusion [/y{1,2}/, '%y']
+                [/M{5}/, months[:narrow][object.month.to_s]], [/M{4}/, months[:wide][object.month.to_s]], #month
+                [/M{3}/, months[:abbreviated][object.month.to_s]], [/M{1,2}/, '%m'], 
+                [/L{5}/, months[:narrow][object.month.to_s]], [/L{4}/, months[:wide][object.month.to_s]], #month
+                [/L{3}/, months[:abbreviated][object.month.to_s]], [/L{1,2}/, '%m'], 
+                [/E{5}/, days[:narrow][obj_d]], [/E{4}/, days[:wide][obj_d]], [/E{1,3}/, days[:abbreviated][obj_d]], #day of the week
+                [/e{1,5}/, '%w'], #day of the week (numeric)
+                [/d{1,2}/, '%d'], # day of the month
+                [/h{1,2}/, '%I'], [/H{1,2}/, '%H'], [/a/, '%p'], #hour
+                [/m{1,2}/, '%M'], [/s{1,2}/, '%S'], # seconds
+                [/z{1,4}/, '%Z'], [/Z{1,4}/, '%Z'], [/V{1,4}/, '%Z'] # time zone
+            ]
+            format_string = mgsub(format_string, replacements)
+
+            if (time_format)
+                am = @cldr.calendar.am[options[:calendar].to_s]
+                pm = @cldr.calendar.pm[options[:calendar].to_s]
+                format_string.gsub!(/%p/, object.hour < 12 ? am : pm) if object.respond_to? :hour
+            end
+            object.strftime(format_string)
+        end
+        
+        # FIXME: add extended format handling like in localize
+        def parse_dt(locale, string, format = :default, options = {})
+            options[:calendar] ||= 'gregorian'
+            
+            if (format == :default)
+                format = @cldr.calendar.dateformat_defaults[options[:calendar]]
+            end
+            time_format = @cldr.calendar.timeformats[options[:calendar].to_sym][format.to_s].dup
+            date_format = @cldr.calendar.dateformats[options[:calendar].to_sym][format.to_s].dup
+            if (options[:return] == :datetime)
+                dt_f = @cldr.calendar.datetimeformats[options[:calendar].to_s]
+                format_string = dt_f.sub('{1}', date_format).sub('{0}', time_format)
+                klass = DateTime
+            elsif (options[:return] == :date)
+                format_string = date_format
+                klass = Date
+            end
+            replacements = [
+                [/y{1,4}/, '%Y'], # year      don't use two digits year [/y{1,2}/, '%y'],
+                [/M{1,5}/, '%m'],
+                [/L{1,5}/, '%m'],
+                [/E{1,5}/, ''], #day of the week
+                [/e{1,5}/, '%w'], #day of the week (numeric)
+                [/d{1,2}/, '%d'], # day of the month
+                [/h{1,2}/, '%I'], [/H{1,2}/, '%H'], [/a/, '%p'], #hour
+                [/m{1,2}/, '%M'], [/s{1,2}/, '%S'], # seconds
+                [/z{1,4}/, '%Z'], [/Z{1,4}/, '%Z'], [/V{1,4}/, '%Z'] # time zone
+            ]
+            format_string = mgsub(format_string, replacements)
+            klass.strptime(string, format_string)
+        end
+        
+        
+        def prepare_format_string(obj, string)
+ 
+        end
+        
+        
+        def mgsub(string, key_value_pairs)
+            regexp_fragments = key_value_pairs.collect { |k,v| k }
+            string.gsub( 
+            Regexp.union(*regexp_fragments)) do |match|
+                key_value_pairs.detect{|k,v| k =~ match}[1]
+            end
+        end
+        
+    end
+    
+end; end

data/lib/spiderfw/i18n/gettext.rb

@@ -0,0 +1,8 @@
+# def _(s)
+#     s
+# end
+
+require 'gettext'
+include GetText
+bindtextdomain('spider')
+GetText.set_output_charset('utf-8')

data/lib/spiderfw/i18n/i18n.rb

@@ -0,0 +1,120 @@
+require 'lib/spiderfw/i18n/provider'
+require 'lib/spiderfw/i18n/rails'
+begin
+    require 'lib/spiderfw/i18n/cldr'
+rescue LoadError
+end
+
+module Spider
+
+    module I18n
+        DefaultLocale = 'en'
+        
+        class << self
+            
+            def init
+                @locales = {}
+            end
+            
+            def providers
+                [:CLDR, :Rails]
+            end
+            
+            def provider(locale)
+                @locales[locale] = load_locale(locale) unless @locales[locale]
+                unless @locales[locale]
+                    default = Spider.conf.get('i18n.default_locale')
+                    load_locale(default) unless @locales[default]
+                    return @locales[default]
+                end
+                return @locales[locale]
+            end
+                    
+        
+            def load_locale(locale)
+                self.providers.each do |p|
+                    res = try_provider(p, locale)
+                    return res if res
+                end
+                return nil
+            end
+            
+            def try_provider(const, locale)
+                begin
+                    res = const_get(const).new(locale)
+                rescue => exc
+                    return nil
+                end
+            end
+            
+            def localize(*args)
+                localize_date_time(*args)
+            end
+
+            def localize_date_time(locale, object, format = :default, options={})
+                raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
+                p = provider(locale)
+                unless p
+                    Spider::Logger.error("No provider found for locale #{locale}")
+                    return object.to_s
+                end
+                return p.localize_date_time(locale, object, format, options)
+            end
+            
+            def parse_dt(locale, string, format = :default, options={})
+                p = provider(locale)
+                unless p
+                    Spider::Logger.error("No provider found for locale #{locale}")
+                    return Date.parse(string)
+                end
+                return p.parse_dt(locale, string, format, options)
+            end
+            
+            def parse_date(locale, string, format = :default, options = {})
+                parse_dt(locale, string, format, options.merge({:return => :date}))
+            end
+
+            def parse_datetime(locale, string, format = :default, options = {})
+                parse_dt(locale, string, format, options.merge({:return => :datetime}))
+            end
+            
+            # from Rails
+            def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+                from_time = from_time.to_time if from_time.respond_to?(:to_time)
+                from_time = from_time.to_local_time if from_time.respond_to?(:to_local_time)
+                to_time = to_time.to_time if to_time.respond_to?(:to_time)
+                to_time = to_time.to_local_time if to_time.respond_to?(:to_local_time)
+                distance_in_minutes = (((to_time - from_time).abs)/60).round
+                distance_in_seconds = ((to_time - from_time).abs).round
+
+                case distance_in_minutes
+                when 0..1
+                    return (distance_in_minutes == 0) ? _('less than a minute') : _('1 minute') unless include_seconds
+                    case distance_in_seconds
+                    when 0..4   then _('less than %s seconds') % '5'
+                    when 5..9   then _('less than %s seconds') % '10'
+                    when 10..19 then _('less than %s seconds') % '20'
+                    when 20..39 then _('half a minute')
+                    when 40..59 then _('less than a minute')
+                    else             _('1 minute')
+                    end
+
+                when 2..44           then _("%s minutes") % distance_in_minutes
+                when 45..89          then _('about 1 hour')
+                when 90..1439        then _("about %d hours") % (distance_in_minutes.to_f / 60.0).round
+                when 1440..2879      then _('1 day')
+                when 2880..43199     then _("%d days") % (distance_in_minutes / 1440).round
+                when 43200..86399    then _('about 1 month')
+                when 86400..525599   then _("%d months") % (distance_in_minutes / 43200).round
+                when 525600..1051199 then _('about 1 year')
+                else                      _("over %d years") % (distance_in_minutes / 525600).round
+                end
+            end
+            
+        end
+
+    end
+    I18n.init
+
+
+end

data/lib/spiderfw/i18n/provider.rb

@@ -0,0 +1,12 @@
+module Spider; module I18n
+    
+    class Provider
+        
+        def localize(locale, object, format = :default, options={})
+            raise "Unimplemented"
+        end
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/i18n/rails.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+
+module Spider; module I18n
+    
+    class Rails < Provider
+        
+        def initialize(locale)
+            @locale = load_locale(locale)
+        end
+
+
+        def load_locale(locale)
+            orig_locale = locale
+            file, locale = find_locale(locale)
+            l = load_locale_file(file) if file
+            @locale_data = l[locale] if l
+            raise ArgumentError unless @l
+            @locale_data.extend(Spider::HashDottedAccess)
+            return locale
+        end
+
+        def load_locale_file(filename)
+            type = File.extname(filename).tr('.', '').downcase
+            if (type == 'rb')
+                return eval(IO.read(filename), binding, filename)
+            elsif (type == 'yml')
+                return YAML::load(IO.read(filename))
+            end
+        end
+
+
+        def find_locale(locale)
+            try = locale.to_s
+            while (try)
+                extensions = ['yml', 'rb']
+                extensions.each do |ext|
+                    full_path = Spider.conf.get('i18n.rails_path')+'/'+try+'.'+ext
+                    return [full_path, try] if (File.exist?(full_path))
+                end
+                if (try =~ (/^([^\.-_@]+)[\.-_@]/))
+                    try = $1
+                else
+                    try = false
+                end
+            end
+        end
+
+        def localize_date_time(locale, object, format = :default, options={})
+            l = @locale_data
+            type = object.respond_to?(:sec) ? 'time' : 'date'
+            formats = l["#{type}.formats"]
+            format = formats[format.to_s] if formats && formats[format.to_s]
+            raise "Format #{format} not found" unless format
+
+            format = format.to_s.dup
+
+            format.gsub!(/%a/, l['date.abbr_day_names'][object.wday])
+            format.gsub!(/%A/, l["date.day_names"][object.wday])
+            format.gsub!(/%b/, l["date.abbr_month_names"][object.mon])
+            format.gsub!(/%B/, l["date.month_names"][object.mon])
+            format.gsub!(/%p/, l["time.#{object.hour < 12 ? :am : :pm}"]) if object.respond_to? :hour
+            object.strftime(format)
+        end
+        
+        # FIXME: add extended format handling like in localize
+        def parse_date_time(locale, string, format = :default, options={})
+            l = @locale_data
+            type = object.respond_to?(:sec) ? 'time' : 'date'
+            formats = l["#{type}.formats"]
+            format = formats[format.to_s] if formats && formats[format.to_s]
+            raise "Format #{format} not found" unless format
+
+            format = format.to_s.dup
+            if (options[:return] == :datetime)
+                klass = DateTime
+            elsif (options[:return] == :date)
+                klass = Date
+            end
+            object.strptime(format)
+        end
+
+        
+        def time_ago_in_words(from_time, include_seconds = false)
+          distance_of_time_in_words(from_time, Time.now, include_seconds)
+        end
+        
+    end
+    
+end; end