ptomato-ramaze 2009.02

data/lib/ramaze/snippets/string/end_with.rb

@@ -0,0 +1,20 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+      unless ''.respond_to?(:end_with?)
+        # Compatibility with 1.9
+        def end_with?(other)
+          other = other.to_s
+          self[-other.size, other.size] == other
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/esc.rb

@@ -0,0 +1,34 @@
+require 'cgi'
+require 'uri'
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      # String#escape is an extensible escaping mechanism for string.  currently
+      # it suports
+      #   '<div>foo bar</div>'.esc(:html)
+      #   'foo bar'.esc(:uri)
+      #   'foo bar'.esc(:cgi)
+
+      def escape which = :html
+        case which
+        when :html
+          Rack::Utils.escape_html(self)
+        when :cgi
+          Rack::Utils.escape(self)
+        when :uri
+          ::URI.escape(self)
+        else
+          raise ArgumentError, "do not know how to escape '#{ which }'"
+        end
+      end
+
+      alias_method 'esc', 'escape'
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/ord.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+      unless ''.respond_to?(:ord)
+
+        # compatibility with Ruby 1.9
+
+        def ord
+          self[0]
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/snake_case.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      # convert to snake_case from CamelCase
+      #
+      #   'FooBar'.snake_case # => 'foo_bar'
+
+      def snake_case
+        gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/start_with.rb

@@ -0,0 +1,19 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      unless ''.respond_to?(:start_with?)
+
+        # Compatibility with 1.9
+
+        def start_with?(other)
+          other = other.to_s
+          self[0, other.size] == other
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/snippets/string/unindent.rb

@@ -0,0 +1,28 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      # Useful for writing indented String and unindent on demand, based on the
+      # first line with indentation.
+      def unindent
+        find_indent = proc{ |l| l.find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1] }
+
+        lines = self.split("\n")
+        space = find_indent[lines]
+        space = find_indent[lines.reverse] unless space
+
+        strip.gsub(/^#{space}/, '')
+      end
+      alias ui unindent
+
+      # Destructive variant of undindent, replacing the String
+      def unindent!
+        self.replace unindent
+      end
+      alias ui! unindent!
+    end
+  end
+end

data/lib/ramaze/snippets/thread/into.rb

@@ -0,0 +1,18 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Extensions for Thread
+
+class Thread
+  # Copy all thread variables into the new thread
+
+  def self.into *args
+    Thread.new(Thread.current, *args) do |thread, *args|
+      thread.keys.each do |k|
+        Thread.current[k] = thread[k] unless k.to_s =~ /^__/
+      end
+
+      yield(*args)
+    end
+  end
+end

data/lib/ramaze/snippets.rb

@@ -0,0 +1,22 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+dir  = File.join(File.expand_path(File.dirname(__FILE__)), 'snippets')
+glob = File.join(dir, '**', '*.rb')
+
+Dir[glob].each do |snippet|
+  require(snippet)
+end
+
+Ramaze::CoreExtensions.constants.each do |const|
+  ext = Ramaze::CoreExtensions.const_get(const)
+  into = Module.const_get(const)
+
+  collisions = ext.instance_methods & into.instance_methods
+
+  if collisions.empty?
+    into.__send__(:include, ext)
+  else
+    warn "Won't include %p with %p, %p exists" % [into, ext, collisions]
+  end
+end

data/lib/ramaze/spec/helper/bacon.rb

@@ -0,0 +1,7 @@
+libdir = File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
+$LOAD_PATH.unshift libdir
+require 'vendor/bacon'
+require 'ramaze/spec/helper/pretty_output'
+Bacon.extend Bacon::PrettyOutput
+# Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit

data/lib/ramaze/spec/helper/browser.rb

@@ -0,0 +1,88 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Browser
+  attr_reader :cookie, :http
+
+  def initialize(base = '/', &block)
+    @base     = base
+    @history  = []
+    @uri      = URI("http://localhost:#{Ramaze::Global.port}")
+    @http     = SimpleHttp.new(@uri)
+
+    story(&block) if block_given?
+  end
+
+  def story(&block)
+    instance_eval(&block) if block_given?
+  end
+
+  def get path = '/', hash = {}
+    request(:get, path, hash)
+  end
+
+  def post path = '/', hash = {}
+    request(:post, path, hash)
+  end
+
+  def erequest method, path, hash = {}
+    response = request(method, path, hash)
+    eval(response)
+  rescue Object => ex
+    p :response => response
+    ex.message
+  end
+
+  def epost path = '/', hash = {}
+    erequest(:post, path, hash)
+  end
+
+  def eget path = '/', hash = {}
+    erequest(:get, path, hash)
+  end
+
+  def hget(*args)
+    @page = Hpricot(get(*args))
+  end
+
+  def hpost(*args)
+    @page = Hpricot(post(*args))
+  end
+
+  def find_link(text)
+    link = @page.at("a[text()='#{text}']")
+    link.should.not.be.nil if link.respond_to?(:should)
+    link[:href]
+  end
+
+  def follow_link(text)
+    hget find_link(text)
+  end
+
+  def follow_links(*texts)
+    texts.each do |text|
+      follow_link text
+    end
+  end
+
+  def request method, path, hash = {}
+    @http.uri = @uri + "/#{@base}/#{path}".squeeze('/')
+    @http.request_headers['referer'] = @history.last.path rescue '/'
+
+    if method == :get and not hash.empty?
+      @http.uri.query = hash.inject([]){|s,(k,v)| s << "#{k}=#{v}"}.join('&')
+      hash.clear
+    end
+
+    response = @http.send(method, hash).strip
+    @history << @http.uri
+    get_cookie
+
+    response
+  end
+
+  def get_cookie
+    @cookie = @http.response_headers['set-cookie']
+    @http.request_headers['cookie'] = @cookie
+  end
+end

data/lib/ramaze/spec/helper/mock_http.rb

@@ -0,0 +1,64 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze'
+require 'ramaze/adapter/fake'
+require 'rack/mock'
+
+module MockHTTP
+  DEFAULTS = {
+    'REMOTE_ADDR' => '127.0.0.1'
+  }
+
+  MOCK_URI = URI::HTTP.build(
+    :host => 'localhost',
+    :port => 80
+  )
+
+  FISHING = {
+    :input => :input,
+    :referrer => 'HTTP_REFERER',
+    :referer => 'HTTP_REFERER',
+    :cookie => 'HTTP_COOKIE',
+    :if_none_match=> 'HTTP_IF_NONE_MATCH',
+    :if_modified_since=> 'HTTP_IF_MODIFIED_SINCE',
+  }
+
+  MOCK_REQUEST = ::Rack::MockRequest.new(Ramaze::Adapter::Fake)
+
+  def get(*args)    mock_request(:get,    *args) end
+  def put(*args)    mock_request(:put,    *args) end
+  def post(*args)   mock_request(:post,   *args) end
+  def delete(*args) mock_request(:delete, *args) end
+
+  def mock_request(meth, path, query = {})
+    uri, options = process_request(path, query)
+    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
+  end
+
+  def raw_mock_request(meth, uri, options = {})
+    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
+  end
+
+  def process_request(path, query)
+    options = {}
+    FISHING.each do |key, value|
+      options[value] = query.delete(key) if query.key?(key)
+    end if query.is_a?(Hash)
+    [create_url(path, query), options]
+  end
+
+  def create_url(path, query)
+    uri = MOCK_URI.dup
+    uri.path = path
+    uri.query = make_query(query)
+    uri.to_s
+  end
+
+  def make_query query
+    return query unless query and not query.is_a?(String)
+    query.map{|key, value|
+      "#{Rack::Utils.escape(key)}=#{Rack::Utils.escape(value)}"
+    }.join('&')
+  end
+end

data/lib/ramaze/spec/helper/pretty_output.rb

@@ -0,0 +1,82 @@
+module Bacon
+  module PrettyOutput
+    NAME = ''
+
+    # store name and run
+    def handle_specification(name)
+      NAME.replace name
+			puts NAME
+      yield
+			puts
+    end
+
+    # Core, yields the requirement and outputs problems
+    def handle_requirement(description)
+	    print "- #{description}\n"
+      error = yield
+
+      unless error.empty?
+        if defined?(Ramaze::Logging)
+          puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
+          colors = Ramaze::Logger::Informer::COLORS
+
+          until RamazeLogger.history.empty?
+            tag, line = RamazeLogger.history.shift
+            out = "%6s | %s" % [tag.to_s, line]
+            puts out.send(colors[tag])
+          end
+        end
+
+        general_error
+      end
+    end
+
+    # Show nicer output on error
+    def general_error
+      puts "", ErrorLog
+      ErrorLog.scan(/^\s*(.*?):(\d+): #{NAME} - (.*?)$/) do
+        puts "#{ENV['EDITOR'] || 'vim'} #$1 +#$2 # #$3"
+      end
+      ErrorLog.replace ''
+    end
+
+    # output summary
+    def handle_summary
+	    puts
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+end
+
+if defined?(Ramaze::Logging)
+  module Ramaze
+    # Special Logger, stores everything in its history
+    class SpecLogger
+      include Ramaze::Logging
+      include Enumerable
+
+      attr_accessor :history
+
+      # Create new history
+      def initialize
+        @history = []
+      end
+
+      # Yield the history
+      def each
+        @history.each{|e| yield(e) }
+      end
+
+      # general log
+      def log(tag, str)
+        @history << [tag, str]
+      end
+    end
+  end
+
+  module Bacon::PrettyOutput
+    RamazeLogger = Ramaze::SpecLogger.new
+    Ramaze::Log.loggers = [RamazeLogger]
+  end
+end

data/lib/ramaze/spec/helper/requester.rb

@@ -0,0 +1,63 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Requester
+  def get url = '/', hash = {}
+    request(:get, url, hash)
+  end
+
+  def post url = '/', hash = {}
+    request(:post, url, hash)
+  end
+
+  def request method, url, hash = {}
+    http = SimpleHttp.new(url2uri(url))
+    if method == :get and not hash.empty?
+      http.uri.query = hash.map{|k,v| "#{k}=#{v}"}.join('&')
+      hash = {}
+    end
+
+    puts "#{method.to_s.upcase} => #{http.uri}"
+    http.send(method, hash).strip
+  end
+
+  def epost url = '/', hash = {}
+    erequest(:post, url, hash)
+  end
+
+  def eget url = '/', hash = {}
+    erequest(:get, url, hash)
+  end
+
+  def erequest method, url, hash = {}
+    response = request(method, url, hash)
+    eval(response)
+  rescue Object => ex
+    p :response => response
+    ex.message
+  end
+
+  def hget(url = '/', hash = {})
+    @response = get(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
+  def hpost(url = '/', hash = {})
+    @response = post(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
+  def url2uri url
+    uri = URI.parse(url)
+    #p uri.methods.sort.grep(/=/)
+    uri.scheme = 'http'
+    uri.host = 'localhost'
+    uri.port = Ramaze::Global.port
+    uri.path = "/#{url}".squeeze('/')
+    uri
+  end
+end