egalite 0.0.1

data/m17n.rb

@@ -0,0 +1,193 @@
+
+module Egalite
+  module M17N
+    
+    
+    module Filters
+      def before_filter
+        # check hostname first to determine which language to serve.
+        first = req.host.split(/\./).first
+        @lang = Translation.lang(first)
+        if not @lang and req.accept_language and Translation.allow_content_negotiation
+          # fallback to Accept-Language HTTP header for language to serve.
+          langs = req.accept_language.split(/,/)
+          @lang = langs.map { |s| Translation.lang(s.split(/;/).first) }.compact.first
+        end
+        @lang ||= Translation.lang(Translation.user_default_lang)
+        @lang ||= Translation.lang('ja')
+        
+        super
+      end
+      def filter_on_html_load(html,path)
+        html = @lang.translate_html(path, html) if @lang
+        super(html,path)
+      end
+      def after_filter_return_value(response)
+        if @lang
+          response = @lang.translate_msg(req.controller_class, req.action_method, response)
+        end
+        super(response)
+      end
+      def _(str, values = [])
+        if @lang
+          str = @lang.translate_string(req.controller_class, req.action_method, str, values)
+        else
+          str = str.dup
+          values.each_with_index { |s2,i| str.gsub!(/\{#{i}\}/, s2) }
+        end
+        str
+      end
+    end
+    class Controller < Egalite::Controller
+      include Filters
+    end
+    
+    
+    class Translation
+      class <<self
+        attr_accessor :langs, :user_default_lang, :allow_content_negotiation
+      end
+      def self.load(path)
+        @@langs = {}
+        
+        s = open(path) { |f| f.read }
+        
+        langs = nil
+        system_default = nil
+        
+        [:languages, :system_default, :english_name, :native_name, :aliases].each { |optname|
+          s.gsub!(/\{\{#{optname}\s*(.+?)\s*\}\}\s*\n+/i) {
+            values = $1.split(/\s*,\s*/)
+            case optname
+              when :languages
+                langs = values
+                values.each { |lang|
+                  @@langs[lang] = Translation.new(lang)
+                  @@langs[lang].data = {}
+                }
+              when :system_default
+                lang = values.shift
+                @@langs[lang] = Translation.new(lang)
+                @@langs[lang].data = nil
+                system_default = lang
+              when :aliases
+                lang = values.shift
+                @@langs[lang].send("#{optname}=", values)
+              else
+                lang = values.shift
+                @@langs[lang].send("#{optname}=", values.first)
+            end
+            ''
+          }
+        }
+        
+        s.split(/###+\s*\n+/).each { |part|
+          next if part =~ /\A\s*\Z/
+          lines = part.split(/\n+/)
+          key = lines.shift
+          (type, path) = key.split(/\s+/,2)
+          raise "Egalite::M17N::Translation.load: type should be 'html', 'msg' or 'img' but it was '#{type}'" unless %w[msg html img].include?(type)
+          lines.each { |line|
+            if type == 'img'
+              langs.each { |lang|
+                next unless @@langs[lang].data
+                img = line.sub(/\.(jpg|jpeg|gif|png)/i,"_#{lang}.\\1")
+                @@langs[lang].data[:img] ||= {}
+                @@langs[lang].data[:img][path] ||= {}
+                @@langs[lang].data[:img][path][line] = img
+              }
+            else
+              a = line.split(/\s*\t+\s*/)
+              k = nil
+              a.each_with_index { |s,i|
+                unless @@langs[langs[i]].data
+                  k = s
+                else
+                  @@langs[langs[i]].data[type.to_sym] ||= {}
+                  @@langs[langs[i]].data[type.to_sym][path] ||= {}
+                  @@langs[langs[i]].data[type.to_sym][path][k] = s
+                end
+              }
+            end
+          }
+        }
+        @@langs
+      end
+      def self.lang(s)
+        return nil unless s
+        a =   @@langs.find { |k,v| v.fullmatch?(s) }
+        a ||= @@langs.find { |k,v| v.partialmatch?(s) }
+        a ? a.last : nil
+      end
+      private
+      def method_path(c,a)
+        c.class.name.to_s + '#' + a.to_s
+      end
+      def t_string(list, s)
+        list[s] ? list[s] : s
+      end
+      def t_hash(list, h)
+        if h.is_a?(EgaliteResponse)
+          h.param = t_hash(list, h.param)
+          return h
+        end
+        return h unless h.is_a?(Hash)
+        h2 = {}
+        h.each { |k,v|
+          h2[k] = case v
+            when String: t_string(list,v)
+            when Array: v.map { |x| t_hash(list,x) }
+            when Hash: t_hash(list, v)
+            else v
+          end
+        }
+        h2
+      end
+
+    public
+
+      attr_accessor :english_name, :native_name, :aliases, :data
+      attr_reader :langcode
+      
+      def initialize(langcode)
+        @langcode = langcode
+        @aliases = []
+      end
+      def fullmatch?(lang)
+        lang = lang.to_s.downcase
+        @langcode == lang or @aliases.include?(lang)
+      end
+      def partialmatch?(lang)
+        fullmatch?(lang.to_s.split(/-/).first)
+      end
+      def translate_html(path, html)
+        return html unless @data
+        list = @data[:html][path]
+        return html unless list
+        s = html.dup
+        list.sort { |a,b| b[0].length <=> a[0].length }.each { |k,v| s.gsub!(k, v)}
+        if @data[:img] and @data[:img][path]
+          @data[:img][path].each { |k,v| s.gsub!(k, v) }
+        end
+        s
+      end
+      def translate_msg(controller, action, msg)
+        return msg unless @data
+        list = @data[:msg][method_path(controller,action)]
+        return msg unless list
+        t_hash(list, msg)
+      end
+      def translate_string(controller, action, string, placeholders = [])
+        if @data
+          list = @data[:msg][method_path(controller,action)]
+          if list
+            string = t_string(list, string)
+          end
+        end
+        string = string.dup
+        placeholders.each_with_index { |s2,i| string.gsub!(/\{#{i}\}/, s2) }
+        string
+      end
+    end
+  end
+end

data/rack/auth/abstract/handler.rb

@@ -0,0 +1,37 @@
+module Rack
+  module Auth
+    # Rack::Auth::AbstractHandler implements common authentication functionality.
+    #
+    # +realm+ should be set for all handlers.
+
+    class AbstractHandler
+
+      attr_accessor :realm
+
+      def initialize(app, realm=nil, &authenticator)
+        @app, @realm, @authenticator = app, realm, authenticator
+      end
+
+
+      private
+
+      def unauthorized(www_authenticate = challenge)
+        return [ 401,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0',
+            'WWW-Authenticate' => www_authenticate.to_s },
+          []
+        ]
+      end
+
+      def bad_request
+        return [ 400,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0' },
+          []
+        ]
+      end
+
+    end
+  end
+end

data/rack/auth/abstract/request.rb

@@ -0,0 +1,37 @@
+module Rack
+  module Auth
+    class AbstractRequest
+
+      def initialize(env)
+        @env = env
+      end
+
+      def provided?
+        !authorization_key.nil?
+      end
+
+      def parts
+        @parts ||= @env[authorization_key].split(' ', 2)
+      end
+
+      def scheme
+        @scheme ||= parts.first.downcase.to_sym
+      end
+
+      def params
+        @params ||= parts.last
+      end
+
+
+      private
+
+      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+
+      def authorization_key
+        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @env.has_key?(key) }
+      end
+
+    end
+
+  end
+end

data/rack/auth/basic.rb

@@ -0,0 +1,58 @@
+require 'rack/auth/abstract/handler'
+require 'rack/auth/abstract/request'
+
+module Rack
+  module Auth
+    # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
+    #
+    # Initialize with the Rack application that you want protecting,
+    # and a block that checks if a username and password pair are valid.
+    #
+    # See also: <tt>example/protectedlobster.rb</tt>
+
+    class Basic < AbstractHandler
+
+      def call(env)
+        auth = Basic::Request.new(env)
+
+        return unauthorized unless auth.provided?
+
+        return bad_request unless auth.basic?
+
+        if valid?(auth)
+          env['REMOTE_USER'] = auth.username
+
+          return @app.call(env)
+        end
+
+        unauthorized
+      end
+
+
+      private
+
+      def challenge
+        'Basic realm="%s"' % realm
+      end
+
+      def valid?(auth)
+        @authenticator.call(*auth.credentials)
+      end
+
+      class Request < Auth::AbstractRequest
+        def basic?
+          :basic == scheme
+        end
+
+        def credentials
+          @credentials ||= params.unpack("m*").first.split(/:/, 2)
+        end
+
+        def username
+          credentials.first
+        end
+      end
+
+    end
+  end
+end

data/rack/auth/digest/md5.rb

@@ -0,0 +1,124 @@
+require 'rack/auth/abstract/handler'
+require 'rack/auth/digest/request'
+require 'rack/auth/digest/params'
+require 'rack/auth/digest/nonce'
+require 'digest/md5'
+
+module Rack
+  module Auth
+    module Digest
+      # Rack::Auth::Digest::MD5 implements the MD5 algorithm version of
+      # HTTP Digest Authentication, as per RFC 2617.
+      #
+      # Initialize with the [Rack] application that you want protecting,
+      # and a block that looks up a plaintext password for a given username.
+      #
+      # +opaque+ needs to be set to a constant base64/hexadecimal string.
+      #
+      class MD5 < AbstractHandler
+
+        attr_accessor :opaque
+
+        attr_writer :passwords_hashed
+
+        def initialize(*args)
+          super
+          @passwords_hashed = nil
+        end
+
+        def passwords_hashed?
+          !!@passwords_hashed
+        end
+
+        def call(env)
+          auth = Request.new(env)
+
+          unless auth.provided?
+            return unauthorized
+          end
+
+          if !auth.digest? || !auth.correct_uri? || !valid_qop?(auth)
+            return bad_request
+          end
+
+          if valid?(auth)
+            if auth.nonce.stale?
+              return unauthorized(challenge(:stale => true))
+            else
+              env['REMOTE_USER'] = auth.username
+
+              return @app.call(env)
+            end
+          end
+
+          unauthorized
+        end
+
+
+        private
+
+        QOP = 'auth'.freeze
+
+        def params(hash = {})
+          Params.new do |params|
+            params['realm'] = realm
+            params['nonce'] = Nonce.new.to_s
+            params['opaque'] = H(opaque)
+            params['qop'] = QOP
+
+            hash.each { |k, v| params[k] = v }
+          end
+        end
+
+        def challenge(hash = {})
+          "Digest #{params(hash)}"
+        end
+
+        def valid?(auth)
+          valid_opaque?(auth) && valid_nonce?(auth) && valid_digest?(auth)
+        end
+
+        def valid_qop?(auth)
+          QOP == auth.qop
+        end
+
+        def valid_opaque?(auth)
+          H(opaque) == auth.opaque
+        end
+
+        def valid_nonce?(auth)
+          auth.nonce.valid?
+        end
+
+        def valid_digest?(auth)
+          digest(auth, @authenticator.call(auth.username)) == auth.response
+        end
+
+        def md5(data)
+          ::Digest::MD5.hexdigest(data)
+        end
+
+        alias :H :md5
+
+        def KD(secret, data)
+          H([secret, data] * ':')
+        end
+
+        def A1(auth, password)
+          [ auth.username, auth.realm, password ] * ':'
+        end
+
+        def A2(auth)
+          [ auth.method, auth.uri ] * ':'
+        end
+
+        def digest(auth, password)
+          password_hash = passwords_hashed? ? password : H(A1(auth, password))
+
+          KD(password_hash, [ auth.nonce, auth.nc, auth.cnonce, QOP, H(A2(auth)) ] * ':')
+        end
+
+      end
+    end
+  end
+end

data/rack/auth/digest/nonce.rb

@@ -0,0 +1,51 @@
+require 'digest/md5'
+
+module Rack
+  module Auth
+    module Digest
+      # Rack::Auth::Digest::Nonce is the default nonce generator for the
+      # Rack::Auth::Digest::MD5 authentication handler.
+      #
+      # +private_key+ needs to set to a constant string.
+      #
+      # +time_limit+ can be optionally set to an integer (number of seconds),
+      # to limit the validity of the generated nonces.
+
+      class Nonce
+
+        class << self
+          attr_accessor :private_key, :time_limit
+        end
+
+        def self.parse(string)
+          new(*string.unpack("m*").first.split(' ', 2))
+        end
+
+        def initialize(timestamp = Time.now, given_digest = nil)
+          @timestamp, @given_digest = timestamp.to_i, given_digest
+        end
+
+        def to_s
+          [([ @timestamp, digest ] * ' ')].pack("m*").strip
+        end
+
+        def digest
+          ::Digest::MD5.hexdigest([ @timestamp, self.class.private_key ] * ':')
+        end
+
+        def valid?
+          digest == @given_digest
+        end
+
+        def stale?
+          !self.class.time_limit.nil? && (@timestamp - Time.now.to_i) < self.class.time_limit
+        end
+
+        def fresh?
+          !stale?
+        end
+
+      end
+    end
+  end
+end

data/rack/auth/digest/params.rb

@@ -0,0 +1,55 @@
+module Rack
+  module Auth
+    module Digest
+      class Params < Hash
+
+        def self.parse(str)
+          split_header_value(str).inject(new) do |header, param|
+            k, v = param.split('=', 2)
+            header[k] = dequote(v)
+            header
+          end
+        end
+
+        def self.dequote(str) # From WEBrick::HTTPUtils
+          ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
+          ret.gsub!(/\\(.)/, "\\1")
+          ret
+        end
+
+        def self.split_header_value(str)
+          str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
+        end
+
+        def initialize
+          super
+
+          yield self if block_given?
+        end
+
+        def [](k)
+          super k.to_s
+        end
+
+        def []=(k, v)
+          super k.to_s, v.to_s
+        end
+
+        UNQUOTED = ['nc', 'stale']
+
+        def to_s
+          inject([]) do |parts, (k, v)|
+            parts << "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(v))
+            parts
+          end.join(', ')
+        end
+
+        def quote(str) # From WEBrick::HTTPUtils
+          '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
+        end
+
+      end
+    end
+  end
+end
+

data/rack/auth/digest/request.rb

@@ -0,0 +1,40 @@
+require 'rack/auth/abstract/request'
+require 'rack/auth/digest/params'
+require 'rack/auth/digest/nonce'
+
+module Rack
+  module Auth
+    module Digest
+      class Request < Auth::AbstractRequest
+
+        def method
+          @env['rack.methodoverride.original_method'] || @env['REQUEST_METHOD']
+        end
+
+        def digest?
+          :digest == scheme
+        end
+
+        def correct_uri?
+          (@env['SCRIPT_NAME'].to_s + @env['PATH_INFO'].to_s) == uri
+        end
+
+        def nonce
+          @nonce ||= Nonce.parse(params['nonce'])
+        end
+
+        def params
+          @params ||= Params.parse(parts.last)
+        end
+
+        def method_missing(sym)
+          if params.has_key? key = sym.to_s
+            return params[key]
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/rack/builder.rb

@@ -0,0 +1,80 @@
+module Rack
+  # Rack::Builder implements a small DSL to iteratively construct Rack
+  # applications.
+  #
+  # Example:
+  #
+  #  app = Rack::Builder.new {
+  #    use Rack::CommonLogger
+  #    use Rack::ShowExceptions
+  #    map "/lobster" do
+  #      use Rack::Lint
+  #      run Rack::Lobster.new
+  #    end
+  #  }
+  #
+  # Or
+  #
+  #  app = Rack::Builder.app do
+  #    use Rack::CommonLogger
+  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
+  #  end
+  #
+  # +use+ adds a middleware to the stack, +run+ dispatches to an application.
+  # You can use +map+ to construct a Rack::URLMap in a convenient way.
+
+  class Builder
+    def self.parse_file(config, opts = Server::Options.new)
+      options = {}
+      if config =~ /\.ru$/
+        cfgfile = ::File.read(config)
+        if cfgfile[/^#\\(.*)/] && opts
+          options = opts.parse! $1.split(/\s+/)
+        end
+        cfgfile.sub!(/^__END__\n.*/, '')
+        app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app",
+          TOPLEVEL_BINDING, config
+      else
+        require config
+        app = Object.const_get(::File.basename(config, '.rb').capitalize)
+      end
+      return app, options
+    end
+
+    def initialize(&block)
+      @ins = []
+      instance_eval(&block) if block_given?
+    end
+
+    def self.app(&block)
+      self.new(&block).to_app
+    end
+
+    def use(middleware, *args, &block)
+      @ins << lambda { |app| middleware.new(app, *args, &block) }
+    end
+
+    def run(app)
+      @ins << app #lambda { |nothing| app }
+    end
+
+    def map(path, &block)
+      if @ins.last.kind_of? Hash
+        @ins.last[path] = self.class.new(&block).to_app
+      else
+        @ins << {}
+        map(path, &block)
+      end
+    end
+
+    def to_app
+      @ins[-1] = Rack::URLMap.new(@ins.last)  if Hash === @ins.last
+      inner_app = @ins.last
+      @ins[0...-1].reverse.inject(inner_app) { |a, e| e.call(a) }
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+  end
+end