cadre 0.0.1

data/bin/cadre

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# vim: set ft=ruby :
+
+require 'cadre/command-line'
+
+Cadre::CommandLine.start

data/default_files/config.yaml

@@ -0,0 +1,9 @@
+---
+verbose: true
+quickfix:
+  output_path: errors.err
+  backtrace_pattern: '.*\.rb'
+  backtrace_limit: -1
+  include_pending: false
+simplecov:
+  output_path: .cadre/coverage.vim

data/default_files/templates/coverage-results.vim.erb

@@ -0,0 +1,13 @@
+"simplecov results template
+let s:generatedTime = <%= Time.now.to_i %>
+let s:coverageResults = {
+<% results.each_pair do |file, coverage|
+  %>\'<%= file %>': {
+\  'hits': <%= coverage[:hits].inspect %>,
+\  'misses': <%= coverage[:misses].inspect%>,
+\  'ignored': <%= coverage[:ignored].inspect%>
+\  },
+<% end%>
+\}
+call AddSimplecovResults(expand("<sfile>:p"), s:coverageResults)
+"end template

data/default_files/templates/plugin.vim

@@ -0,0 +1,155 @@
+""" Test Ally Vim plugin
+"hi  HitLine     ctermbg=Cyan     guibg=Cyan
+"hi  MissLine    ctermbg=Magenta  guibg=Magenta
+"hi  IgnoreLine  ctermbg=Black    guibg=Black
+
+hi  HitSign     ctermfg=6      cterm=bold   gui=bold    guifg=Green
+hi  MissSign    ctermfg=Red    cterm=bold   gui=bold    guifg=Red
+hi  IgnoreSign  ctermfg=6      cterm=bold   gui=bold    guifg=Grey
+"
+sign  define  hit      linehl=HitLine      texthl=HitSign      text=✔
+sign  define  miss     linehl=MissLine     texthl=MissSign     text=✘
+sign  define  ignored  linehl=IgnoredLine  texthl=IgnoredSign  text=◌
+
+let s:coverageFileRelPath = ".cadre/coverage.vim"
+
+let s:coverageFtimes = {}
+let s:allCoverage = {}
+
+function! AddSimplecovResults(file, results)
+  let s:allCoverage[fnamemodify(a:file, ":p")] = a:results
+endfunction
+
+function! s:LoadAllCoverage(file)
+  let l:ftime = getftime(a:file)
+  if(!has_key(s:coverageFtimes, a:file) || (s:coverageFtimes[a:file] < l:ftime))
+    if(has_key(s:allCoverage, a:file))
+      unlet s:allCoverage[a:file]
+    endif
+    exe "source ".a:file
+    let s:coverageFtimes[a:file] = l:ftime
+  endif
+  let b:coverageFtime = s:coverageFtimes[a:file]
+endfunction
+
+function! s:BestCoverage(coverageFile, coverageForName)
+  let matchBadness = strlen(a:coverageForName)
+  if(has_key(s:allCoverage, a:coverageFile))
+    for filename in keys(s:allCoverage[a:coverageFile])
+      let matchQuality = match(a:coverageForName, filename . "$")
+      if (matchQuality >= 0 && matchQuality < matchBadness)
+        let matchBadness = matchQuality
+        let found = filename
+      endif
+    endfor
+  endif
+
+  if exists("found")
+    let b:lineCoverage = s:allCoverage[a:coverageFile][l:found]
+    let b:coverageName = found
+  else
+    let b:coverageName = '(none)'
+    call s:emptyCoverage(a:coverageForName)
+  endif
+endfunction
+
+function! s:emptyCoverage(coverageForName)
+  echom "No coverage recorded for " . a:coverageForName
+  let b:lineCoverage = {'hits': [], 'misses': [], 'ignored': [] }
+endfunction
+
+function! s:FindCoverageFile(codeFile)
+  let found_coverage = findfile(s:coverageFileRelPath,fnamemodify(a:codeFile, ':p:h').";")
+  if(found_coverage == '')
+    return ''
+  else
+    return fnamemodify(found_coverage, ":p")
+  end
+endfunction
+
+function! s:LoadFileCoverage(codeFile, coverageFile)
+  call s:LoadAllCoverage(a:coverageFile)
+  call s:BestCoverage(a:coverageFile, a:codeFile)
+endfunction
+
+function s:SetSign(filename, line, type)
+  let id = b:coverageSignIndex
+  let b:coverageSignIndex += 1
+  let b:coverageSigns += [id]
+  exe ":sign place ".id." line=".a:line." name=".a:type." file=" . a:filename
+endfunction
+
+"XXX locating buffer + codeFile...
+function! s:SetCoverageSigns(filename)
+  if (! exists("b:coverageSigns"))
+    let b:coverageSigns = []
+  endif
+
+  if (! exists("b:coverageSignIndex"))
+    let b:coverageSignIndex = 1
+  endif
+
+  for line in b:lineCoverage['hits']
+    call s:SetSign(a:filename, l:line, 'hit')
+  endfor
+
+  for line in b:lineCoverage['misses']
+    call s:SetSign(a:filename, l:line, 'miss')
+  endfor
+
+  for line in b:lineCoverage['ignored']
+    call s:SetSign(a:filename, l:line, 'ignored')
+  endfor
+endfunction
+
+function! s:ClearCoverageSigns()
+  if(exists("b:coverageSigns"))
+    for signId in b:coverageSigns
+      exe ":sign unplace ".signId
+    endfor
+    unlet! b:coverageSigns
+  endif
+endfunction
+
+function! s:MarkUpBuffer(filepath)
+  let coverageFile = s:FindCoverageFile(a:filepath)
+
+  if(coverageFile == '')
+    echom "No coverage file"
+    return
+  endif
+
+  if(exists("b:coverageFtime") && getftime(coverageFile) <= b:coverageFtime)
+    "Coverage already done"
+    return
+  endif
+
+  if(&modified)
+    echom "Buffer modified - coverage signs would likely be wrong"
+    return
+  endif
+
+  if(getftime(a:filepath) > getftime(coverageFile))
+    echom "Code file is newer that coverage file - signs would likely be wrong"
+    return
+  endif
+
+  call s:LoadFileCoverage(a:filepath, l:coverageFile)
+  call s:ClearCoverageSigns()
+  call s:SetCoverageSigns(a:filepath)
+endfunction
+
+let s:filename = expand("<sfile>")
+function! s:AutocommandUncov(sourced)
+  if(a:sourced == s:filename)
+    call s:ClearCoverageSigns(expand("%:p"))
+  endif
+endfunction
+
+command! -nargs=0 Cov call s:CoverageSigns(expand("%:p"))
+command! -nargs=0 Uncov call s:ClearCoverageSigns(expand("%:p"))
+
+augroup SimpleCov
+  au!
+  au BufWinEnter *.rb call s:MarkUpBuffer(expand('<afile>:p'))
+augroup end

data/default_files/templates/rspec-config

@@ -0,0 +1,7 @@
+require 'cadre/rspec'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.add_formatter(Cadre::RSpec::NotifyOnCompleteFormatter)
+  config.add_formatter(Cadre::RSpec::QuickfixFormatter)
+end

data/default_files/templates/simplecov-config

@@ -0,0 +1,9 @@
+require 'cadre/simplecov'
+
+#SimpleCov.start 'rails' do #if, you know: Rails.
+SimpleCov.start do
+  formatter SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Cadre::SimpleCov::VimFormatter
+  ]
+end

data/lib/cadre/command-line.rb

@@ -0,0 +1,39 @@
+require 'thor'
+require 'cadre/valise'
+
+module Cadre
+  class CommandLine < Thor
+    desc "how_to", "Short guide on usage"
+    def how_to
+      command_name = File::basename($0)
+      puts <<-EOH
+      This is a set of tools for aiding development - to integrate testing and
+      metrics with editors and notifications.
+
+      Try:
+      #{command_name} vim_plugin > ~/.vim/plugin/cadre.vim
+      #{command_name} rspec_config >> spec/spec_helper.rb
+      #{command_name} simplecov_config >> .simplecov
+
+      Yeah, that's three commands, and you have to do the redirects yourself,
+      but you can review the output before making it live, and put them
+      somewhere else if that's what you want.
+      EOH
+    end
+
+    desc "vim_plugin", "Outputs plugin for vim"
+    def vim_plugin
+      puts Valise.find("templates/plugin.vim").contents
+    end
+
+    desc "rspec_config","Outputs RSpec config"
+    def rspec_config
+      puts Valise.find("templates/rspec-config").contents
+    end
+
+    desc "simplecov_config", "Outputs Simplecov config"
+    def simplecov_config
+      puts Valise.find("templates/simplecov-config").contents
+    end
+  end
+end

data/lib/cadre/config.rb

@@ -0,0 +1,50 @@
+module Cadre
+  class Config
+    def initialize(valise, component)
+      @valise = valise
+      @component = component
+    end
+    attr_reader :valise, :component
+
+    def config_hash
+      valise.find("config.yaml").contents
+    end
+
+    def value_or_fail(value, common=true)
+      if common
+        config_hash.fetch(component, {}).fetch(value){config_hash.fetch(value)}
+      else
+        config_hash.fetch(component).fetch(value)
+      end
+    rescue KeyError
+      raise "Field not configurated: #{value}" #yep: configurated
+    end
+
+    def output_path
+      value_or_fail("output_path", false)
+    end
+
+    def verbose
+      !!value_or_fail("verbose")
+    end
+    alias verbose? verbose
+
+    def quiet
+      !verbose
+    end
+    alias quiet? quiet
+
+    def backtrace_pattern
+      Regexp.new(value_or_fail('backtrace_pattern'))
+    end
+
+    def backtrace_limit
+      value_or_fail('backtrace_limit')
+    end
+
+    def include_pending
+      !!value_or_fail('include_pending')
+    end
+    alias include_pending? include_pending
+  end
+end

data/lib/cadre/growl/notifier.rb

@@ -0,0 +1,27 @@
+module Cadre
+  module Growl
+    #XXXX This isn't going to work at all as is. Lifted from other code, as #ok
+    #hints toward a working adapter
+    class Notifier
+      def close
+        super
+        summary = summary_line example_count, failure_count, pending_count
+        if failure_count > 0
+          growlnotify "--image ./autotest/fail.png -p Emergency -m '#{summary}' -t 'Spec failure detected'" #ok
+        elsif pending_count > 0
+          growlnotify "--image ./autotest/pending.png -p High -m '#{summary}' -t 'Pending spec(s) present'" #ok
+        else
+          growlnotify "--image ./autotest/pass.png -p 'Very Low' -m '#{summary}' -t 'All specs passed'" #ok
+        end
+      end
+
+      def growlnotify str
+        system 'which growlnotify > /dev/null'
+        if $?.exitstatus == 0
+          system "growlnotify -n autotest #{str}"
+        end
+      end
+
+    end
+  end
+end

data/lib/cadre/libnotify/notifier.rb

@@ -0,0 +1,36 @@
+require 'cadre/valise'
+
+module Cadre
+  module Libnotify
+    class Notifier
+      def initialize
+        yield self if block_given?
+      end
+
+      attr_accessor :summary, :message, :sound, :expire_time, :app_name, :transient
+
+      def go
+        cmd = "notify-send #{options} \"#@summary\" \"#@message\""
+        %x[#{cmd}]
+        %x[paplay #{Valise.find(["sounds", sound]).full_path}]
+      end
+
+      def options
+        options = []
+        unless expire_time.nil?
+          options << "-t #@expire_time"
+        end
+
+        if transient
+          options << "-h \"byte:transient:1\""
+        end
+
+        unless app_name.nil?
+          options << "-a #@app_name"
+        end
+
+        options.join(" ")
+      end
+    end
+  end
+end

data/lib/cadre/rspec/notify-on-complete-formatter.rb

@@ -0,0 +1,43 @@
+require 'cadre/libnotify/notifier'
+
+rspec_pid = Process.pid
+at_exit do
+  if Process.pid == rspec_pid and not($!.nil? or $!.is_a?(SystemExit))
+    message =  "Exception:\n#{$!.inspect}\n#{Dir.pwd}"
+    Cadre::Libnotify::Notifier.new do |notifier|
+      notifier.summary = "Spec run exited unexpectedly"
+      notifier.message = message
+      notifier.expire_time = 5000
+      notifier.sound = "error"
+    end.go
+  end
+end
+
+module Cadre
+  module RSpec
+    class NotifyOnCompleteFormatter < ::RSpec::Core::Formatters::BaseFormatter
+      def notify_message(duration, example_count, failure_count, pending_count)
+        "Total duration: #{duration}\n Total: #{example_count}\n Failed: #{failure_count}\n Pending: #{pending_count}\n\nFinished at #{Time.now}"
+      end
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        notifier = Libnotify::Notifier.new
+        if duration < 20
+          notifier.transient = true
+          notifier.summary = "Finished spec run"
+          notifier.message = notify_message(duration, example_count, failure_count, pending_count)
+          notifier.sound = "failure" if failure_count > 0
+        else
+          notifier.summary = "Finished long spec run"
+          notifier.message = notify_message(duration, example_count, failure_count, pending_count)
+          if failure_count > 0
+            notifier.sound = "failure"
+          else
+            notifier.sound = "success"
+          end
+        end
+        notifier.go
+      end
+    end
+  end
+end

data/lib/cadre/rspec/quickfix.rb

@@ -0,0 +1,59 @@
+# !!! Lifted wholesale from
+# https://wincent.com/blog/running-rspec-specs-from-inside-vim
+require 'rspec/core/formatters/base_text_formatter'
+require 'cadre/config'
+
+module Cadre
+  module RSpec
+    class QuickfixFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+
+      # TODO: vim-side function for printing progress (if that's even possible)
+      #
+      def initialize(output)
+        super(output)
+        @config = Config.new(Valise, "quickfix")
+        @output = File::open(@config.output_path, "w")
+      end
+      attr_reader :config
+
+      def example_failed(example)
+        exception = example.execution_result[:exception]
+        paths = exception.backtrace.map do |frame|
+          format_caller frame
+        end.compact
+        paths = paths[0..config.backtrace_limit]
+        message = "#{example.full_description}: #{format_message exception.message}"
+        paths.each do |path|
+          output.puts "#{path}: [FAIL] #{message}"
+        end
+      end
+
+      def example_pending(example)
+        return unless config.include_pending?
+        message = format_message example.execution_result[:pending_message]
+        path    = format_caller example.location
+        output.puts "#{path}: [PEND] #{message}" if path
+      end
+
+      def dump_failures(*args); end
+
+      def dump_pending(*args); end
+
+      def message(msg); end
+
+      def dump_summary(duration, example_count, failure_count, pending_count)
+        @duration = duration
+        @example_count = example_count
+        @failure_count = failure_count
+        @pending_count = pending_count
+      end
+
+      private
+
+      def format_message(msg)
+        # NOTE: may consider compressing all whitespace here
+        msg.gsub("\n", ' ')[0,40]
+      end
+    end
+  end
+end

data/lib/cadre/rspec/true-feelings.rb

@@ -0,0 +1,9 @@
+class Uuu < RSpec::Core::Formatters::ProgressFormatter
+  def example_passed(example)
+    if @failed_examples.empty?
+      super
+    else
+      output.print red("u")
+    end
+  end
+end

data/lib/cadre/rspec.rb

@@ -0,0 +1,3 @@
+require 'cadre/rspec/notify-on-complete-formatter'
+require 'cadre/rspec/quickfix'
+require 'cadre/rspec/true-feelings'

data/lib/cadre/simplecov/vim-formatter.rb

@@ -0,0 +1,65 @@
+require 'fileutils'
+
+module Cadre
+  module SimpleCov
+    class VimFormatter
+      class << self
+        attr_accessor :options
+      end
+
+      def options
+        @options ||=
+          begin
+            require 'cadre/config'
+            require 'cadre/valise'
+            Config.new(Valise, "simplecov")
+          end
+      end
+
+      Scope = Struct.new(:results)
+
+      def format(result)
+        scope = Scope.new({})
+        dir_re = /^#{common_directory(result.filenames)}\//
+          result.filenames.zip(result.original_result.values_at(*result.filenames)).each do |name, lines|
+
+          scope.results[name.sub(dir_re, "")] = file_results = {:ignored => [], :hits => [], :misses => []}
+          lines.each_with_index do |hits, line|
+            case hits
+            when nil
+              file_results[:ignored] << line + 1
+            when 0
+              file_results[:misses] << line + 1
+            else
+              file_results[:hits] << line + 1
+            end
+          end
+          end
+
+        coverage_output = options.output_path
+
+        write_file("coverage-results.vim", coverage_output, scope)
+        puts "Wrote vim coverage script to #{coverage_output}" unless options.quiet?
+      end
+
+      def common_directory(files)
+        return "" if files.empty?
+        File::join(files.map{|file| file.split(File::Separator)}.inject do |dir, path|
+          dir.zip(path).take_while{|l,r| l == r}.map{|l,_| l}
+        end)
+      end
+
+      def templates
+        @templates ||= Valise.templates
+      end
+
+      def write_file(template_name, output_filename, bound)
+        FileUtils::mkdir_p(File::dirname(output_filename))
+        content = templates.find(template_name).contents.render(bound)
+        File.open( output_filename, "w" ) do |file_result|
+          file_result.write content
+        end
+      end
+    end
+  end
+end

data/lib/cadre/simplecov.rb

@@ -0,0 +1 @@
+require 'cadre/simplecov/vim-formatter'

data/lib/cadre/valise.rb

@@ -0,0 +1,17 @@
+require 'valise'
+
+module Cadre
+  def self.build_valise
+    Valise.define do
+      rw ".cadre"
+      rw "~/.cadre"
+      rw "/usr/share/cadre"
+      rw "/etc/cadre"
+      ro up_to("lib") + "/../default_files"
+
+      handle "*.yaml", :yaml, :hash_merge
+    end
+  end
+
+  Valise = build_valise
+end

data/spec/simplecov/formatter.rb

@@ -0,0 +1,43 @@
+require 'simplecov'
+require 'simplecov-vim/formatter'
+
+describe SimpleCov::Formatter::VimFormatter do
+  include FileSandbox
+
+  let :files do
+    sandbox.new :directory => "lib/nested"
+    [sandbox.new(:file => "lib/pretend_file"), sandbox.new(:file => "lib/nested/pretend_file")]
+  end
+
+  let :original_result do
+    files.each_with_object({}) do |file, hash|
+      hash[file.path] = [1,1,1,1]
+    end
+  end
+
+  let :result do
+    SimpleCov::Result.new(original_result)
+  end
+
+  let :formatter do
+    SimpleCov::Formatter::VimFormatter.new
+  end
+
+  it "should have an original result with absolute paths" do
+    original_result.keys.each do |path|
+      path.should =~ %r{\A/}
+    end
+  end
+
+  it "should produce a vimscript" do
+    formatter.format(result)
+    File::exists?("coverage.vim").should be_true
+
+
+    File::open("coverage.vim") do |scriptfile|
+      scriptfile.lines.grep(/(['"])pretend_file\1/).should_not == []
+      scriptfile.rewind
+      scriptfile.lines.grep(%r[(['"])nested/pretend_file\1]).should_not == []
+    end
+  end
+end

data/spec_help/gem_test_suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: cadre
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors:
+- Judson Lester
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  name: thor
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 0
+        - 18
+        - 1
+        version: 0.18.1
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 0
+        - 18
+        - 1
+        version: 0.18.1
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  name: tilt
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  name: valise
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 0
+        - 9
+        version: '0.9'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        segments:
+        - 0
+        - 9
+        version: '0.9'
+    none: false
+description: ! "  Three things:\n\n  An rspec formatter that triggers libnotify on
+  completion.\n  An rspec formatter that outputs to vim quickfix\n  A simplecov formatter
+  that produces vim markers (+ a vim plugin to load them)\n"
+email:
+- nyarly@gmail.com
+executables:
+- cadre
+extensions: []
+extra_rdoc_files: []
+files:
+- default_files/config.yaml
+- default_files/sounds/error
+- default_files/sounds/failure
+- default_files/sounds/success
+- default_files/templates/plugin.vim
+- default_files/templates/coverage-results.vim.erb
+- default_files/templates/simplecov-config
+- default_files/templates/rspec-config
+- lib/cadre/libnotify/notifier.rb
+- lib/cadre/growl/notifier.rb
+- lib/cadre/rspec.rb
+- lib/cadre/rspec/quickfix.rb
+- lib/cadre/rspec/notify-on-complete-formatter.rb
+- lib/cadre/rspec/true-feelings.rb
+- lib/cadre/config.rb
+- lib/cadre/command-line.rb
+- lib/cadre/valise.rb
+- lib/cadre/simplecov/vim-formatter.rb
+- lib/cadre/simplecov.rb
+- bin/cadre
+- spec/simplecov/formatter.rb
+- spec_help/gem_test_suite.rb
+homepage: http://nyarly.github.com/cadre
+licenses:
+- MIT
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- cadre-0.0.1 Documentation
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 743147407
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: cadre
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tools to smooth development
+test_files:
+- spec_help/gem_test_suite.rb