qspec 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qspec.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 tomykaira
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Qspec
+
+Qspec makes rspec test fast.  Q is for **queue** and **quick**.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'qspec'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install qspec
+
+## Additional Installation
+
+You can use `spork` to cut the overhead of Qspec startup.
+**Use 1.0**. Old `spork` does not detect Qspec.
+
+```ruby
+  gem 'spork', '~> 1.0rc'
+```
+
+If you are on rails, remember to add `spork-rails` too.
+
+By default, qspec uses file based inter-process communication.
+This is poorly implemented and becomes a burden.
+
+We recommend to use `redis`.
+
+- Setting up redis-server with default port
+- Add `redis` gem to your Gemfile
+- Specify `redis` for IPC method in `.qspec.yml`
+
+## Usage
+
+Installing this gem adds `qspec` and `qspec-helper` commands.
+
+### Setup
+
+```sh
+$ bundle exec qspec-helper init
+# edit .qspec.yml
+```
+
+### Run spec
+
+```sh
+bundle exec qspec spec/
+```
+
+### Run with spork
+
+```sh
+bundle exec qspec-helper spork
+bundle exec qspec spec/
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/qspec

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'qspec'
+status = Qspec::CommandLine.new(ARGV).run($stderr, $stdout).to_i
+exit status

data/bin/qspec-helper

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'qspec'
+Qspec::Helper.new(ARGV).serve

data/lib/qspec.rb

@@ -0,0 +1,19 @@
+require 'rspec/core'
+require 'qspec/version'
+require 'qspec/ipc'
+require 'qspec/manager'
+require 'qspec/spork_helper'
+require 'qspec/command_line'
+require 'qspec/formatters/redis_formatter'
+require 'qspec/config'
+require 'qspec/helper'
+
+module Qspec
+  DIRECTORY = File.expand_path('tmp/qspec')
+
+  FileUtils.mkdir_p(DIRECTORY) unless FileTest.exists?(DIRECTORY)
+
+  def self.path(filename)
+    File.join(DIRECTORY, filename)
+  end
+end

data/lib/qspec/command_line.rb

@@ -0,0 +1,54 @@
+require 'rspec/core/command_line'
+
+module Qspec
+  class CommandLine < ::RSpec::Core::CommandLine
+    include Manager # defines start_worker
+    include SporkHelper
+    attr_reader :output, :ipc, :config, :id
+
+    def initialize(options)
+      @config = Config.new()
+      @ipc = IPC.from_config(@config['ipc'])
+      @id = ENV['qspec_id']
+
+      super(options)
+    end
+
+    def run(err, out)
+      @configuration.error_stream = err
+      @output = @configuration.output_stream ||= out
+      @options.configure(@configuration)
+
+      if @id
+        process
+      else
+        start_worker
+      end
+    end
+
+    def process
+      success = true
+      while f = ipc.lpop("to_run_#{id}")
+        @configuration.add_formatter(Qspec::Formatters::RedisFormatterFactory.build(id, f))
+        begin
+          load File.expand_path(f)
+          @configuration.reporter.report(@world.example_count, @configuration.randomize? ? @configuration.seed : nil) do |reporter|
+            begin
+              GC.disable if @config['no_gc']
+              @configuration.run_hook(:before, :suite)
+              success &&= @world.example_groups.ordered.all? {|g| g.run(reporter)}
+            ensure
+              @configuration.run_hook(:after, :suite)
+              GC.enable if @config['no_gc']
+              GC.start  if @config['no_gc']
+            end
+          end
+        ensure
+          @world.example_groups.clear
+          @configuration.reset # formatter, reporter
+        end
+      end
+      success ? 0 : @configuration.failure_exit_code
+    end
+  end
+end

data/lib/qspec/config.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+module Qspec
+  class Config
+    DEFAULT_PATH = '.qspec.yml'
+
+    def initialize(path = DEFAULT_PATH)
+      @path = path
+      if File.exists?(path)
+        @config = YAML.load_file(path)
+      else
+        STDERR.puts "You do not have #{path}.  Initialize with `qspec-helper init`"
+        exit 1
+      end
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def self.create_template(path = DEFAULT_PATH)
+      if File.exists?(path)
+        STDERR.puts "You already have a template file #{path}.  Remove it if you want to reset."
+        exit 1
+      end
+      File.open(path, 'w') do |f|
+        f.write <<TMPL
+# DO NOT check this file into VCS (e.g. git).
+# Parallelization setting differs between machines.
+no_gc: false
+ipc: file         # 'file' or 'redis', if 'redis', gem and server are required
+sort_by: time     # 'time' or 'size',  if 'time', store execution time and use it next time
+workers: 4        # half of cpu - number of cpu
+spork_port: 9240  # specified port..port+N-1 are used
+TMPL
+      end
+      puts "Config file created in #{path}. Check it before run `qspec spec`."
+    end
+  end
+end

data/lib/qspec/formatters/redis_formatter.rb

@@ -0,0 +1,47 @@
+require 'rspec/core/formatters/base_formatter'
+
+module Qspec
+  module Formatters
+    module RedisFormatterFactory
+      def self.build(id, file)
+        Class.new(RSpec::Core::Formatters::BaseFormatter) do
+          @@id = id
+          @@file = file
+          include RedisFormatterFactory
+        end
+      end
+
+      def initialize(output)
+        @ipc = IPC.default
+        super
+      end
+
+      def dump_failures
+        failed_examples.each do |example|
+          ex = example.execution_result[:exception]
+          data = {
+            description: example.full_description,
+            exception: format_exception(example, ex),
+            backtrace: format_backtrace(ex.backtrace, example)
+          }
+          @ipc.rpush("failure_#{@@id}", Marshal.dump(data))
+        end
+      end
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        data = [@@file, duration, example_count, failure_count, pending_count]
+        @ipc.rpush("stat_#{@@id}", Marshal.dump(data))
+      end
+
+      def format_exception(example, ex)
+        exception_class_name = ex.class.to_s
+        output = StringIO.new
+        output.puts "* #{example.full_description}"
+        output.puts "\tFailure/Error: #{read_failed_line(ex, example)}"
+        output.puts "\t#{exception_class_name}:" unless exception_class_name =~ /RSpec/
+        ex.message.to_s.split("\n").each { |line| output.puts "\t  #{line}" } if ex.message
+        output.string
+      end
+    end
+  end
+end

data/lib/qspec/helper.rb

@@ -0,0 +1,21 @@
+module Qspec
+  class Helper
+    include SporkHelper
+
+    def initialize(argv)
+      @argv   = argv
+    end
+
+    def serve
+      case @argv.last
+      when 'init'
+        puts "Creating template"
+        Config.create_template
+      when 'spork'
+        @config = Config.new
+        puts "Start #{@config['workers']} sporks"
+        start_spork_workers(@config['workers'])
+      end
+    end
+  end
+end

data/lib/qspec/ipc.rb

@@ -0,0 +1,34 @@
+module Qspec
+  # abstract
+  class IPC
+    def self.from_config(name)
+      @@default =
+        case name
+        when 'redis'
+          require 'qspec/ipc/redis'
+          IPC::Redis.new
+        when 'file', nil
+          require 'qspec/ipc/file'
+          IPC::File.new
+        else
+          raise "Unknown IPC method #{name}"
+        end
+    end
+
+    def self.default
+      @@default || (raise 'Default IPC module not set')
+    end
+
+    def del(key)
+    end
+
+    def lpop(key)
+    end
+
+    def rpush(key, value)
+    end
+
+    def llen(key)
+    end
+  end
+end

data/lib/qspec/ipc/file.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+
+module Qspec
+  class IPC
+    class File < IPC
+      DIRECTORY = 'tmp/qspec'
+
+      def initialize
+        FileUtils.mkdir_p(DIRECTORY) unless FileTest.exists?(DIRECTORY)
+      end
+
+      def del(key)
+        ::File.unlink(Qspec.path(key)) rescue nil
+      end
+
+      def lpop(key)
+        open(key, :rw) do |f|
+          list = safe_load(f)
+          f.truncate(0)
+          f.rewind
+          data = list.shift
+          f.write(Marshal.dump(list))
+          data
+        end
+      end
+
+      def rpush(key, value)
+        open(key, :rw) do |f|
+          list = safe_load(f)
+          f.truncate(0)
+          f.rewind
+          list.push(value)
+          f.write(Marshal.dump(list))
+        end
+      end
+
+      def llen(key)
+        open(key, :r) do |f|
+          safe_load(f).length
+        end
+      end
+
+      private
+      def open(key, type)
+        mode, lock = case type
+                     when :rw then [::File::RDWR|::File::CREAT|::File::BINARY, ::File::LOCK_EX]
+                     when :r  then [::File::RDONLY|::File::CREAT|::File::BINARY, ::File::LOCK_SH]
+                     end
+        ::File.open(Qspec.path(key), mode) do |f|
+          f.flock(lock)
+          f.set_encoding('ASCII-8BIT')
+          yield(f)
+        end
+      end
+
+      def safe_load(f)
+        data = f.read
+        data.strip == '' ? [] : Marshal.load(data)
+      end
+    end
+  end
+end

data/lib/qspec/ipc/redis.rb

@@ -0,0 +1,16 @@
+require 'redis'
+module Qspec
+  class IPC
+    class Redis < IPC
+      def initialize
+        @redis = ::Redis.new
+      end
+
+      [:del, :lpop, :rpush, :llen].each do |method|
+        define_method(method) do |*args|
+          @redis.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/qspec/manager.rb

@@ -0,0 +1,131 @@
+require 'rspec/core/formatters/helpers'
+
+module Qspec
+  module Manager
+    TIME_LOG_NAME = 'elapsed_time'
+    DEFAULT_ELAPSED_TIME = 3.0
+    attr_reader :output
+    attr_reader :id
+
+    def start_worker
+      @id = rand(10000)
+      output.puts "ID: #{id}"
+      register_files(id)
+      if runnning_ports
+        puts "Connecting to spork: #{runnning_ports.inspect}"
+        runnning_ports.each do |port|
+          fork do
+            connect_spork(port, id, @configuration.error_stream, output)
+          end
+        end
+      else
+        puts "Forking #{@config['workers']} workers"
+        command = "qspec #{@options.drb_argv.join " "}"
+        @config['workers'].times do |i|
+          env = {
+            "qspec_id" => id.to_s,
+            "TEST_ENV_NUMBER" => i == 0 ? '' : (i + 1).to_s }
+          spawn(env,
+                command,
+                out: '/dev/null')
+        end
+      end
+
+      @stats = []
+      thread = start_progress_thread(id)
+      success = Process.waitall.all? { |pid, status| status.exitstatus == 0 }
+      thread.exit
+
+      pop_stat(id)
+
+      output.puts "Failures: " if ipc.llen("failure_#{id}") > 0
+
+      each_object("failure_#{id}") do |failure|
+        dump_failure(failure)
+      end
+
+      log_elapsed_times
+      dump_summary
+      exit(success ? 0 : 1)
+    ensure
+      if ipc
+        ipc.del("to_run_#{id}")
+        ipc.del("stat_#{id}")
+        ipc.del("failure_#{id}")
+      end
+    end
+
+    private
+    def start_progress_thread(id)
+      Thread.new do
+        loop do
+          pop_stat(id)
+          sleep 1
+        end
+      end
+    end
+
+    def pop_stat(id)
+      each_object("stat_#{id}") do |obj|
+        @stats << obj
+        output.print "!!! " if obj[3] > 0
+        output.puts obj.inspect
+      end
+    end
+
+    def each_object(key)
+      while data = ipc.lpop(key)
+        yield(Marshal.load(data))
+      end
+    end
+
+    def dump_summary
+      sum = @stats.each_with_object({ example: 0, failure: 0, pending: 0 }) do |stat, sum|
+        sum[:example] += stat[2]
+        sum[:failure] += stat[3]
+        sum[:pending] += stat[4]
+      end
+      output.puts "\n#{sum[:example]} examples, #{sum[:failure]} failures, #{sum[:pending]} pendings"
+    end
+
+    def dump_failure(failure)
+      puts ""
+      puts failure[:exception]
+      failure[:backtrace].each do |line|
+        output.puts "\t#{line}"
+      end
+    end
+
+    def log_elapsed_times
+      File.open(Qspec.path(TIME_LOG_NAME), 'w') do |f|
+        @stats.each do |stat|
+          f.puts "#{File.expand_path(stat[0])}:#{stat[1].to_f}"
+        end
+      end
+    end
+
+    def register_files(id)
+      sorted_files_to_run.uniq.each do |f|
+        ipc.rpush "to_run_#{id}", f
+      end
+    end
+
+    def sorted_files_to_run
+      @sorted_files_to_run ||= if @config['sort_by'] == 'time' && File.exists?(Qspec.path(TIME_LOG_NAME))
+                                 sort_by_time(@configuration.files_to_run)
+                               else
+                                 sort_by_size(@configuration.files_to_run)
+                               end
+    end
+
+    def sort_by_time(files)
+      log = Hash[File.readlines(Qspec.path(TIME_LOG_NAME)).map { |line| line.strip.split(":") }]
+      files.sort_by { |file| log[File.expand_path(file)].to_f || DEFAULT_ELAPSED_TIME }.reverse
+    end
+
+    # large to small
+    def sort_by_size(files)
+      files.sort_by { |file| -File.stat(file).size }
+    end
+  end
+end

data/lib/qspec/spork_helper.rb

@@ -0,0 +1,65 @@
+# spork is optional
+begin
+  require 'drb/drb'
+  require 'spork/test_framework/qspec'
+rescue LoadError
+end
+
+require 'rspec/core/drb_options'
+
+module Qspec
+  module SporkHelper
+    def start_spork_workers(count)
+      Signal.trap(:INT){
+        puts "Stop spork processes"
+        remove_port_file
+        exit(0)
+      }
+
+      default_port = (@config['spork_port'] || ::Spork::TestFramework::Qspec::DEFAULT_PORT).to_i
+      ports = []
+      count.times do |i|
+        port = default_port+i
+        spawn({ "TEST_ENV_NUMBER" => i == 0 ? '' : (i + 1).to_s },
+              "spork qspec --port #{port}")
+        ports << port
+      end
+      create_port_file(ports)
+      Process.waitall.all? { |pid, status| status.exitstatus == 0 } ? 0 : 1
+    end
+
+    def connect_spork(port, id, err, out)
+      begin
+        DRb.start_service("druby://localhost:0")
+      rescue SocketError, Errno::EADDRNOTAVAIL
+        DRb.start_service("druby://:0")
+      end
+      spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{port||PORT}")
+      exit spec_server.run(@options.drb_argv + [id], err, out).to_i
+    end
+
+    def create_port_file(ports)
+      File.open(port_file, 'w') do |f|
+        f.puts ports.join("\n")
+      end
+    end
+
+    def runnning_ports
+      @runnning_ports ||= begin
+        ports = File.readlines(port_file).map { |line| line.strip.to_i }
+        ports.empty? ? nil : ports
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+
+    def remove_port_file
+      File.unlink(port_file)
+    end
+
+    private
+    def port_file
+      @port_file ||= Qspec.path('spork_ports')
+    end
+  end
+end

data/lib/qspec/version.rb

@@ -0,0 +1,3 @@
+module Qspec
+  VERSION = "0.1.0"
+end

data/lib/spork/test_framework/qspec.rb

@@ -0,0 +1,11 @@
+require 'spork'
+class Spork::TestFramework::Qspec < Spork::TestFramework
+  DEFAULT_PORT = 9240
+  HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
+
+  def run_tests(argv, stderr, stdout)
+    require 'qspec'
+    ENV['qspec_id'] = argv.pop.to_s
+    ::Qspec::CommandLine.new(argv).run(stderr, stdout)
+  end
+end

data/qspec.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qspec/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "qspec"
+  gem.version       = Qspec::VERSION
+  gem.authors       = ["tomykaira"]
+  gem.email         = ["tomykaira@gmail.com"]
+  gem.description   = %q{QSpec inserts spec files to a queue.  Workers process that queue one by one.}
+  gem.summary       = %q{QSpec is extension of RSpec.  Q is for queue, and quick.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.post_install_message = "Run qspec-helper init to create your config file"
+
+  gem.add_dependency 'rspec-core', '~>2.13.1'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: qspec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- tomykaira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.1
+description: QSpec inserts spec files to a queue.  Workers process that queue one
+  by one.
+email:
+- tomykaira@gmail.com
+executables:
+- qspec
+- qspec-helper
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/qspec
+- bin/qspec-helper
+- lib/qspec.rb
+- lib/qspec/command_line.rb
+- lib/qspec/config.rb
+- lib/qspec/formatters/redis_formatter.rb
+- lib/qspec/helper.rb
+- lib/qspec/ipc.rb
+- lib/qspec/ipc/file.rb
+- lib/qspec/ipc/redis.rb
+- lib/qspec/manager.rb
+- lib/qspec/spork_helper.rb
+- lib/qspec/version.rb
+- lib/spork/test_framework/qspec.rb
+- qspec.gemspec
+homepage: ''
+licenses: []
+post_install_message: Run qspec-helper init to create your config file
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -177445891
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -177445891
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: QSpec is extension of RSpec.  Q is for queue, and quick.
+test_files: []