olelo 0.9.0

data/lib/olelo/user.rb

@@ -0,0 +1,132 @@
+module Olelo
+  class AuthenticationError < RuntimeError
+    def status
+      :forbidden
+    end
+  end
+
+  class AccessDenied < RuntimeError
+    def initialize
+      super(:access_denied.t)
+    end
+
+    def status
+      :forbidden
+    end
+  end
+
+  class User
+    include Util
+    attr_reader :name, :groups
+    attr_accessor :email
+
+    def initialize(name, email, groups = nil)
+      @name, @email, @groups = name, email, Set.new(groups.to_a)
+    end
+
+    def change_password(oldpassword, password, confirm)
+      User.validate_password(password, confirm)
+      User.service.change_password(self, oldpassword, password)
+    end
+
+    def modify(&block)
+      copy = dup
+      block.call(copy)
+      validate
+      User.service.update(copy)
+      instance_variables.each do |name|
+        instance_variable_set(name, copy.instance_variable_get(name))
+      end
+    end
+
+    def validate
+      check do |errors|
+        errors << :invalid_email.t if email !~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+        errors << :invalid_name.t  if name !~ /[\w\.\-\+_]+/
+      end
+    end
+
+    class Service
+      include Util
+      extend Factory
+
+      class NotSupportedError < AuthenticationError
+        def initialize(name)
+          super(:auth_unsupported.t(:name => name))
+        end
+      end
+
+      def find(name)
+        raise NotImplementedError
+      end
+
+      def authenticate(name, password)
+        raise NotImplementedError
+      end
+
+      def create(user, password)
+        raise NotSupportedError('create')
+      end
+
+      def update(user)
+        raise NotSupportedError('update')
+      end
+
+      def change_password(user, oldpassword, password)
+        raise NotSupportedError('change_password')
+      end
+    end
+
+    class<< self
+      def current
+        Thread.current[:olelo_user]
+      end
+
+      def current=(user)
+        Thread.current[:olelo_user] = user
+      end
+
+      def logged_in?
+        current && current.groups.include?('user')
+      end
+
+      def service
+        @service ||= Service[Config['authentication.service']].new(Config['authentication'][Config['authentication.service']])
+      end
+
+      def validate_password(password, confirm)
+        check do |errors|
+          errors << :passwords_do_not_match.t if password != confirm
+          errors << :empty_password.t if password.blank?
+        end
+      end
+
+      def anonymous(request)
+        ip = request.ip || 'unknown-ip'
+        name = request.remote_host ? "#{request.remote_host} (#{ip})" : ip
+        new(name, "anonymous@#{ip}")
+      end
+
+      def find!(name)
+        service.find(name)
+      end
+
+      def find(name)
+        find!(name) rescue nil
+      end
+
+      def authenticate(name, password)
+        service.authenticate(name, password).tap {|user| user.groups << 'user' }
+      end
+
+      def create(name, password, confirm, email)
+        validate_password(password, confirm)
+        user = new(name, email, %w(user))
+        user.validate
+        service.create(user, password)
+        user
+      end
+    end
+
+  end
+end

data/lib/olelo/util.rb

@@ -0,0 +1,233 @@
+module Olelo
+  class NotFound < NameError
+    def initialize(id)
+      super(:not_found.t(:id => id), id)
+    end
+
+    def status
+      :not_found
+    end
+  end
+
+  class MultiError < StandardError
+    attr_accessor :messages
+
+    def initialize(messages)
+      @messages = messages
+    end
+
+    def message
+      @messages.join(', ')
+    end
+  end
+
+  module Factory
+    def registry
+      @registry ||= superclass.try(:registry) || {}
+    end
+
+    def register(name, klass)
+      name = name.to_s
+      raise(ArgumentError, "Implementation '#{name}' already exists for '#{self.name}'") if registry.key?(name)
+      registry[name] = klass
+    end
+
+    def [](name)
+      registry[name.to_s] || raise(NameError, "Implementation '#{name}' for '#{self.name}' not found")
+    end
+  end
+
+  class BlockFile < ::File
+    alias to_path path
+
+    def each
+      rewind
+      while part = read(8192)
+        yield part
+      end
+    end
+  end
+
+  module Util
+    def self.included(base)
+      base.extend(Util)
+    end
+
+    extend self
+
+    def check
+      errors = []
+      yield(errors)
+      raise MultiError, errors if !errors.empty?
+    end
+
+    # Like CGI.escape but escapes space not as +
+    def escape(s)
+      s = s.to_s
+      s.gsub(/([^a-zA-Z0-9_.-]+)/) do
+        '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+      end
+    end
+
+    # Like CGI.unescape but does not unescape +
+    def unescape(s)
+      s = s.to_s
+      enc = s.encoding
+      s.gsub(/((?:%[0-9a-fA-F]{2})+)/) do
+        [$1.delete('%')].pack('H*').force_encoding(enc)
+      end
+    end
+
+    def unescape_backslash(s)
+      s = s.to_s
+      enc = s.encoding
+      s.gsub(/\\([0-7]{3})/) { $1.to_i(8).chr.force_encoding(enc) }.
+        gsub(/\\x([\da-f]{2})/i) { $1.to_i(16).chr.force_encoding(enc) }
+    end
+
+    # Escape html entities in string
+    #
+    # @param [String] s String
+    # @return [String] Escaped string
+    def escape_html(s)
+      CGI.escapeHTML(s.to_s)
+    end
+
+    # Unescape html entities in string
+    #
+    # @param [String] s String with escaped html entities
+    # @return [String] Unescaped string
+    def unescape_html(s)
+      CGI.unescapeHTML(s.to_s)
+    end
+
+    # Hash used by {#escape_javascript}
+    # @api private
+    JAVASCRIPT_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
+
+    # Escape javascript code for embedding in html
+    #
+    # @param [String] s String
+    # @return [String] Escaped string
+    def escape_javascript(s)
+      s.to_s.gsub(/[&><]/) { |x| JAVASCRIPT_ESCAPE[x] }
+    end
+
+    # Compute md5 hash of string
+    #
+    # @param [String] String
+    # @return [String] md5 hash of string
+    #
+    def md5(s)
+      s = Digest::MD5.hexdigest(s)
+      s.force_encoding(Encoding::ASCII)
+      s
+    end
+
+    # Compute sha256 hash of string
+    #
+    # @param [String] String
+    # @return [String] sha256 hash of string
+    #
+    def sha256(s)
+      s = Digest::SHA256.hexdigest(s)
+      s.force_encoding(Encoding::ASCII)
+      s
+    end
+
+    # Build query from parameter hash
+    #
+    # Similar to {Rack::Utils#build_query} but sorts parameters.
+    # This allows the query string to be used as key for caching etc.
+    #
+    # @param [Hash] params Parameter hash
+    # @return [String] query string
+    #
+    def build_query(params)
+      params.map {|k,v| [k.to_s, v ] }.sort.map do |k, v|
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          "#{escape(k)}=#{escape(v.to_s)}"
+        end
+      end.join('&')
+    end
+
+    # Creates deep copy of object by abusing `Marshal`
+    # This method is slow and not adequate for huge objects.
+    # It can only copy objects which are serializable.
+    #
+    # @param [Object] Serializable object
+    # @return [Object] Deep copy of object
+    def deep_copy(object)
+      Marshal.load(Marshal.dump(object))
+    end
+
+    # Decode base64 encoded string
+    #
+    # @param [String] Base64 encoded string
+    # @return [String] Decoded string
+    def decode64(s)
+      s.unpack('m').first
+    end
+
+    # Encode string as base64
+    #
+    # @param [String] String
+    # @return [String] Base64 encoded string
+    def encode64(s)
+      [s].pack('m').gsub(/\n/, '')
+    end
+
+    # Truncate string if it is too long and add omission
+    #
+    # @param [String]  String to truncate
+    # @param [Integer] Maximum length
+    # @param [String]  Omission string, e.g. ellipsis
+    # @return [String] Truncated string
+    def truncate(s, max, omission = '...')
+      s = s.to_s
+      if s.length > max
+        s[0...max] + omission
+      else
+        s
+      end
+    end
+
+    # Capitalizes all the words to create a nicer looking title
+    #
+    # @param [String] lowercase_string_with_underscore
+    # @return [String] Lowercase String With Underscore
+    def titlecase(s)
+      s.to_s.tr('_', ' ').split(/\s+/).map(&:capitalize).join(' ')
+    end
+
+    # Used by {#valid_xml_chars?}
+    # @api private
+    VALID_XML_CHARS = [
+      0x9, 0xA, 0xD,
+      (0x20..0xD7FF),
+      (0xE000..0xFFFD),
+      (0x10000..0x10FFFF)
+    ]
+
+    # Check if string contains only characters which are valid in XML
+    #
+    # @see http://www.w3.org/TR/REC-xml/#charsets XML charset
+    # @param [String] s
+    # @return [Boolean]
+    def valid_xml_chars?(s)
+      s = s.to_s
+      if s.encoding == Encoding::UTF_8
+        return false if !s.valid_encoding?
+      else
+        s = s.dup if s.frozen?
+        return false if s.try_encoding(Encoding::UTF_8).encoding != Encoding::UTF_8
+      end
+      s.codepoints do |n|
+        return false if !VALID_XML_CHARS.any? {|v| v === n }
+      end
+      true
+    end
+  end
+end

data/lib/olelo/version.rb

@@ -0,0 +1,3 @@
+module Olelo
+  VERSION = '0.9.0'
+end

data/lib/olelo/virtualfs.rb

@@ -0,0 +1,161 @@
+module Olelo
+  class VirtualFS
+    def read(name)
+      raise NotImplementedError
+    end
+
+    def glob(*names)
+      raise NotImplementedError
+    end
+
+    def mtime(name)
+      raise NotImplementedError
+    end
+
+    def open(name)
+      [read(name)]
+    end
+
+    def size(name)
+      read(name).bytesize
+    end
+
+    def mime(name)
+      MimeMagic.by_path(name) || MimeMagic.new('application/octet-stream')
+    end
+
+    class VirtualFile
+      attr_reader :fs, :name
+
+      def initialize(fs, name)
+        @fs, @name = fs, name
+      end
+
+      def read
+        fs.read(name)
+      end
+
+      def open
+        fs.open(name)
+      end
+
+      def mtime
+        @mtime ||= fs.mtime(name)
+      end
+
+      def size
+        @size ||= fs.size(name)
+      end
+
+      def mime
+        @fs.mime(name)
+      end
+    end
+
+    class Native < VirtualFS
+      def initialize(dir)
+        @dir = dir
+      end
+
+      # @override
+      def read(name)
+        File.read(File.join(@dir, name))
+      end
+
+      # @override
+      def glob(*names)
+        names.map do |name|
+          Dir[File.join(@dir, name)].select {|f| File.file?(f) }
+        end.flatten.each do |f|
+          yield(VirtualFile.new(self, f[@dir.length+1..-1]))
+        end
+      end
+
+      # @override
+      def open(name)
+        BlockFile.open(File.join(@dir, name), 'rb')
+      end
+
+      # @override
+      def mtime(name)
+        File.mtime(File.join(@dir, name))
+      end
+
+      # @override
+      def size(name)
+        File.stat(File.join(@dir, name)).size
+      end
+    end
+
+    class Embedded < VirtualFS
+      def initialize(file)
+        @file = file
+        @cache = {}
+      end
+
+      # @override
+      def read(name)
+        @cache[name] ||=
+          begin
+            code, data = File.read(@file).split('__END__')
+            content = nil
+            data.to_s.each_line do |line|
+            if line =~ /^@@\s*([^\s]+)\s*/
+              if name == $1
+                content = ''
+              elsif content
+                break
+              end
+            elsif content
+              content << line
+            end
+          end
+            content || raise(IOError, "#{name} not found")
+          end
+      end
+
+      # @override
+      def glob(*names)
+        code, data = File.read(@file).split('__END__')
+        data.to_s.each_line do |line|
+          if line =~ /^@@\s*([^\s]+)\s*/ && names.any? {|pattern| File.fnmatch(pattern, $1) }
+            yield(VirtualFile.new(self, $1))
+          end
+        end
+      end
+
+      # @override
+      def mtime(name)
+        File.mtime(@file)
+      end
+    end
+
+    class Union < VirtualFS
+      def initialize(*fs)
+        @fs = fs.compact
+      end
+
+      # @override
+      def glob(*names, &block)
+        @fs.each {|fs| fs.glob(*names, &block) }
+      end
+
+      %w(read mtime open size mime).each do |method|
+        class_eval %{
+          def #{method}(*args)
+            result = nil
+            @fs.any? do |fs|
+              begin
+                result = fs.#{method}(*args)
+              rescue
+              end
+            end || raise(IOError, "#{method}(\#{args.map(&:inspect).join(', ')}) failed")
+            result
+          end
+        }
+      end
+
+    end
+
+  end
+end