git_test 0.0.4 → 0.0.5

data/lib/git_test/notify.rb

@@ -0,0 +1,93 @@
+module GitTest
+  class Notify
+    class TextFormat
+      attr_accessor :length, :msg, :filler
+      ENGINE = "#=="
+      CABOOSE = "==#"
+      FILL_CHAR = "="
+
+      def initialize(msg, length)
+        self.msg    = " #{msg} "
+        self.length = length
+      end
+
+      def filler_length_needed
+        length - (ENGINE.length + CABOOSE.length + msg.length)
+      end
+
+      def filler_per_side
+        filler_length_needed/2.0
+      end
+
+      def odd?
+        !even?
+      end
+
+      def even?
+        filler_per_side % 2 == 0
+      end
+
+      def message_too_long?
+        filler_length_needed < 0
+      end
+
+      # def truncate_message!
+      #   self.msg # = msg[0, msg.length + filler_length_needed - 3 ] << "..."
+      # end
+
+      def add_filler!
+        filler = filler_per_side.floor.times.map {FILL_CHAR}.join("")
+        # result = if even?
+        #         self.msg = "#{filler}#{msg}#{filler}"
+        #       else
+        #         self.msg = "#{filler}#{msg}#{filler}#{FILL_CHAR}"
+        #       end
+      end
+
+       def output
+         "#{ENGINE}#{msg}"
+       end
+
+      def normalize
+        add_filler!
+        output
+      end
+
+    end
+    attr_accessor :output
+
+    def initialize(output = STDOUT)
+      self.output = output
+    end
+
+    def start(msg)
+      write(msg, :light_blue)
+    end
+
+    def sentiment(msg, bool = true)
+      write(msg, bool ? :green : :red)
+    end
+
+    def done(msg, passed = true)
+      sentiment(msg, passed)
+    end
+
+    def warn(msg)
+      write("WARNING: #{msg}", :red)
+    end
+
+    def critical_error(msg, exit_code = -1)
+      write(msg, :red)
+      exit! exit_code
+    end
+
+    def raw(msg)
+      output.puts(msg)
+    end
+
+    def write(msg, color = :light_yellow, truncate = 80)
+      msg = TextFormat.new(msg, truncate).normalize
+      output.puts "#{msg}".send color
+    end
+  end
+end

data/lib/git_test/proj.rb

@@ -0,0 +1,49 @@
+module GitTest
+  class Proj < Git::Base
+    attr_accessor :notify
+    def initialize(options = {}, notify = Notify.new)
+      self.notify = notify
+      path =  options[:path]||"."
+      super :working_directory => path
+    end
+
+    def username
+      config["user.name"]
+    end
+
+    # add
+    # commit("this is my commit message")
+
+
+    def show(branch, file)
+      self.lib.send :command, "show", "#{branch}:#{file}"
+    end
+
+
+    def real_pull(remote = 'origin', branch = 'master')
+      check_repo_status!
+      self.lib.send :command, 'pull', [remote, branch]
+    end
+
+    def check_repo_status!
+      repo_status_checked = true
+    end
+
+    def path
+      dir.to_s
+    end
+
+    # def test_directory
+    #   File.join(path, '..', ".tmp-git-test-dir-for-#{repo_name}")
+    # end
+
+    def repo_name
+      path.split('/').last
+    end
+
+    def clone_to(path)
+      Git.clone(self.repo, path)
+    end
+    alias :clone_to_test :clone_to
+  end
+end

data/lib/git_test/runner.rb

@@ -0,0 +1,143 @@
+require 'time'
+
+module GitTest
+  # orchestrates everything
+  class Runner
+     attr_accessor :notify, :options, :proj, :test_proj, :test, :writer, :test_dir
+
+     def initialize(options ={} , notify = Notify.new)
+       self.options  = options
+       self.notify   = notify
+       self.proj     = GitTest::Proj.new(options)
+       self.test     = GitTest::Test.new(options)
+       self.test_dir = Dir.mktmpdir(".git_test_#{proj.current_branch}_#{Time.now.to_i}")
+       clone_to_test!
+     end
+
+     # runs the test command provided
+     def test!
+       in_test_dir do
+         proj.check_repo_status!
+         notify.start("Running tests on: #{proj.current_branch}")
+         test.run!
+         notify.done("Test finished: #{test.status}", test.passed?)
+       end
+     end
+
+     # will open the specified or  last report
+     def show_report(file_name = nil, branch = current_branch)
+       file_name ||= last_report_file_name(branch)
+       report = proj.show(report_branch, File.join(report_path(branch), file_name))
+       report_file = Tempfile.new([report_name, report_extension])
+       report_file.write(report)
+       exec "open #{report_file.path}"
+       sleep 300
+     end
+
+     # gives last report file name
+     def last_report_file_name(branch = current_branch)
+       ls_report_dir(branch).first
+     end
+
+     # outputs the files in the test directory for a given branch
+     def ls_report_dir(branch = current_branch)
+       files = proj.show(report_branch, report_path(branch)).split("\n")
+       files.shift(2)
+       files
+     end
+
+
+     # cleans up the temp directory
+     def clean_test_dir!
+       FileUtils.remove_entry_secure test_dir
+     end
+
+     # pushes to origin on the current branch and report branch
+     def push!
+       notify.write("Pushing to origin")
+       proj.push('origin', proj.current_branch)
+       proj.push('origin', report_branch) if proj.is_branch? report_branch
+     end
+
+     # pulls from origin on the current branch and report branch
+     def pull!
+       notify.write("Pulling from origin")
+       proj.pull('origin', proj.current_branch)
+     end
+
+     # writes the result of the test command to disk
+     def write_report!
+       notify.critical_error("Must run `test!` before writing a report") if test.status.nil?
+       in_test_dir do
+         self.writer  = GitTest::Writer.new(:path   => report_path,
+                                            :name   => report_name,
+                                            :report => test.report )
+         in_report_branch do
+           writer.save!
+           commit_to_test_proj!
+         end
+       end
+     end
+
+     # commits contents of test branch and pushes back to local repo
+     def commit_to_test_proj!
+       test_proj.add full_report_path
+       result = test_proj.commit("#{proj.current_branch} #{report_name}")
+       notify.write("Pushing back to local repo")
+       test_proj.real_pull('origin', report_branch)
+       test_proj.push('origin', report_branch)
+     end
+
+     private
+
+     def full_report_path
+       File.join(report_path, report_name)
+     end
+
+     def report_branch
+       "git_test_reports"
+     end
+
+     def report_path(branch = proj.current_branch)
+       "git_test_reports/#{branch}"
+     end
+
+     def report_name
+       name =  "#{ test.created_at.utc.iso8601 }_"
+       name << "#{ proj.username }_"
+       name << "#{ test.status }#{ report_extension }"
+     end
+
+     def current_branch
+       proj.current_branch
+     end
+
+
+
+     def report_extension
+       ".#{test.format}"
+     end
+
+
+     def clone_to_test!
+       clone = proj.clone_to_test(test_dir)
+       self.test_proj = GitTest::Proj.new(:path => clone.dir.to_s)
+     end
+
+     def in_test_dir(&block)
+       Dir.chdir(test_dir) do
+         yield
+       end
+     end
+
+     def in_report_branch(branch = report_branch, &block)
+       in_test_dir do
+         branch = test_proj.branch(branch)
+         branch.checkout
+         test_proj.checkout(branch)
+         yield
+         test_proj.checkout(proj.current_branch)
+       end
+     end
+   end
+end

data/lib/git_test/test.rb

@@ -0,0 +1,28 @@
+module GitTest
+  class Test
+    attr_accessor :report, :status, :notify, :created_at, :command, :exit_code
+    def initialize(options = {}, notify = Notify.new)
+      self.notify     = notify
+      self.created_at = Time.now
+      self.command    = options[:cmd]
+    end
+
+    def format
+      :html
+    end
+
+    def passed?
+      exit_code == 0
+    end
+
+    def failed?
+      !passed?
+    end
+
+    def run!
+      self.report = %x{#{command}}
+      self.exit_code = Integer($?)
+      self.status = passed? ? "passed" : "failed"
+    end
+  end
+end

data/lib/git_test/writer.rb

@@ -0,0 +1,46 @@
+require 'fileutils.rb'
+
+
+module GitTest
+  # takes a path, a name (file name) and a report
+  # makes directory if not present
+  # writes the given report to the file name in that path
+  class Writer
+    attr_accessor :report, :path, :name, :notify
+
+    def initialize(options, notify = Notify.new)
+      self.path   = options[:path]
+      self.name   = options[:name]
+      self.report = options[:report]
+      self.notify = notify
+    end
+
+
+    def mkdir!
+      FileUtils.mkdir_p(path)
+    end
+    
+    def full_path
+      File.join(path, name)
+    end
+
+    def write_report_to_disk!
+      mkdir!
+      File.open(full_path, 'w') {|f| f.write(report) }
+    end
+
+    def self.save(*args)
+      self.new(*args).save
+    end
+
+    def save
+      notify.start("Writing report to #{full_path}")
+      write_report_to_disk!
+    end
+    alias :save! :save
+
+    def show_report
+      system "open #{}"
+    end
+  end
+end

data/lib/git_test.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'git'
+require 'colorize'
+require 'growl'
+
+module GitTest
+
+end
+
+require 'lib/git_test/notify.rb'
+require 'lib/git_test/runner'
+require 'lib/git_test/test'
+require 'lib/git_test/writer'
+require 'lib/git_test/proj'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: git_test
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Richard Schneeman
@@ -181,6 +181,12 @@ extra_rdoc_files:
 - README.md
 files: 
 - bin/git_test
+- lib/git_test.rb
+- lib/git_test/notify.rb
+- lib/git_test/proj.rb
+- lib/git_test/runner.rb
+- lib/git_test/test.rb
+- lib/git_test/writer.rb
 - README.md
 homepage: https://github.com/schneems/git_test
 licenses: []