limited_red 0.2.4

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Joseph Wilk
+
+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.rdoc

@@ -0,0 +1,17 @@
+= Limited Red Client
+
+== Docs
+
+https://github.com/josephwilk/limited-red-client/wikis
+
+== Running tests
+
+  rake
+
+== Authors
+* Joseph Wilk <joe@josephwilk.net>
+
+
+== Copyright
+
+Copyright (c) 2010,2011 Joseph Wilk. See LICENSE for details.

data/lib/limited_red.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'httparty'
+require 'cucumber'
+
+module LimitedRed
+  ROOT = File.expand_path('..', __FILE__)
+
+  autoload :Gzip,       "#{ROOT}/limited_red/gzip"
+  autoload :Client,     "#{ROOT}/limited_red/client"
+
+  autoload :ThreadPool, "#{ROOT}/limited_red/thread_pool"
+  autoload :FakeThreadPool, "#{ROOT}/limited_red/thread_pool"
+  
+  autoload :Stats,      "#{ROOT}/limited_red/stats"
+  autoload :Config,     "#{ROOT}/limited_red/config"
+
+  module Adapter
+    autoload :HttParty,   "#{ROOT}/limited_red/adapter/httparty"
+  end
+
+  module Formatter
+    autoload :Stats, "#{ROOT}/limited_red/formatter/stats"
+  end
+end

data/lib/limited_red/adapter/httparty.rb

@@ -0,0 +1,24 @@
+module LimitedRed
+  module Adapter
+    class HttParty
+      def self.new(config, options = {})
+        host = config['host'] || 'https://limited-red-data-service.heroku.com/'
+        port = config['port'] || ''
+        uri = "#{host}#{port == '' ? '' : ":#{port}"}"
+      
+        HttPartyAdapter.base_uri(uri)
+        HttPartyAdapter
+      end
+    end
+
+    class HttPartyAdapter
+      include HTTParty
+      
+      def self.encode_and_compress(data)
+        compressed_result = Gzip.compress(data)
+        Base64.encode64(compressed_result)
+      end
+      
+    end
+  end
+end

data/lib/limited_red/client.rb

@@ -0,0 +1,74 @@
+module LimitedRed
+  class Client
+    def initialize(config, out = STDOUT, adapter = nil, thread_pool = ThreadPool)
+      @config ||= config
+      @out = out
+      @project_id = @config['project name']
+      @username = @config['username']
+      @api_key = @config['api key']
+        
+      @adapter = adapter || LimitedRed::Adapter::HttParty.new(@config)
+      @thread_pool = thread_pool
+    end
+
+    def log_result(build_id, data)
+      data[:result] = @adapter.encode_and_compress(data[:result])
+      data = data.merge({:user => @username, :token => token_for(data.merge(:build_id => build_id))})
+
+      @thread_pool.with_a_thread_run do
+        result = @adapter.post("/projects/#{@project_id}/builds/#{build_id}/results", :body => data)
+        @out.puts error_message(result) if error?(result)
+      end
+    end
+
+    def log_build(build_id, data)
+      data[:build_id] = build_id
+      data = data.merge({:user => @username, :build_id => build_id, :token => token_for(data)})
+        
+      @thread_pool.with_a_thread_run do
+        result = @adapter.post("/projects/#{@project_id}/builds", :body => data)
+        @out.puts error_message(result) if error?(result)
+      end
+    end
+      
+    def find_failing_features
+      raise "No project name was found in params: #{@config.inspect}" if @project_id.nil?
+
+      response = @adapter.get("/projects/#{@project_id}/features/fails?user=#{@username}")
+
+      return [] if response.nil? || response.empty?
+      response.code == 200 ? response.body.split(" ") : []
+    end
+            
+    private
+    def token_for(data)
+      data_string = @username.to_s +
+                    @project_id.to_s +
+                    build_data_string(data[:fails]) +
+                    build_data_string(data[:passes]) +
+                    (data[:result] ? data[:result] : "") +
+                    (data[:build_id].to_s) + 
+                    @api_key.to_s
+
+      Digest::SHA1.hexdigest(data_string)
+    end
+
+    def build_data_string(data)
+      data == "" || data.nil? ? "" : data.join("")
+    end
+
+    def error?(result)
+      result && !result.body.empty?
+    end
+      
+    def error_message(error_msg)
+      if ENV['LIMITED_RED_ENV'] == 'test' || ENV['LIMITED_RED_ENV'] == 'development'
+        message = #{error_msg}
+      else
+        message = ""
+      end
+      
+      "\nLimited Red had a problem logging your test results.\n#{message}"
+    end
+  end
+end

data/lib/limited_red/config.rb

@@ -0,0 +1,111 @@
+module LimitedRed
+  class Config
+    def initialize(out_stream = STDOUT, in_stream = STDIN)
+      @in = in_stream
+      @out = out_stream
+    end
+    
+    def self.load_and_validate_config
+      new.load_and_validate_config
+    end
+        
+    def load_and_validate_config
+      ensure_config_exists
+      if valid_config?
+        config
+      else
+        errors = "Make sure you have the following set in your .limited_red:\n"
+        errors += " * project name\n" unless config['project name']
+        errors += " * username\n" unless config['username']
+        errors += " * api key\n" unless config['api key']
+        @out.print errors
+      end
+    end
+
+    def config
+      @config ||= begin
+        limited_red_project_config  = load_yaml(limited_red_project_config_file)
+        limited_red_shared_config = load_yaml(limited_red_shared_config_file)
+        limited_red_shared_config.merge(limited_red_project_config)
+      end
+    end
+
+    private
+      
+    def load_yaml(file)
+      if file
+        content = IO.read(file)
+        YAML::load(content)
+      else
+        {}
+      end
+    end
+
+    def ensure_config_exists
+      unless limited_red_project_config_file_exists?
+        details = ask_for_setup_details
+
+        File.open("#{home_dir}/.limited_red", 'w') do |f|
+          f.write("username: #{details['username']}\n")
+          f.write("api key: #{details['api key']}\n")
+        end
+          
+        FileUtils.touch(".limited_red")
+        File.open('.limited_red', 'w') do |f|
+          f.write("project name: #{details['project name']}\n")
+        end
+      end
+    end
+
+    def ask_for_setup_details
+      details = {}
+      @out.print "Project name"
+      project_name = guess_project_name
+      @out.print " (default: #{project_name})" if project_name
+      @out.print ": "
+      name = @in.readline.strip
+      name = name.empty? ? project_name : name
+      name.downcase
+      details['project name'] = name.gsub(/[^a-zA-Z0-9']+/, "-")
+      @out.print "username: "
+      username = @in.readline.strip
+      details['username'] = username
+      @out.print "api key: "
+      api_key = @in.readline.strip
+      details['api key'] = api_key
+      details
+    end
+
+    def valid_config?
+      config && 
+      config['project name'] &&
+      config['username'] &&
+      config['api key']
+    end
+
+    def limited_red_project_config_file_exists?
+      limited_red_project_config_file
+    end
+
+    def limited_red_shared_config_file
+      @global_config_file ||= Dir.glob("#{home_dir}/.limited_red").first
+    end
+
+    def limited_red_project_config_file
+      @project_config_file ||= Dir.glob('.limited_red').first
+    end
+      
+    private
+    def home_dir
+      ENV['HOME'] ||  File.expand_path('~') #Dir.home
+    end
+      
+    def guess_project_name
+      dir = Dir.pwd
+      if dir
+        current_dir = dir.split('/')[-1]
+        return current_dir if current_dir && !current_dir.empty?
+      end
+    end
+  end
+end

data/lib/limited_red/formatter/stats.rb

@@ -0,0 +1,63 @@
+require 'cucumber/formatter/json'
+require 'limited_red/client'
+
+module LimitedRed
+  module Formatter  
+    class Stats < Cucumber::Formatter::Json
+      
+      def initialize(step_mother, path_or_io, options)
+        @t = Time.now
+        @build_id = Time.now.to_i
+        @step_mother = step_mother
+        @client = LimitedRed::Client.new(LimitedRed::Config.load_and_validate_config)
+
+        super
+      end
+
+      def after_feature(feature)
+        if supports_feature_hash?
+          json = feature_hash.to_json
+          @client.log_result(@build_id, :result => json)
+        else
+          puts "Error: Gherkin version is out of date and does not support @feature_hash: #{gherkin_formatter.instance_variables}"
+        end
+      end
+
+      def after_features(features)
+        print_summary
+      end
+
+      def print_summary
+         @client.log_build(@build_id, {:fails => failing_files, 
+                                       :passes => passing_files})
+                                                   
+        ThreadPool.wait_for_all_threads_to_finish
+      end
+
+      def failing_files
+        failures = @step_mother.scenarios(:failed).select { |s| s.is_a?(Cucumber::Ast::Scenario) || s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow) }
+        failures = failures.collect { |s| (s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)) ? s.scenario_outline : s }
+        failures.map{|fail| fail.file_colon_line}
+      end
+
+      def passing_files
+        passing = @step_mother.scenarios(:passed).select { |s| s.is_a?(Cucumber::Ast::Scenario) || s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow) }
+        passing = passing.collect { |s| (s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)) ? s.scenario_outline : s }
+        passing.map{|pass| pass.file_colon_line}
+      end
+      
+      def supports_feature_hash?
+        gherkin_formatter.instance_variables.include?(:@feature_hash)
+      end
+      
+      def feature_hash
+        gherkin_formatter.instance_variable_get("@feature_hash")
+      end
+      
+      def gherkin_formatter
+        @gf
+      end
+      
+    end
+  end
+end

data/lib/limited_red/gzip.rb

@@ -0,0 +1,22 @@
+require 'zlib'
+require 'stringio'
+
+module LimitedRed
+  module Gzip
+    class Stream < StringIO
+      def close; rewind; end
+    end
+
+    def self.compress(source)
+      output = Stream.new
+      gz = Zlib::GzipWriter.new(output)
+      gz.write(source)
+      gz.close
+      output.string
+    end
+    
+    def self.decompress(source)
+      Zlib::GzipReader.new(StringIO.new(source)).read
+    end
+  end
+end

data/lib/limited_red/plugin.rb

@@ -0,0 +1,23 @@
+AfterConfiguration do |config|
+  unless ENV['STOP_RECORDING']
+    require 'limited_red'
+  
+    options = config.instance_variable_get("@options")
+    options[:formats] << ['LimitedRed::Formatter::Stats', config.out_stream]
+  
+    limited_red_config = LimitedRed::Config.load_and_validate_config
+    if limited_red_config
+      cuke_stats = LimitedRed::Stats.new(limited_red_config)
+  
+      feature_files = options[:paths]
+      feature_files = ["features"] if feature_files.empty?
+
+      prioritised_features = cuke_stats.feature_files & config.feature_files
+      
+      options[:paths] = prioritised_features + feature_files
+    else
+      puts "Aborting Cucumber run"
+      exit
+    end
+  end
+end

data/lib/limited_red/stats.rb

@@ -0,0 +1,18 @@
+module LimitedRed
+  class Stats
+    def initialize(config)
+      @client = Client.new(config)
+    end
+
+    def feature_files
+      files = failing_features.uniq
+      files.select{|file| File.exists?(file)}
+    end
+
+    private
+
+    def failing_features
+      @client.find_failing_features
+    end 
+  end
+end

data/lib/limited_red/thread_pool.rb

@@ -0,0 +1,28 @@
+module LimitedRed
+  class FakeThreadPool
+    class << self
+      def with_a_thread_run(&block)
+        yield
+      end
+      
+      def wait_for_all_threads_to_finish
+      end
+    end
+  end
+  
+  class ThreadPool
+    class << self
+      attr_writer :threads
+      
+      def with_a_thread_run(&block)
+        @threads ||= []
+        @threads << Thread.new(&block)
+      end
+      
+      def wait_for_all_threads_to_finish
+        @threads.each { |thread| thread.join }
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: limited_red
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Wilk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70300184545600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70300184545600
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70300184545120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70300184545120
+description: Run tests priorited by those that are most likely to fail
+email: joe@josephwilk.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- lib/limited_red/adapter/httparty.rb
+- lib/limited_red/client.rb
+- lib/limited_red/config.rb
+- lib/limited_red/formatter/stats.rb
+- lib/limited_red/gzip.rb
+- lib/limited_red/plugin.rb
+- lib/limited_red/stats.rb
+- lib/limited_red/thread_pool.rb
+- lib/limited_red.rb
+- LICENSE
+- README.rdoc
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Run tests priorited by those that are most likely to fail
+test_files: []