abcing 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43744baaa2fe4138222d3ea2808e94658983a85e
+  data.tar.gz: 45d5010f1b3b3d2a597d0ecac85b17c5005918ce
+SHA512:
+  metadata.gz: 5738aeb756c8e9009cd3ba43be511476b1b22bae652fec8fce779263588c2a2e7f548cbcbb037d08345ce689fa421d0d02d72dc7f51cbdd4753e8dc806079ef0
+  data.tar.gz: a97b72cac034dfa1d7d6f1744f966cd470da570fad89bac6ce673913228469a5c91f873fa0c40e914020c6001367dbab5e89819dbaef6c4018928b33eb6b9f24

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Emile
+
+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,47 @@
+# ABCing
+
+ ![alt tag](https://s3-eu-west-1.amazonaws.com/abcing/coverage.png)
+
+Dumbed down automated test coverage metrics.
+Checks your working directory for class names, and tries to match them in the test directories.
+
+The way this works is:
+
+If it finds a matching class name in one of your test directories, you get a green result.
+If it finds a class name in the working directory but not in the test directory, it is printed in red.
+Other letters (not present in your working directory or test directories) are printed in yellow.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'abcing'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install abcing
+
+## Usage
+
+abcing /path/to/project/root
+
+Currently this only considers app/ and lib/ for the scan.
+It will check spec/ and features/ for matching class names found in the working directory.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/abcing/fork )
+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 a new Pull Request
+
+## TODO
+
+1. check for presence of config file for scan params

data/Rakefile

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

data/abcing.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'abcing/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "abcing"
+  spec.version       = Abcing::VERSION
+  spec.authors       = ["Emile"]
+  spec.email         = ["emile.swarts123@gmail.com"]
+  spec.summary       = %q{Dumb code metrics}
+  spec.description   = %q{See coverage by alphabet}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ['abcing']
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+end

data/bin/abcing

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'abcing'
+
+working_directory = ARGV[0] || Dir.pwd
+
+ABCing::Runner.new(working_directory).run

data/lib/abcing.rb

@@ -0,0 +1,50 @@
+require 'abcing/alphabet_match'
+require 'abcing/class_file_finder'
+require 'abcing/class_name_finder'
+require 'abcing/colour_alphabet_result'
+require 'abcing/renderer'
+require 'abcing/scanner'
+require 'abcing/version'
+
+module ABCing
+  class Runner
+    def initialize(working_dir)
+      @working_dir = working_dir
+    end
+
+    def run
+      app_directories = ["#{@working_dir}/app", "#{@working_dir}/lib"]
+      test_directories = ["#{@working_dir}/spec", "#{@working_dir}/features"]
+
+      params = {
+        app_directories: app_directories,
+        test_directories: test_directories }
+
+      scan_results = ABCing::Scanner.new(params).results
+
+      ABCing::Renderer.new(scan_results).render
+    end
+  end
+end
+
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def pink
+    colorize(35)
+  end
+end

data/lib/abcing/alphabet_match.rb

@@ -0,0 +1,17 @@
+module ABCing
+  class AlphabetMatch
+    def initialize(class_names)
+      @class_names = class_names
+    end
+
+    def letters
+      class_letters.flatten.sort.uniq
+    end
+
+    private
+
+    def class_letters
+      @class_names.map { |c| c[0] }
+    end
+  end
+end

data/lib/abcing/class_file_finder.rb

@@ -0,0 +1,29 @@
+module ABCing
+  class ClassFileFinder
+    def initialize(directories = ['.'])
+      @target_directories = directories
+    end
+
+    def find
+      @target_directories.collect do |dir|
+        matching_files(dir)
+      end.flatten
+    end
+
+    private
+
+    def matching_files(directory)
+      files_for_directory(directory).select do |f|
+        is_class_file? f
+      end
+    end
+
+    def is_class_file?(file)
+      File.read(file).include?('class ')
+    end
+
+    def files_for_directory(directory)
+      Dir["#{directory}/**/*.rb"]
+    end
+  end
+end

data/lib/abcing/class_name_finder.rb

@@ -0,0 +1,11 @@
+module ABCing
+  class ClassNameFinder
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def find
+      @contents.collect { |c| c.scan(/class (\w+).*$/).flatten.uniq }.flatten.uniq
+    end
+  end
+end

data/lib/abcing/colour_alphabet_result.rb

@@ -0,0 +1,35 @@
+module ABCing
+  class ColourAlphabetResult
+    def initialize(params)
+      @test_letters = params.fetch(:test_letters)
+      @app_letters = params.fetch(:app_letters)
+      @alphabet = ('A'..'Z').to_a
+    end
+
+    def calculate
+      results = {}
+
+      @alphabet.each do |a|
+        results[a.to_sym] = colour(a)
+      end
+
+      results
+    end
+
+    def colour(letter)
+      return :green if test_letter_covered?(letter)
+
+      return :red if test_letter_not_covered?(letter)
+
+      :yellow
+    end
+
+    def test_letter_covered?(letter)
+      @app_letters.include?(letter) and @test_letters.include?(letter)
+    end
+
+    def test_letter_not_covered?(letter)
+      @app_letters.include?(letter) and !@test_letters.include?(letter)
+    end
+  end
+end

data/lib/abcing/renderer.rb

@@ -0,0 +1,32 @@
+module ABCing
+  class Renderer
+    def initialize(scan_results)
+      p scan_results
+      @alphabet = ('A'..'Z').to_a
+      @scan_results = scan_results
+    end
+
+    def render
+      puts report
+    end
+
+    private
+
+    def report
+      coloured_letters.map do |coloured_letter, colour|
+        coloured_letter.to_s.send(colour)
+      end.join(' ')
+    end
+
+    def coloured_letters
+      test_letters = @scan_results.fetch(:test_letter_matches)
+      app_letters = @scan_results.fetch(:app_letter_matches)
+
+      params = {
+        test_letters: test_letters,
+        app_letters: app_letters }
+
+      ABCing::ColourAlphabetResult.new(params).calculate
+    end
+  end
+end

data/lib/abcing/scanner.rb

@@ -0,0 +1,52 @@
+module ABCing
+  class Scanner
+    def initialize(params)
+      @app_directories = params.fetch(:app_directories)
+      @test_directories = params.fetch(:test_directories)
+    end
+
+    def results
+      test_classes = []
+
+      app_class_names.each do |a|
+        @test_directories.each do |t|
+          entries = test_class_names(a)
+          test_classes << entries unless entries.empty?
+        end
+      end
+
+      { test_letter_matches: first_letters(test_classes.flatten.uniq),
+        app_letter_matches: first_letters(app_class_names) }
+    end
+
+    private
+
+    def test_class_names(app_class_name)
+      contents(test_files).collect { |e| e.scan(/^.*(#{app_class_name}).*$/) }.flatten
+    end
+
+    def app_class_names
+      class_names contents(files @app_directories)
+    end
+
+    def contents(files)
+      files.collect { |f| File.read(f) }
+    end
+
+    def test_files
+      @test_directories.collect { |dir| Dir["#{dir}/**/*.rb"] }.flatten
+    end
+
+    def files(directories)
+      ABCing::ClassFileFinder.new(directories).find
+    end
+
+    def class_names(file_contents)
+      ABCing::ClassNameFinder.new(file_contents).find
+    end
+
+    def first_letters(class_names)
+      ABCing::AlphabetMatch.new(class_names).letters
+    end
+  end
+end

data/lib/abcing/version.rb

@@ -0,0 +1,3 @@
+module Abcing
+  VERSION = "0.0.1"
+end

data/spec/alphabet_match_spec.rb

@@ -0,0 +1,35 @@
+
+require_relative '../lib/abcing/alphabet_match'
+
+describe ABCing::AlphabetMatch do
+  before(:each) do
+    Dir.mkdir 'dummy'
+  end
+
+  after(:each) do
+    FileUtils.rm_rf 'dummy'
+  end
+
+  it 'collects 2 letters' do
+    class_names = ['Bar', 'Foo']
+    matcher = ABCing::AlphabetMatch.new(class_names)
+
+    expect(matcher.letters).to eq(['B', 'F'])
+  end
+
+  it 'Only collects unique letters' do
+    class_names = ['Zoo', 'Zebra']
+
+    matcher = ABCing::AlphabetMatch.new(class_names)
+
+    expect(matcher.letters).to eq(['Z'])
+  end
+
+  it 'Orders letter results alphabetically' do
+    class_names = ['Cobra', 'Acid', 'Bee']
+
+    matcher = ABCing::AlphabetMatch.new(class_names)
+
+    expect(matcher.letters).to eq(['A', 'B', 'C'])
+  end
+end

data/spec/class_file_finder_spec.rb

@@ -0,0 +1,47 @@
+require 'fileutils'
+require 'abcing/class_file_finder'
+
+describe ABCing::ClassFileFinder do
+  before(:each) do
+    Dir.mkdir 'dummy'
+    out_file = File.new("dummy/foo.rb", "w")
+    out_file.puts("class Foo; end;")
+    out_file.close
+
+    out_file = File.new("dummy/bar.rb", "w")
+    out_file.puts("class Foo; end;")
+    out_file.close
+  end
+
+  after(:each) do
+    FileUtils.rm_rf 'dummy'
+  end
+
+  context 'Included files' do
+    it 'Finds files with class defined in them' do
+      expected_results = [
+        'dummy/bar.rb',
+        'dummy/foo.rb',
+      ]
+
+      finder = ABCing::ClassFileFinder.new(['dummy'])
+      expect(finder.find).to eq(expected_results)
+    end
+  end
+
+  context 'Excluded files' do
+    it 'that do not have a .rb extension' do
+      out_file = File.new("dummy/foo_config.txt", "w")
+      out_file.puts("class FooConfig; end;")
+      out_file.close
+
+      expected_results = [
+        'dummy/bar.rb',
+        'dummy/foo.rb',
+      ]
+
+      finder = ABCing::ClassFileFinder.new(['dummy'])
+      expect(finder.find).to eq(expected_results)
+    end
+  end
+end

data/spec/class_name_finder_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../lib/abcing/class_name_finder.rb'
+
+describe ABCing::ClassNameFinder do
+  it 'produces class names from string input' do
+    content = ['class Something; end']
+    finder = ABCing::ClassNameFinder.new(content)
+    expect(finder.find).to eq(['Something'])
+  end
+
+  it 'Only finds unique class names' do
+    content = ['class Something; end
+    class Something; end']
+    finder = ABCing::ClassNameFinder.new(content)
+    expect(finder.find).to eq(['Something'])
+  end
+end

data/spec/colour_alphabet_result_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../lib/abcing/colour_alphabet_result.rb'
+
+describe ABCing::ColourAlphabetResult do
+  it 'finds tested class letters' do
+    params = {
+      test_letters: ['A', 'B'],
+      app_letters: ['A', 'B']
+    }
+
+    result = ABCing::ColourAlphabetResult.new(params).calculate
+    expect(result).to include(A: :green, B: :green)
+  end
+
+  it 'does not find a test for a class letter' do
+    params = {
+      test_letters: ['A'],
+      app_letters: ['A', 'B']
+    }
+
+    result = ABCing::ColourAlphabetResult.new(params).calculate
+    expect(result).to include(A: :green, B: :red)
+  end
+
+  it 'does not find an application class or test class from the letter of the alphabet' do
+    params = {
+      test_letters: [],
+      app_letters: []
+    }
+
+    result = ABCing::ColourAlphabetResult.new(params).calculate
+    expect(result).to include(A: :yellow, B: :yellow)
+  end
+
+
+end

data/spec/renderer_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/abcing/renderer'
+
+describe ABCing::Renderer do
+  it '#render' do
+    scan_results = {
+      test_letter_matches: ["A", "B"],
+      app_letter_matches: ["A", "C"] }
+
+    ABCing::Renderer.new(scan_results).render
+  end
+end

data/spec/scan_result_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/abcing/scanner.rb'
+
+describe ABCing::Scanner do
+  it 'scans' do
+    params = { app_directories: [], test_directories: [] }
+    scanner = ABCing::Scanner.new(params)
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: abcing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Emile
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: See coverage by alphabet
+email:
+- emile.swarts123@gmail.com
+executables:
+- abcing
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- abcing.gemspec
+- bin/abcing
+- lib/abcing.rb
+- lib/abcing/alphabet_match.rb
+- lib/abcing/class_file_finder.rb
+- lib/abcing/class_name_finder.rb
+- lib/abcing/colour_alphabet_result.rb
+- lib/abcing/renderer.rb
+- lib/abcing/scanner.rb
+- lib/abcing/version.rb
+- spec/alphabet_match_spec.rb
+- spec/class_file_finder_spec.rb
+- spec/class_name_finder_spec.rb
+- spec/colour_alphabet_result_spec.rb
+- spec/renderer_spec.rb
+- spec/scan_result_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dumb code metrics
+test_files:
+- spec/alphabet_match_spec.rb
+- spec/class_file_finder_spec.rb
+- spec/class_name_finder_spec.rb
+- spec/colour_alphabet_result_spec.rb
+- spec/renderer_spec.rb
+- spec/scan_result_spec.rb