vex 0.2

data/lib/vex/base/object/singleton_methods.rb

@@ -0,0 +1,23 @@
+class Object
+  module SingletonMethods
+    # returns the singleton class of an object
+    def singleton_class
+      class << self; self; end
+    end
+
+    # defines a method on an object
+    def define_object_method(name, &block)
+      singleton_class.send :define_method, name, &block
+    end
+  end
+
+  include SingletonMethods
+end
+
+module SingletonMethods::Etest
+  def test_singleton_methods
+    s = "s"
+    s.define_object_method :bla do "blabla" end
+    assert_equal("blabla", s.bla)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/object/with_benchmark.rb

@@ -0,0 +1,110 @@
+require "benchmark"
+
+module Object::WithBenchmark
+
+  class BenchmarkProxy
+    def initialize(host, *args)
+      @host = host
+
+      if args.length == 1 && args.first.is_a?(String)
+        @out, @label = nil, args.first
+      else 
+        @out, @label = *args
+      end
+    end
+
+    private
+    
+    def report(msg)
+      if !@out
+        logger = @host.respond_to?(:logger) && @host.logger || App.logger
+
+        logger.warn(msg)
+        STDERR.puts(msg) if App.env == "development"
+      elsif @out.respond_to?(:warn)
+        @out.warn(msg)
+      elsif @out.respond_to?(:<<)
+        @out << "#{msg}\n"
+      end
+    end
+    
+    def method_missing(*args, &block)
+      result = ex = nil
+
+      realtime = Benchmark.realtime do
+        begin
+          result = @host.__send__(*args, &block)
+        rescue
+          ex = $!
+        end
+      end
+
+      msg = "#{@label || "benchmarked"}: #{ex && "EXCEPTION #{ex} after "}#{"%.2f secs" % realtime}"
+
+      report(msg)
+
+      raise ex if ex
+      result
+    end
+  end
+
+  def no_benchmark(*args, &block)
+    block_given? ? yield : self
+  end
+  
+  def benchmark(*args, &block)
+    count = args.last.is_a?(Fixnum) ? args.pop : 1
+
+    proxy = BenchmarkProxy.new self, *args, &block
+    return proxy unless block_given?
+    return proxy.yield(&block) if count <= 1
+    return proxy.yield do 
+      count.times(&block)
+    end
+  end
+
+  def yield(&block); yield; end
+end
+
+Object.send :include, Object::WithBenchmark
+
+module Object::WithBenchmark::Etest
+  def test_results
+    App.logger.stubs(:warn).returns(nil)
+
+    assert_equal 6, "string".benchmark.length
+    assert_raise(NoMethodError) { 
+      "string".benchmark.you_dont_know_me 
+    }
+  end
+
+  def test_benchmark
+    s = ""
+    assert_equal 6, "string".benchmark(s, "").length
+    assert s.length > 0
+  end
+
+  def test_label
+    App.logger.stubs(:warn).returns(nil)
+
+    assert_equal 6, "string".benchmark("oh! a label!").length
+  end
+
+  class DL
+    attr :msg
+    def warn(s); 
+      @msg = s
+    end
+  end
+  
+  def test_logger
+    s = "string"
+
+    def s.logger; @logger ||= DL.new; end
+    assert s.respond_to?(:logger)
+    assert s.logger.msg.blank?
+
+    assert_equal 6, s.benchmark.length
+    assert !s.logger.msg.blank?
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/range_array.rb

@@ -0,0 +1,40 @@
+class RangeArray < Array
+  def initialize(array)
+    min = max = nil
+
+    array.each do |i|
+      if min 
+        if    i >= min && i <= max then next
+        elsif i == min-1 then min = i
+        elsif i == max+1 then max = i
+        else
+          push min, max
+          min = max = i
+        end
+      else
+        min = max = i
+      end
+    end
+    
+    push min, max if min
+  end
+
+  def push(min, max)
+    super min == max ? min : min..max
+  end
+end
+
+module RangeArray::Etest
+  def ra(*array)
+    RangeArray.new array
+  end
+
+  def test_range_array
+    assert_equal [1..3],                        ra(1, 2, 3)
+    assert_equal [1..3, 5..6],                  ra(1, 2, 3, 5, 6)
+    assert_equal [1..3, 5..6, 8],               ra(1, 2, 3, 5, 6, 8)
+    assert_equal [1..2, 7, 3, 5..6, 8],         ra(1, 2, 7, 3, 5, 6, 8)
+    assert_equal [1..2, 7, 3, 5..6, 8, 4],      ra(1, 2, 7, 3, 5, 6, 8, 4)
+    assert_equal [1..2, 7, 3, 5..6, 8, 4, -3],  ra(1, 2, 7, 3, 5, 6, 8, 4, -3)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/range_ext.rb

@@ -0,0 +1,28 @@
+class Range
+  def limit(value)
+    if value < first then first
+    elsif value > last then last
+    else value
+    end
+  end
+end
+
+class Numeric
+  def limit(range)
+    range.limit(self)
+  end
+end
+
+module Range::Etest
+  def test_range
+    assert_equal 1, (1..3).limit(-1)
+    assert_equal 1, (1..3).limit(1)
+    assert_equal 2, (1..3).limit(2)
+    assert_equal 3, (1..3).limit(3)
+    assert_equal 3, (1..3).limit(4)
+  end
+
+  def test_numeric
+    assert_equal 1, -1.limit(1..3)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/safe_token.rb

@@ -0,0 +1,156 @@
+require 'digest/sha1'
+require 'json'
+require 'base64'
+
+module SafeToken
+  CipherError = if defined?(OpenSSL::Cipher::CipherError)
+    OpenSSL::Cipher::CipherError
+  else
+    OpenSSL::CipherError
+  end
+  
+  class InvalidToken < RuntimeError; end
+  class TokenTooLong < InvalidToken; end
+  class TokenExpired < InvalidToken 
+    attr :expires
+    def initialize(expires)
+      @expires = expires
+    end
+    
+    def to_s
+      "token expired at #{expires}"
+    end
+  end
+  private
+  
+  DEFAULTS = {
+    :secret => "46a348efe02807c999d69709abdbcd1b",
+    :limit => 800,        # This should be safe for an URL
+    :crypt => false
+  }
+  
+  def self.hash!(opts, data)
+    Digest::SHA1.hexdigest data
+  end
+  
+  def self.aes(encrypt_or_decrypt, data, opts)
+    return data if opts[:crypt] == false
+    
+    # get the password and make sure it is long enough for the algorithm to work
+    secret = opts[:crypt].is_a?(String) ? opts[:crypt] : opts[:secret]
+    secret = Digest::SHA1.hexdigest(secret)
+    
+    c = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+    c.send encrypt_or_decrypt
+    c.key = secret
+    s = c.update(data)
+    s << c.final
+  end
+  
+  def self.encode64(s)
+    Base64.encode64(s).gsub("\n", '').gsub("=", '-')
+  end
+  
+  def self.decode64(s)
+    Base64.decode64(s.gsub("-", '='))
+  end
+
+  def self.limit!(s, opts)
+    if opts[:limit] && s.length > opts[:limit]
+      raise TokenTooLong, "Token too long: (#{s.length} bytes, allowed are #{opts[:limit]})" 
+    end
+    s
+  end
+  
+  public
+  
+  def self.generate(data, opts = {})
+    opts = DEFAULTS.dup.update(opts)
+    expires = opts[:expires].to_i if opts[:expires]
+    
+    data = data.to_json
+    
+    hash = hash!(opts, "#{opts[:secret]}-#{expires}:#{data}")
+    s = "sha1:#{hash}:#{expires}:#{data}"
+
+    s = aes(:encrypt, s, opts)
+    s = encode64(s)
+    limit!(s, opts)
+  end
+  
+  def self.validate(s, opts = {})
+    opts = DEFAULTS.dup.update(opts)
+
+    begin
+      s = decode64(s)
+      s = aes(:decrypt, s, opts)
+    rescue SafeToken::CipherError
+      raise InvalidToken, "Invalid token encryption: #{$!}"
+    end
+
+    raise InvalidToken, "Invalid token syntax" unless s =~ /^([^:]*):([^:]*):([^:]*):(.*)/
+
+    method, hash, expires, data = $1, $2, $3, $4
+
+    unless hash!(opts, "#{opts[:secret]}-#{expires}:#{data}") == hash
+      raise InvalidToken, "Invalid token #{s}"
+    end
+    
+    if !expires.empty?
+      expires = Time.at(expires.to_i)
+      raise TokenExpired, expires if expires < Time.now      
+    end
+    
+    JSON.parse(data)
+  end
+end
+
+module SafeToken::Etest
+  def data
+    {"a" => "123232", "b" => { "c" => [ 1, 2, "d" ]}}
+  end
+  
+  def test_expiration
+    token = SafeToken.generate(data, :crypt => false, :expires => Time.now-10)
+    assert_raise(SafeToken::TokenExpired) {  
+      begin
+        SafeToken.validate(token)
+      rescue
+        assert $!.to_s =~ /expired/
+        raise
+      end
+    }
+
+    token = SafeToken.generate(data, :crypt => false, :expires => Time.now+10)
+    assert_equal data, SafeToken.validate(token)
+  end
+  
+  def test_token
+    token = SafeToken.generate(data, :crypt => false)
+    assert_equal data, SafeToken.validate(token)
+  end
+  
+  def test_token_w_crypt
+    token = SafeToken.generate(data, :crypt => true)
+    assert_equal data, SafeToken.validate(token, :crypt => true)
+  end
+  
+  def test_token_w_crypt2
+    token1 = SafeToken.generate(data, :crypt => "secret")
+    token2 = SafeToken.generate(data, :crypt => true)
+    token3 = SafeToken.generate(data, :crypt => false)
+    assert_not_equal(token1, token2)
+    assert_not_equal(token1, token3)
+    assert_not_equal(token2, token3)
+  end
+
+  def test_invalid_enc_parameters
+    token = SafeToken.generate(data, :crypt => true)
+
+    OpenSSL::Cipher::Cipher.any_instance.stubs(:update).raises(SafeToken::CipherError)
+    assert_raise(SafeToken::InvalidToken) {  
+       assert_equal data, SafeToken.validate(token, :crypt => true)
+    }
+  end
+end if VEX_TEST == "base"
+

data/lib/vex/base/string/string_ext.rb

@@ -0,0 +1,136 @@
+module StringExt
+  def constantize?
+    constantize
+  rescue LoadError, NameError
+    STDERR.puts $!.to_s
+  end
+  
+  def uri?
+    !!(self =~ /^[a-z][a-z]+:/)
+  end
+  
+  def unhtml
+    return self if blank?
+    s = Sanitize.clean(self)
+    HTMLEntities.new.decode(s)
+  end
+
+  # truncate :length => 30, :omission => "…"
+  def truncate(*args)
+    opts = if args.length == 1 && args.first.is_a?(Hash)
+      args.first
+    else
+      args.inject({}) do |hash, arg|
+        key = case arg
+        when Fixnum then :length
+        when String then :omission
+        end
+      
+        invalid_argument!(arg) if key.nil? || hash[key]
+      
+        hash.update key => arg
+      end
+    end
+    
+    _truncate(opts)
+  end
+  
+  def _truncate(opts)
+    opts = { :length => opts, :omission => "…" } unless opts.is_a?(Hash)
+    max_length = opts[:length] || 30
+    omission = opts[:omission] || "…"
+
+    #
+    # Treat multibytes differently
+    if respond_to?(:mb_chars)
+      l = max_length - omission.mb_chars.length
+      if mb_chars.length > max_length
+        return (mb_chars[0...l] + omission).to_s
+      end
+    else
+      l = max_length - omission.length
+      if length > max_length
+        return self[0...l] + omission
+      end
+    end
+
+    self
+  end
+
+  def truncate!(opts = {})
+    replace truncate(opts)
+  end
+  
+  def word_wrap(line_len=100)
+    lines = split("\n")
+    lines.map { |line| StringExt.word_wrap(line, line_len) }.join("\n")
+  end
+
+  def self.word_wrap(line, line_len)
+    r = []
+    while line.length > line_len
+      # find last space in the first line_len characters. Failing that we
+      # take the *first* (sic!) space in the entire line.
+      firstline = line[0..line_len]
+      space_idx = firstline.rindex(/\s/) || line.index(/\s/, line_len)
+
+      if !space_idx
+        r << line
+        line = ""
+      else
+        r << line[0...space_idx]
+        line = line[space_idx+1..-1]
+      end
+    end
+
+    r << line unless line.blank?
+    r.join("\n")
+  end
+end
+
+String.send :include, StringExt
+
+module StringExt::Etest
+  def test_unhtml
+    assert_equal("", "".unhtml)
+    assert_equal("hjghjg", "<p>hjghjg</p>".unhtml)
+    assert_equal("&auml", "&auml".unhtml)
+    assert_equal("ä", "&auml;".unhtml)
+  end
+
+  # truncate :length => 30, :omission => "..."
+  def test_truncate
+    assert_equal("", "".truncate)
+    assert_equal("123456", "123456".truncate)
+    assert_equal("123…", "1234567".truncate(:length => 6))
+    assert_equal("123…", "1234567".truncate(6))
+    assert_equal("12345~", "1234567".truncate(6, "~"))
+  end
+
+  def test_truncate!
+    s = "1234567"
+
+    assert_equal "123…", s.truncate(6)
+    assert_equal "1234567", s
+
+    assert_equal "123…", s.truncate!(6)
+    assert_equal "123…", s
+  end
+
+  def test_word_wrap
+    assert_equal "abcdef\nghijkl",  "abcdef ghijkl".word_wrap(8)
+    assert_equal "abc def\nghijkl", "abc def ghijkl".word_wrap(8)
+    assert_equal "abcdefghijkl",    "abcdefghijkl".word_wrap(8)
+  end
+  
+  def test_uri
+    assert_equal true, "http://".uri?
+    assert_equal false, "//".uri?
+    assert_equal false, "c:\\x\\y".uri?
+  end
+
+  def test_constantize
+    assert_equal String, "String".constantize?
+    assert_equal nil, "I::Dont::Know::This".constantize?
+  end
+end if VEX_TEST == "base"