vex 0.2

data/lib/vex/base/local_conf.rb

@@ -0,0 +1,35 @@
+class LocalConf < Hash
+  include Hash::EasyAccess
+  
+  def initialize(file)
+    r1 = load file.sub(/\.yml$/, ".defaults.yml")
+    r2 = load file, App.env
+
+    return if r1 || r2
+    
+    raise Errno::ENOENT, 
+      "Missing configuration file #{App.root}/config/#{file.sub(/\.yml$/, "")}{.defaults}.yml}"
+  end
+
+  private
+  
+  def load(file, key = nil)
+    data = YAML::load_file("#{App.root}/config/#{file}")
+    data = data[key] if data && key
+    data.each { |k,v| update k.to_sym => v } if data
+    true
+  rescue Errno::ENOENT
+    false
+  end
+  
+  def method_missing(sym, *args, &block)
+    return super unless args.empty? && !block_given? && sym.to_s =~ /(.*)\?/
+    !fetch($1.to_sym).blank?
+  rescue IndexError
+    false
+  end
+
+  def self.method_missing(sym, *args, &block)
+    App.local_conf.send sym, *args, &block
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/net/http_ext.rb

@@ -0,0 +1,227 @@
+require "net/http"
+require "net/https"
+
+module Net::HTTPExt; end
+
+Net.extend Net::HTTPExt
+
+#
+# This adds Net.get, Net.head, Net.post
+module Net::HTTPExt
+  REDIRECTION_LIMIT = 10
+
+  DEFAULT_OPTIONS = {
+    :redirect => 10     # MAX # of redirection
+  }
+  
+  # This is a combination of a string (for the response body) and
+  # of a "hash" for the response header
+  class Response < String
+    class Headers
+      attr :code, true
+        
+      def initialize(response)
+        @headers = response.instance_variable_get "@header"
+      end
+
+      def method_missing(sym, *args, &block)
+        return super unless args.empty? && !block_given?
+        self[sym]
+      end
+
+      def [](key)
+        r = @headers[key.to_s.downcase.gsub("_", "-")]
+        raise "huh?" unless r.is_a?(Array) 
+        r.length <= 1 ? r.first : r
+      end
+    end
+
+    attr :response
+    attr :headers
+
+    def code;     Integer(response.code); end
+    def good?;    code >= 200 && code < 300; end
+    def message;  response.message;       end
+    
+    def initialize(response)
+      super(response.body) if response.body
+      @response, @headers = response, Headers.new(response)
+    end
+  end
+
+  # POST request
+  def post(url, body, opts = {})
+    http :post, url, body, opts
+  end
+
+  # HEAD request
+  def head(url, opts = {})
+    http :head, url, nil, opts
+  end
+
+  # GET request
+  def get(url, opts = {})
+    http :get, url, nil, opts
+  end
+
+  def exists?(url, opts = {})
+    r = Net.head(url, opts)
+    r.code >= 200 && r.code < 300
+  end
+
+  alias :exist? :exists?
+
+  HEADERS_KEY = :"net:http_ext:preprocessors:headers"
+
+  def headers
+    Thread.current[HEADERS_KEY] ||= {}
+  end
+
+  def headers=(h)
+    Thread.current[HEADERS_KEY] = h
+  end
+  
+  def with_headers(scope, &block)
+    old = headers
+    self.headers = headers.dup.update scope
+    yield
+  ensure
+    self.headers = old
+  end
+  
+  private
+  
+  def adjust_request!(verb, path, h, body)
+    headers.each do |k,v|
+      k = k.to_s
+      
+      if v.respond_to?(:call)
+        v.call(verb, path, h, body) 
+      elsif v.nil?
+        h.delete k
+        h.delete k.to_sym
+      else
+        h[k] ||= v
+      end
+    end
+  end
+  
+  def http(verb, url, body, opts, &block)
+    # -- timeout handling
+    if timeout = opts.delete(:timeout)
+      begin
+        return Timeout.timeout(timeout) { http(verb, url, body, opts, &block) }
+      rescue Timeout::Error
+        return nil
+      end
+    end
+
+    headers = DEFAULT_OPTIONS.dup.update(opts)
+    redirect = headers.delete :redirect
+    
+    r = do_http verb, url, body, headers, redirect, &block
+    r.headers.code = r.code
+    
+    verb != :head ? r : r.headers
+  end
+  
+  # connects to a HTTP server, yields the URI and the HTTP connection
+  def do_http(verb, url, body, headers={}, redirect = nil, &block)
+    # -- connect to the server
+    uri = url.is_a?(URI) ? url : URI.parse(url)
+
+    connection = Net::HTTP.new(uri.host, uri.port)
+    connection.use_ssl = uri.scheme == "https"
+    connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    invalid_argument!("Invalid URL", url) unless %w(https http).include?(uri.scheme)
+
+    # -- do whatever
+    connection.start do |c|
+      adjust_request! verb, uri.request_uri, headers, body
+      
+      args = [ ]
+      args << "request_#{verb}"
+      args << uri.request_uri
+      args << body if verb == :post || verb == :put
+      args << headers
+
+      response = connection.send *args
+
+      if !response.is_a?(Net::HTTPRedirection) || !redirect
+        next Response.new(response)
+      end
+
+      raise "Reached maximum number of redirections" if redirect <= 0
+
+      do_http verb == :head ? :head : :get,
+        redirection_url(url, response['location']),
+        nil,
+        headers,
+        redirect - 1
+    end
+  ensure
+    connection.finish if connection && connection.started?
+  end
+
+  #
+  # fix non default responses. Magento does this, sometimes...
+  def redirection_url(uri, location)
+    return location if URI.parse(location).scheme rescue nil
+    raise "Cannot redirect to URI #{location}" unless uri.to_s =~ /^((.*?)\/\/(.*?)\/)/
+    $1 + location.gsub(/^\/+/, "")
+  end
+end
+
+module Net::HTTPExt::Etest
+  def test_w_google_w_redirection
+    return unless Socket.online?
+
+    google = Net.get("http://www.google.com")
+    assert google =~ /<title>Google/
+    assert google.headers["Content-Type"] =~ /text\/html/
+    assert google.headers.content_type =~ /text\/html/
+  end
+   
+  def test_w_google_wo_redirection
+    return unless Socket.online?
+
+    google = Net.get("http://www.google.com", :redirect => false)
+    assert_equal(302 , google.code)
+    assert google.headers["Content-Type"] =~ /text\/html/
+    assert google.headers.content_type =~ /text\/html/
+  end
+
+  def test_w_google
+    return unless Socket.online?
+
+    assert Net.exists?("http://www.google.de")
+    assert Net.exist?("http://www.google.de")
+    
+    google = Net.get("http://www.google.de")
+    assert google =~ /<title>Google/
+    assert google.headers["Content-Type"] =~ /text\/html/
+    assert google.headers.content_type =~ /text\/html/
+  end
+
+  def test_w_google_timeout
+    return unless Socket.online?
+
+    google = Net.get("http://www.google.de", :timeout => 0.01)
+    assert_equal(nil, google)
+  end
+
+  def test_w_google_adjusted_headers
+    return unless Socket.online?
+
+    Net.with_headers :x_abc => "Test ABC" do
+      assert_equal("Test ABC", Net.headers[:x_abc])
+      assert Net.exists?("http://www.google.de")
+      Net.with_headers :x_abc => nil do
+        assert_equal(nil, Net.headers[:x_abc])
+      end
+      assert_equal("Test ABC", Net.headers[:x_abc])
+    end
+  end
+end if VEX_TEST == "base"
+

data/lib/vex/base/net/socket_ext.rb

@@ -0,0 +1,43 @@
+require 'socket'  
+
+#
+# see http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+#
+class Socket
+  #
+  # Parameters:
+  #
+  # * when_talking_to: returns my IP when talking to that host.
+  # * when_talking_to: returns my IP when talking to that host.
+  
+  # do_raise is mainly for test purposes
+  def self.local_ip(when_talking_to = nil)
+    when_talking_to ||= '64.233.187.99'
+    begin
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily  
+  
+      UDPSocket.open do |s|  
+        s.connect when_talking_to, 1  
+        s.addr.last  
+      end  
+    rescue
+      "127.0.0.1" # not connected to the funny wide web?
+    ensure  
+      Socket.do_not_reverse_lookup = orig  
+    end
+  end
+
+  def self.online?
+    local_ip != "127.0.0.1"
+  end
+end
+
+module Socket::Etest
+  def test_returns_127_locally
+    require 'ipaddr'
+    local_net = IPAddr.new("127.0.0.0/24")
+    %w(127.0.0.1 127.0.0.2 localhost).each do |ip|
+      assert(local_net.include?(IPAddr.new(Socket.local_ip(ip))))
+    end
+  end
+end if VEX_TEST == "base"

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

@@ -0,0 +1,123 @@
+#
+# short inspect method on all objects.
+#
+# "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmnop".insp
+#    -> "abcdefghijklmnopabcdefghijk..."
+# Model.find(1).insp 
+#    -> "<Model#1>"
+
+class Object
+  def insp
+    body = "#{insp_body}"
+    body = ": #{body}" unless body.empty?
+    "#{insp_head}#{body}#{insp_close}"
+  end
+
+  private
+
+  def insp_head; "<#{self.class}@#{self.object_id}"; end
+  def insp_body; end
+  def insp_close; ">"; end
+end
+
+[ Numeric, TrueClass, FalseClass, NilClass, Symbol, Module ].each do |klass|
+  klass.send :alias_method, :insp, :inspect
+end
+
+class String
+  INSP_TRUNCATE_LEN = 30
+
+  def insp
+    return inspect unless length > INSP_TRUNCATE_LEN
+    
+    l = INSP_TRUNCATE_LEN - 3
+    (self[0...l].to_s + "...").inspect
+  end
+end
+
+if defined?(ActiveRecord)
+  class ActiveRecord::Base
+    private
+  
+    def insp_head; "<#{self.class}##{self.id}"; end
+  end
+end
+
+class Hash
+  def insp
+    self.class == Hash && instance_variables.empty? ? insp_body : super
+  end
+
+  private
+
+  INSP_TRUNCATE_LEN = 10
+
+  def insp_body
+    body = to_a.sort { |a,b|
+      a <=> b rescue a.to_s <=> b.to_s
+    }
+
+    if length > INSP_TRUNCATE_LEN
+      body = body[0...INSP_TRUNCATE_LEN]
+      more = ", ... (#{length - INSP_TRUNCATE_LEN} more)"
+    end
+
+    "{#{body.map { |k,v| "#{k.insp} => #{v.insp}"}.join(", ")}#{more}}"
+  end
+end
+
+class Array
+  def insp
+    self.class == Array && instance_variables.empty? ? insp_body : super
+  end
+
+  private
+
+  INSP_TRUNCATE_LEN = 20
+
+  def insp_body
+    if length > INSP_TRUNCATE_LEN
+      body = self[0...INSP_TRUNCATE_LEN]
+      more = ", ... (#{length - INSP_TRUNCATE_LEN} more)"
+    end
+
+    "[#{(body || self).map(&:insp).join(", ")}#{more}]"
+  end
+end
+
+module Insp; end
+
+module Insp::Etest
+  def test_insp_array
+    assert_equal("[1, 2]", [1,2].insp)
+    assert_equal("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ... (10 more)]", (1..30).to_a.insp)
+  end
+  
+  def test_insp_hash
+    assert_equal("{}", {}.insp)
+
+    h = (1..30).to_a.inject({}) do |hash, id| 
+      hash.update id => id*id
+    end
+    assert_equal "{1 => 1, 2 => 4, 3 => 9, 4 => 16, 5 => 25, 6 => 36, 7 => 49, 8 => 64, 9 => 81, 10 => 100, ... (20 more)}", 
+      h.insp
+  end
+
+  def test_insp_string
+    s = "123"
+    assert_equal(s.insp, s.inspect)
+    s = (s * 100).insp
+    assert s.ends_with?("...\"")
+    assert s.length < 50
+  end
+
+  class X
+    def initialize
+      @x = "x"
+    end
+  end
+  
+  def test_insp_obj
+    assert X.new.insp =~ /Insp::Etest::X/
+  end
+end if VEX_TEST == "base"

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

@@ -0,0 +1,58 @@
+class Module
+  module MultipleAttributes
+    def attributes(*args)
+      writable_flag = args.last
+      if writable_flag != true && writable_flag != false
+        writable_flag = false
+      else
+        args.pop
+      end
+
+      args.each do |arg|
+        attr arg, writable_flag
+      end
+    end
+  end
+
+  include MultipleAttributes
+end
+
+module Module::MultipleAttributes::Etest
+  class X
+    attributes :a
+    attributes :b, :c
+
+    attributes :d, :e, true
+  
+    def initialize
+      @a = "a"
+      @b = "b"
+      @c = "c"
+      @d = "d"
+      @e = "e"
+    end
+  end
+  
+  def test_ma
+    x = X.new
+    assert_equal %w(a b c d e), [ x.a, x.b, x.c, x.d, x.e ]
+
+    assert_raise(NoMethodError) {
+      x.a = 1
+    }
+
+    assert_raise(NoMethodError) {
+      x.b = 1
+    }
+
+    assert_raise(NoMethodError) {
+      x.c = 1
+    }
+
+    x.d = 1
+    x.e = 2
+    
+    assert_equal 1, x.d
+    assert_equal 2, x.e
+  end
+end if VEX_TEST == "base"