october 0.1.1

data/lib/october/version.rb

@@ -0,0 +1,3 @@
+module October
+  VERSION = '0.1.1'
+end

data/lib/october/watchdog.rb

@@ -0,0 +1,36 @@
+module October
+  class Watchdog
+    attr_reader :child, :root, :env
+
+    def initialize(root, env = nil)
+      @root = root
+      @env = env
+    end
+
+    def spawn!
+      @child = fork do
+        ENV['OCTOBER_ENV'] ||= env
+
+        require File.join(root, "boot")
+        require 'october'
+
+        October::Base.start
+      end
+    end
+
+    def loop!
+      loop do
+        begin
+          Process.wait(spawn!)
+          warn "process #{child} ended"
+        rescue Errno::ECHILD
+          warn "process #{child} died or was killed"
+        end
+
+        warn "spawning new one in next iteration"
+
+        sleep(1) # throttle spawning in case anything fails
+      end
+    end
+  end
+end

data/october.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/october/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Michal Cichra"]
+  gem.email         = ["mikz@o2h.cz"]
+  gem.description   = %q{IRC Bot}
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/mikz/october"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n") - %w{.gitignore .rvmrc .travis.yml Guardfile Gemfile.lock}
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "october"
+  gem.require_paths = ["lib", "plugins"]
+  gem.version       = October::VERSION
+
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'i18n'
+
+  gem.add_dependency 'cinch'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'fakefs'
+end
+

data/plugins/autossh.rb

@@ -0,0 +1,23 @@
+class Autossh
+  include October::Plugin
+
+  match /tunnels?$/, method: :reconnect
+
+  register_help 'tunnel[s]', 'Reconnects autossh tunnels'
+
+  def reconnect(m)
+    pids = IO.popen('ps ux | grep "auto[s]sh"') do |io|
+      io.readlines.map { |line|
+        line.split(/\s+/)[1].to_i
+      }
+    end
+
+    m.reply "Found #{pids.count} autossh processes"
+
+    unless pids.empty?
+      m.reply "Sending SIGUSR1 to pid: #{pids.join(", ")}"
+      Process.kill('USR1', *pids)
+    end
+  end
+
+end

data/plugins/fortune.rb

@@ -0,0 +1,13 @@
+gem 'typhoeus'
+
+class Fortune
+  include October::Plugin
+
+  match /fortune?$/, method: :fortune
+
+  register_help 'fortune', 'fortune YO!'
+  def fortune(m)
+    response = Typhoeus::Request.get "http://www.fortunefortoday.com/getfortuneonly.php"
+    m.reply response.body.strip
+  end
+end

data/plugins/help.rb

@@ -0,0 +1,11 @@
+class Help
+  include October::Plugin
+  register_help 'help', 'list all registered commands with description'
+
+   match 'help', method: :help
+
+   def help(m)
+     m.user.msg 'October help:'
+     m.user.msg self.class.list_help
+   end
+end

data/plugins/hudson.rb

@@ -0,0 +1,73 @@
+require 'typhoeus'
+
+class Hudson
+  include October::Plugin
+
+  autoload :Fetcher, 'hudson/fetcher'
+  autoload :Reporter, 'hudson/reporter'
+  autoload :TestRun, 'hudson/test_run'
+  autoload :Config, 'hudson/config'
+
+  HYDRA = Typhoeus::Hydra.new
+
+  FAILED = /(?:failures|failed|f)/
+  NUMBER = /(?:\/(\d+))?/
+  JOB = /([\w\-\.]+?)/
+  BUILD = /#{JOB}#{NUMBER}/
+
+  match /#{FAILED}(?:\s+#{BUILD})?$/, method: :failures
+  match /(?:failures|failed|f) #{BUILD} diff #{BUILD}$/, method: :diff
+  match /Project (.+?) build #(\d+): (?:SUCCESS|FIXED) (?:.+?): (.*)$/, method: :green, :use_prefix => false
+  match /(?:job|j) (\S*)(?: ?)(.*?)$/, method: :update_branch
+  match /(?:build|b)(?: ?)(.*?)$/, method: :build
+
+  register_help 'failures|failed|f project', 'list failed tests (cukes and test units) from last test run'
+  register_help 'failures|failed|f project/test_number', 'list failed tests from specific test run'
+  register_help 'failures|failed|f project/test_number diff another/test', 'list only difference between these two tests'
+  register_help 'build [job_name]', 'builds your personal project or the given job'
+  register_help 'job branch_name [job_name]', 'updates your personal project or the specified job to build the given branch'
+
+  def failures(m, job = nil, test_run = nil)
+    job ||= m.user
+    test = TestRun.new job, test_run
+    reporter = Reporter.new test
+
+    reporter.respond :report, m
+  end
+
+  def diff(m, *projects)
+    tests = projects.in_groups_of(2).map {|project, number|
+      TestRun.new project, number
+    }
+    reporter = Reporter.new *tests
+
+    reporter.respond :diff, m
+  end
+
+  def green(m, project_name, build, url)
+    if October::Plugins.registered["Hudson"]
+      tr = TestRun.new(project_name, build)
+      issues = @bot.plugins.detect{|a| a.is_a? Issues}
+      pull = issues.pull_request(m, tr.branch)
+      issues.comment(m, pull["number"], "Green: #{url}") if pull
+    end
+  end
+
+  def update_branch(m, new_branch, job_name)
+    job_name = m.user.to_s if job_name.blank?
+    config = Config.new(job_name)
+    config.update_branch(new_branch)
+    m.reply "Job '#{job_name}' set to build branch '#{new_branch}'"
+  rescue
+    m.reply "Error updating job"
+  end
+
+  def build(m, job_name)
+    job_name = m.user.to_s if job_name.blank?
+    config = Config.new(job_name)
+    config.build
+    m.reply "Build of '#{job_name}' scheduled"
+  rescue
+    m.reply "Failed to schedule a build for '#{job_name}'"
+  end
+end

data/plugins/hudson/config.rb

@@ -0,0 +1,41 @@
+require 'open-uri'
+
+class Hudson
+  class Config
+    BASE_URL = "http://localhost:8080"
+    BUILD_URL = "/job/<project>/build"
+    CONFIG_URL = "/job/<project>/config.xml"
+
+    attr_reader :job
+
+    def initialize(job)
+      @job = job
+    end
+
+    def config_url
+      (BASE_URL + CONFIG_URL).gsub('<project>', job)
+    end
+
+    def build_url
+      (BASE_URL + BUILD_URL).gsub('<project>', job)
+   end
+
+    def config
+      @config ||= Nokogiri::XML(open(config_url))
+    end
+
+    def build
+      open(build_url)
+    end
+
+    def update_branch(branch_name)
+      config.xpath('/project/scm/branches/hudson.plugins.git.BranchSpec/name').each do |branch|
+        branch.content = branch_name
+      end
+
+      Curl::Easy.http_post(config_url, config.to_s) do |curl|
+        curl.headers['Content-Type'] = 'text/xml'
+      end
+    end
+  end
+end

data/plugins/hudson/fetcher.rb

@@ -0,0 +1,40 @@
+class Hudson
+   class Fetcher < Typhoeus::Request
+    BASE_URL = "http://localhost:8080"
+    JOB_URL = "/job/<project>/<test_run>/consoleText"
+
+    attr_reader :test_run
+
+    def initialize test_run, options = {}
+      @test_run = test_run
+
+      url = (BASE_URL + JOB_URL).
+        gsub('<project>', test_run.project.to_s).
+        gsub('<test_run>', test_run.number.to_s)
+
+      super(url, options)
+
+      self.authorize = {
+        :username => ENV['HUDSON_USER'].presence,
+        :password => ENV['HUDSON_PASS'].presence
+      }
+
+    end
+
+    def authorize= options
+      @username = options[:username]
+      @password = options[:password]
+    end
+
+    def response
+      @response or run
+    end
+
+    def run
+      HYDRA.queue self
+      HYDRA.run
+      self.response
+    end
+  end
+
+end

data/plugins/hudson/reporter.rb

@@ -0,0 +1,104 @@
+class Hudson
+  class Reporter
+
+    class Diff
+      include Enumerable
+
+      def initialize(base, other)
+        @base, @other = base, other
+      end
+
+      def header
+        "--- #{@base.project}/#{@base.number} <=> #{@other.project}/#{@other.number} ---"
+      end
+
+      def each(&block)
+        failures.each(&block)
+      end
+
+      def to_s
+        [header, *surplus, *common, *missing].join("\n")
+      end
+
+      delegate :length, :to => :all
+
+      private
+      def surplus
+        prefix('+', @other.failures - @base.failures)
+      end
+
+      def missing
+        prefix('-', @base.failures - @other.failures)
+      end
+
+      def all
+        @failures ||= @base.failures | @other.failures
+      end
+
+      def common
+        prefix(' ', @base.failures & @other.failures)
+      end
+
+      def prefix(str, array)
+        array.map{ |line| str + " " << line }
+      end
+
+    end
+
+    class Report < Array
+      def initialize test
+        @project, @number = test.project, test.number
+        super(test.failures.flatten)
+      end
+
+      def header
+        "------- #{@project}/#{@number} -------"
+      end
+
+      def to_s
+        [header, *self].join("\n")
+      end
+    end
+
+    attr_reader :tests
+
+    def initialize *tests
+      @tests = tests.flatten
+    end
+
+    def report
+      Report.new(@tests.first)
+    end
+
+    def diff
+      Diff.new(@tests.first, @tests.last)
+    end
+
+    def respond format, message
+
+      if responses.all? &:success?
+        return message.user.msg self.send(format)
+      end
+
+      responses(&:timed_out?).each do |r|
+        message.reply 'Some requests timed out :('
+      end
+
+      responses{|r| r.code == 0 }.each do |r|
+        message.reply r.curl_error_message
+      end
+
+      responses{|r| r.code != 200 }.each do |r|
+        message.reply "HTTP request failed: #{r.code}"
+      end
+
+    end
+
+    private
+
+    def responses(&block)
+      @tests.map(&:response).select &block
+    end
+
+  end
+end

data/plugins/hudson/test_run.rb

@@ -0,0 +1,88 @@
+class Hudson
+  class TestRun
+
+    class Cucumber
+      PATTERN = /^cucumber (?:.+?\/)(features\/.+?\.feature:\d+)/
+
+      def self.parse(log)
+        log.scan(PATTERN).flatten.uniq.map{ |name| self.new(name) }
+      end
+
+      def initialize(file)
+        @file = file
+      end
+
+      def to_s
+        @file
+      end
+      alias :to_str :to_s
+
+      def ==(other)
+        to_s == other.try(:to_s)
+      end
+    end
+
+    class TestUnit
+      PATTERN = /\d+\) (?:Failure|Error):\n(.+?)(?:\n{2})/m
+      NAME = /(.+)\((.+)\)[\n: ]+/
+      FILE = /(?:(test\/.+.[a-z]+):\d+)+(?::in `.+')?/
+
+      def self.parse(log)
+        blocks = log.scan(PATTERN).flatten
+        blocks.map do |block|
+          name = block.scan(NAME).first.first
+          file = block.scan(FILE).last.try(:join) || '(missing file)'
+          self.new(name, file)
+        end
+      end
+
+      def initialize(name, file)
+        @name, @file = name, file
+      end
+
+      def to_s
+        "#{@file} -n '#{@name}'"
+      end
+      alias :to_str :to_s
+
+      def ==(other)
+        to_s == other.try(:to_s)
+      end
+    end
+
+
+    attr_reader :project, :number
+
+    def initialize(project, number = nil)
+      @project = project
+      @number = number.presence || 'lastBuild'
+
+      @fetcher = Fetcher.new self
+    end
+
+    def cucumbers
+      @cucumbers ||= Cucumber.parse(log)
+    end
+
+    def test_unit
+      @test_unit ||= TestUnit.parse(log)
+    end
+
+    def branch
+      log.scan(/Commencing build of Revision (?:.+?) \(origin\/(.+?)\)(.*)/).first.first
+    end
+
+    def all
+      cucumbers + test_unit
+    end
+
+    alias :failures :all
+
+    delegate :response, :to => :@fetcher
+
+    def log
+      response.body
+    end
+
+  end
+end