wycats-merb-core 0.9.8

data/lib/merb-core/test/run_specs.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'open3'
+require 'benchmark'
+
+# Runs specs in all files matching the file pattern.
+#
+# ==== Parameters
+# globs<String, Array[String]>:: File patterns to look for.
+# spec_cmd<~to_s>:: The spec command. Defaults to "spec".
+# run_opts<String>:: Options to pass to spec commands, for instance,
+#                    if you want to use profiling formatter.
+# except<Array[String]>:: File paths to skip.
+def run_specs(globs, spec_cmd='spec', run_opts = "-c", except = [])
+  require "optparse"
+  require "spec"
+  globs = globs.is_a?(Array) ? globs : [globs]
+  examples, failures, errors, pending = 0, 0, 0, 0
+
+  time = Benchmark.measure do
+    globs.each do |glob|
+      (Dir[glob] - except).each do |spec|
+        STDOUT.puts "\n\nRunning #{spec}...\n"
+        response = Open3.popen3("#{spec_cmd} #{File.expand_path(spec)} #{run_opts}") do |i,o,e|
+          while out = o.gets
+            STDOUT.puts out
+            #STDOUT.flush
+            if out =~ /\d+ example/
+              e, f, p = out.match(/(\d+) examples?, (\d+) failures?(?:, (\d+) pending?)?/)[1..-1]
+              examples += e.to_i; failures += f.to_i; pending += p.to_i
+            end
+          end
+          errors += 1 if e.is_a?(IO)
+          STDOUT.puts e.read if e.is_a?(IO)
+        end
+      end
+    end
+  end
+
+  puts
+  puts "*** TOTALS ***"
+  if failures == 0
+    print "\e[32m"
+  else
+    print "\e[31m"
+  end
+  puts "#{examples} examples, #{failures} failures, #{errors} errors, #{pending} pending, #{sprintf("suite run in %3.3f seconds", time.real)}"
+  # TODO: we need to report pending examples all together
+  print "\e[0m"
+end

data/lib/merb-core/test/tasks/spectasks.rb

@@ -0,0 +1,68 @@
+desc "Run specs, run a specific spec with TASK=spec/path_to_spec.rb"
+task :spec => [ "spec:default" ]
+
+namespace :spec do
+  OPTS_FILENAME = "./spec/spec.opts"
+  if File.exist?(OPTS_FILENAME)
+    SPEC_OPTS = ["--options", OPTS_FILENAME]
+  else
+    SPEC_OPTS = ["--color", "--format", "specdoc"]
+  end
+  
+  Spec::Rake::SpecTask.new('default') do |t|
+      t.spec_opts = SPEC_OPTS
+    if(ENV['TASK'])
+      t.spec_files = [ENV['TASK']]
+    else
+      t.spec_files = Dir['spec/**/*_spec.rb'].sort
+    end
+  end
+
+  desc "Run all model specs, run a spec for a specific Model with MODEL=MyModel"
+  Spec::Rake::SpecTask.new('model') do |t|
+    t.spec_opts = SPEC_OPTS
+    if(ENV['MODEL'])
+      t.spec_files = Dir["spec/models/**/#{ENV['MODEL']}_spec.rb"].sort
+    else
+      t.spec_files = Dir['spec/models/**/*_spec.rb'].sort
+    end
+  end
+
+  desc "Run all controller specs, run a spec for a specific Controller with CONTROLLER=MyController"
+  Spec::Rake::SpecTask.new('controller') do |t|
+    t.spec_opts = SPEC_OPTS
+    if(ENV['CONTROLLER'])
+      t.spec_files = Dir["spec/controllers/**/#{ENV['CONTROLLER']}_spec.rb"].sort
+    else    
+      t.spec_files = Dir['spec/controllers/**/*_spec.rb'].sort
+    end
+  end
+  
+  desc "Run all view specs, run specs for a specific controller (and view) with CONTROLLER=MyController (VIEW=MyView)"
+  Spec::Rake::SpecTask.new('view') do |t|
+    t.spec_opts = SPEC_OPTS
+    if(ENV['CONTROLLER'] and ENV['VIEW'])
+      t.spec_files = Dir["spec/views/**/#{ENV['CONTROLLER']}/#{ENV['VIEW']}*_spec.rb"].sort
+    elsif(ENV['CONTROLLER'])
+      t.spec_files = Dir["spec/views/**/#{ENV['CONTROLLER']}/*_spec.rb"].sort
+    else
+      t.spec_files = Dir['spec/views/**/*_spec.rb'].sort
+    end
+  end
+
+  desc "Run all specs and output the result in html"
+  Spec::Rake::SpecTask.new('html') do |t|
+    t.spec_opts = ["--format", "html"]
+    t.libs = ['lib', 'server/lib' ]
+    t.spec_files = Dir['spec/**/*_spec.rb'].sort
+  end
+
+  desc "Run specs and check coverage with rcov"
+  Spec::Rake::SpecTask.new('coverage') do |t|
+    t.spec_opts = SPEC_OPTS
+    t.spec_files = Dir['spec/**/*_spec.rb'].sort
+    t.libs = ['lib', 'server/lib' ]
+    t.rcov = true
+    t.rcov_opts = ["--exclude 'config,spec,#{Gem::path.join(',')}'"]    
+  end
+end

data/lib/merb-core/test/test_ext/hpricot.rb

@@ -0,0 +1,32 @@
+# http://yehudakatz.com/2007/01/27/a-better-assert_select-assert_elements/
+# based on assert_elements
+# Author: Yehuda Katz
+# Email:  wycats @nospam@ gmail.com
+# Web:    http://www.yehudakatz.com
+#
+# which was based on HpricotTestHelper
+# Author: Luke Redpath
+# Email: contact @nospam@ lukeredpath.co.uk
+# Web: www.lukeredpath.co.uk / opensource.agileevolved.com
+
+class Hpricot::Elem
+  def contain?(value)
+    self.inner_text.include?(value)
+  end
+  
+  alias_method :contains?, :contain?
+
+  def match?(regex)
+    self.inner_text.match(regex)
+  end
+  
+  alias_method :matches?, :match?
+  
+  # courtesy of 'thomas' from the comments
+  # of _whys blog - get in touch if you want a better credit!
+  def inner_text
+    self.children.collect do |child|
+      child.is_a?(Hpricot::Text) ? child.content : ((child.respond_to?("inner_text") && child.inner_text) || "")
+    end.join.strip
+  end
+end

data/lib/merb-core/test/test_ext/object.rb

@@ -0,0 +1,14 @@
+class Object
+  # ==== Parameters
+  # attr<~to_s>:: The name of the instance variable to get.
+  #
+  # ==== Returns
+  # Object:: The instance variable @attr for this object.
+  # 
+  # ==== Examples
+  #   # In a spec
+  #   @my_obj.assigns(:my_value).should == @my_value
+  def assigns(attr)
+    self.instance_variable_get("@#{attr}")
+  end
+end

data/lib/merb-core/test/test_ext/string.rb

@@ -0,0 +1,14 @@
+class String
+  def contain?(value)
+    self.include?(value)
+  end
+  
+  alias_method :contains?, :contain?
+
+  def match?(regex)
+    self.match(regex)
+  end
+  
+  alias_method :matches?, :match?
+  
+end

data/lib/merb-core/vendor/facets.rb

@@ -0,0 +1,2 @@
+require "merb-core/vendor/facets/inflect"
+require "merb-core/vendor/facets/dictionary"

data/lib/merb-core/vendor/facets/dictionary.rb

@@ -0,0 +1,433 @@
+# TITLE:
+#
+#   Dictionary
+#
+# AUTHORS:
+#
+#   - Jan Molic
+#   - Thomas Sawyer
+#
+# CREDIT:
+#
+#   - Andrew Johnson (merge, to_a, inspect, shift and Hash[])
+#   - Jeff Sharpe    (reverse and reverse!)
+#   - Thomas Leitner (has_key? and key?)
+#
+# LICENSE:
+#
+#   Copyright (c) 2005 Jan Molic, Thomas Sawyer
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+#   Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
+#
+# LOG:
+#
+#   - 2007.10.31 trans
+#     Fixed initialize so the constructor blocks correctly effected dictionary
+#     rather then just the internal hash.
+
+# = Dictionary
+#
+# The Dictionary class is a Hash that preserves order.
+# So it has some array-like extensions also. By defualt
+# a Dictionary object preserves insertion order, but any
+# order can be specified including alphabetical key order.
+#
+# == Usage
+#
+# Just require this file and use Dictionary instead of Hash.
+#
+#   # You can do simply
+#   hsh = Dictionary.new
+#   hsh['z'] = 1
+#   hsh['a'] = 2
+#   hsh['c'] = 3
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # or using Dictionary[] method
+#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # but this doesn't preserve order
+#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
+#   p hsh.keys     #=> ['a','c','z']
+#
+#   # Dictionary has useful extensions: push, pop and unshift
+#   p hsh.push('to_end', 15)       #=> true, key added
+#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
+#   p hsh.unshift('to_begin', 50)  #=> true, key added
+#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
+#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
+#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+#
+# == Usage Notes
+#
+# * You can use #order_by to set internal sort order.
+# * #<< takes a two element [k,v] array and inserts.
+# * Use ::auto which creates Dictionay sub-entries as needed.
+# * And ::alpha which creates a new Dictionary sorted by key.
+
+class Dictionary
+
+  include Enumerable
+
+  class << self
+    #--
+    # TODO is this needed? Doesn't the super class do this?
+    #++
+    def [](*args)
+      hsh = new
+      if Hash === args[0]
+        hsh.replace(args[0])
+      elsif (args.size % 2) != 0
+        raise ArgumentError, "odd number of elements for Hash"
+      else
+        while !args.empty?
+          hsh[args.shift] = args.shift
+        end
+      end
+      hsh
+    end
+
+    # Like #new but the block sets the order.
+    #
+    def new_by(*args, &blk)
+      new(*args).order_by(&blk)
+    end
+
+    # Alternate to #new which creates a dictionary sorted by key.
+    #
+    #   d = Dictionary.alpha
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| key }
+    def alpha(*args, &block)
+      new(*args, &block).order_by_key
+    end
+
+    # Alternate to #new which auto-creates sub-dictionaries as needed.
+    #
+    #   d = Dictionary.auto
+    #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+    #
+    def auto(*args)
+      #AutoDictionary.new(*args)
+      leet = lambda { |hsh, key| hsh[key] = new(&leet) }
+      new(*args, &leet)
+    end
+  end
+
+   # New Dictiionary.
+  def initialize(*args, &blk)
+    @order = []
+    @order_by = nil
+    if blk
+      dict = self                                  # This ensure autmatic key entry effect the
+      oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
+      @hash = Hash.new(*args, &oblk)
+    else
+      @hash = Hash.new(*args)
+    end
+  end
+
+  def order
+    reorder if @order_by
+    @order
+  end
+
+  # Keep dictionary sorted by a specific sort order.
+  def order_by( &block )
+    @order_by = block
+    order
+    self
+  end
+
+  # Keep dictionary sorted by key.
+  #
+  #   d = Dictionary.new.order_by_key
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   Dictionary.new.order_by { |key,value| key }
+  #
+  # The initializer Dictionary#alpha also provides this.
+  def order_by_key
+    @order_by = lambda { |k,v| k }
+    order
+    self
+  end
+
+  # Keep dictionary sorted by value.
+  #
+  #   d = Dictionary.new.order_by_value
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   Dictionary.new.order_by { |key,value| value }
+  def order_by_value
+    @order_by = lambda { |k,v| v }
+    order
+    self
+  end
+
+  #
+  def reorder
+    if @order_by
+      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
+      @order = assoc.collect{ |k,v| k }
+    end
+    @order
+  end
+
+  def ==(hsh2)
+    if hsh2.is_a?( Dictionary )
+      @order == hsh2.order &&
+      @hash  == hsh2.instance_variable_get("@hash")
+    else
+      false
+    end
+  end
+
+  def [] k
+    @hash[ k ]
+  end
+
+  def fetch(k, *a, &b)
+    @hash.fetch(k, *a, &b)
+  end
+
+  # Store operator.
+  #
+  #   h[key] = value
+  #
+  # Or with additional index.
+  #
+  #  h[key,index] = value
+  def []=(k, i=nil, v=nil)
+    if v
+      insert(i,k,v)
+    else
+      store(k,i)
+    end
+  end
+
+  def insert( i,k,v )
+    @order.insert( i,k )
+    @hash.store( k,v )
+  end
+
+  def store( a,b )
+    @order.push( a ) unless @hash.has_key?( a )
+    @hash.store( a,b )
+  end
+
+  def clear
+    @order = []
+    @hash.clear
+  end
+
+  def delete( key )
+    @order.delete( key )
+    @hash.delete( key )
+  end
+
+  def each_key
+    order.each { |k| yield( k ) }
+    self
+  end
+
+  def each_value
+    order.each { |k| yield( @hash[k] ) }
+    self
+  end
+
+  def each
+    order.each { |k| yield( k,@hash[k] ) }
+    self
+  end
+  alias each_pair each
+
+  def delete_if
+    order.clone.each { |k| delete k if yield(k,@hash[k]) }
+    self
+  end
+
+  def values
+    ary = []
+    order.each { |k| ary.push @hash[k] }
+    ary
+  end
+
+  def keys
+    order
+  end
+
+  def invert
+    hsh2 = self.class.new
+    order.each { |k| hsh2[@hash[k]] = k }
+    hsh2
+  end
+
+  def reject( &block )
+    self.dup.delete_if(&block)
+  end
+
+  def reject!( &block )
+    hsh2 = reject(&block)
+    self == hsh2 ? nil : hsh2
+  end
+
+  def replace( hsh2 )
+    @order = hsh2.order
+    @hash = hsh2.hash
+  end
+
+  def shift
+    key = order.first
+    key ? [key,delete(key)] : super
+  end
+
+  def unshift( k,v )
+    unless @hash.include?( k )
+      @order.unshift( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def <<(kv)
+    push( *kv )
+  end
+
+  def push( k,v )
+    unless @hash.include?( k )
+      @order.push( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def pop
+    key = order.last
+    key ? [key,delete(key)] : nil
+  end
+
+  def inspect
+    ary = []
+    each {|k,v| ary << k.inspect + "=>" + v.inspect}
+    '{' + ary.join(", ") + '}'
+  end
+
+  def dup
+    a = []
+    each{ |k,v| a << k; a << v }
+    self.class[*a]
+  end
+
+  def update( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    reorder
+    self
+  end
+  alias :merge! update
+
+  def merge( hsh2 )
+    self.dup.update(hsh2)
+  end
+
+  def select
+    ary = []
+    each { |k,v| ary << [k,v] if yield k,v }
+    ary
+  end
+
+  def reverse!
+    @order.reverse!
+    self
+  end
+
+  def reverse
+    dup.reverse!
+  end
+
+  def first
+    @hash[order.first]
+  end
+
+  def last
+    @hash[order.last]
+  end
+
+  def length
+    @order.length
+  end
+  alias :size :length
+
+  def empty?
+    @hash.empty?
+  end
+
+  def has_key?(key)
+    @hash.has_key?(key)
+  end
+
+  def key?(key)
+    @hash.key?(key)
+  end
+
+  def to_a
+    ary = []
+    each { |k,v| ary << [k,v] }
+    ary
+  end
+  
+  def to_json
+    buf = "["
+    map do |k,v|
+      buf << k.to_json
+      buf << ", "
+      buf << v.to_json
+    end.join(", ")
+    buf << "]"
+    buf
+  end
+
+  def to_s
+    self.to_a.to_s
+  end
+
+  def to_hash
+    @hash.dup
+  end
+
+  def to_h
+    @hash.dup
+  end
+end