count_von_count 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5331c0ef8cfb1d8c62ff892e0b7550a28feb0ceb
+  data.tar.gz: 4c92fe24c97ab6968d43543720680a0367ae0f34
+SHA512:
+  metadata.gz: bf51c9b84c749649c8efa7ca0b54c66ca990ebaa43f9662d166c1dedc8c47a7aafc9bb4992f27a969e52b57102f48c1189d23a8b39a01228ab8a3c8a7fc701da
+  data.tar.gz: 5517603051d82ae5ee683daf60910bcf9cecd4aaf4c10ede3045fc5cae7755a56aca681bbe5bce678c5f0c579fb64355bba2311135097a573a8d3ee5e012f79e

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+*.bundle
+coverage/
+

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    count_von_count (0.0.1)
+      terminal-table
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    docile (1.1.5)
+    method_source (0.8.2)
+    multi_json (1.10.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rs (35)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    terminal-table (1.4.5)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  count_von_count!
+  pry
+  rake
+  rs
+  simplecov

data/README.md

@@ -0,0 +1,48 @@
+#Count Von Count
+
+![The Count](http://img2.wikia.nocookie.net/__cb20060205225316/muppet/images/3/3c/CT-p0001-ST.jpg)
+
+1! 2! 3! Ah Ah Ah
+
+Count your lines of code and love it
+
+## What it is
+`rake stats` and other similiar line counters are rails specific, this counts lines based on a given glob
+and support proper counting for ruby, js, and coffee
+
+It supports mutliple output formats including json and yaml.
+
+### To Install
+```
+gem install count_von_count
+```
+
+Or Gemfile, or whatever
+
+### Docs
+
+```Bash
+count_von_count count /path/to/dir
+#or
+cd /path/to/dir
+count_von_count
+```
+
+#### Options
+By default, when you point to a project, it will count all the code in default set of directories:
+
+- app/\*\*/\*.rb
+- lib/\*\*/\*.rb
+
+And tests in:
+
+- spec/\*\*/\*\_spec.rb
+
+If you don't want to include these paths, you can pass `--no_default` and add a list of custom paths
+using `-c` for code paths and `-t` for test paths. These paths are given relative to the project
+directory.
+
+If you want to output in a different format other than text, pass `-f {yaml,json}` to get what you want.
+
+If you want to write the files out to a directory (instead of stdout), pass `-o` with a path and
+it will end up in a file called results.txt (or whatever format you choose)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/count_von_count

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'count_von_count/cli'
+CountVonCount::CLI.start

data/count_von_count.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'count_von_count/version'
+
+Gem::Specification.new do |s|
+  s.name        = "count_von_count"
+  s.version     = CountVonCount::VERSION
+  s.authors     = ["Addison Higham"]
+  s.email       = "ahigham@instructure.com"
+  s.homepage    = "http://github.com/addisonj/count_von_count"
+  s.summary     = "Count lines of code and report it"
+  s.description = "Count lines of code with granularity and output it various formats"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = `git ls-files -z`.split("\x0")
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_dependency 'thor'
+  s.add_dependency 'terminal-table'
+
+  s.add_development_dependency "bundler", "~> 1.6"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rs"
+  s.add_development_dependency "simplecov"
+
+  s.license = 'MIT'
+end

data/lib/count_von_count/cli.rb

@@ -0,0 +1,44 @@
+require 'thor'
+require 'count_von_count'
+
+module CountVonCount
+
+  class CLI < Thor
+
+    desc "count PATH", "count the number of lines of code"
+    long_desc <<-DESC
+      By default, when you point to a project, it will count all the code in default set of directories:
+
+        - app/**/*.rb
+
+        - lib/**/*.rb
+
+      And tests in:
+
+        - spec/**/*_spec.rb
+
+      If you don't want to include these paths, you can pass --no_default and add a list of custom paths
+      using `-c` for code paths and `-t` for test paths. These paths are given relative to the project
+      directory.
+
+      If you want to output in a different format other than text, pass `-f {yaml,json}` to get what you want.
+
+      If you want to write the files out to a directory (instead of stdout), pass -o with a path and
+      it will end up in a file called results.txt (or whatever format you choose)
+
+    DESC
+
+    option :code, type: :array, aliases: :c, desc: "A list of relative code paths to include"
+    option :test, type: :array, aliases: :t, desc: "A list of relative test paths to include"
+    option :no_default, type: :boolean, aliases: :n, desc: "Don't include default paths", default: false
+    option :format, type: :string, aliases: :f, desc: "The format to output to, valid are yaml,json,txt", default: :txt
+    option :outout, type: :string, aliases: :o, desc: "A directory to write the results to"
+
+    def count(path=Dir.pwd)
+      CountVonCount.new(path, options[:code], options[:test], options[:no_default], options[:format].to_sym, options[:output]).run
+    end
+
+    default_task :count
+  end
+
+end

data/lib/count_von_count/counter.rb

@@ -0,0 +1,60 @@
+module CountVonCount
+
+  class Counter
+    attr_accessor :path, :code_paths, :test_paths, :formatter
+
+    def initialize(path, code_paths, test_paths, formatter)
+      @path = path
+      @formatter = formatter
+      @code_paths = expand_globs(code_paths)
+      raise "No files found in globs" if @code_paths.empty?
+      @test_paths = expand_globs(test_paths)
+    end
+
+    def expand_globs(globs)
+      Dir.chdir(@path) do
+        globs.flat_map do |g|
+          Pathname.glob(g).reject{|f| f.directory? }.map(&:realpath)
+        end
+      end
+    end
+
+    def run
+      results = {}
+      results[:code] = process_files(code_paths)
+      results[:tests] = process_files(test_paths) unless test_paths.empty?
+      formatter.write_output(results)
+    end
+
+    def process_files(files)
+      files_by_dir = files.group_by(&:dirname)
+      all_stats = []
+      by_dir = {}
+      by_file = {}
+      files_by_dir.each do |dir, dir_files|
+        stats_for_dir = []
+        dir_files.each do |file|
+          stat = Stat.new
+          stat.process(file)
+          unless stat.empty?
+            by_file[rel_path(file)] = stat.to_h
+            stats_for_dir.push(stat)
+            all_stats.push(stat)
+          end
+        end
+        dir_sum = Stat.sum(stats_for_dir)
+        by_dir[rel_path(dir)] = dir_sum.to_h unless dir_sum.empty?
+      end
+      total = Stat.sum(all_stats).to_h
+      {total: total, by_dir: sort_by_loc(by_dir), by_file: sort_by_loc(by_file)}
+    end
+
+    def sort_by_loc(hash)
+      hash.sort_by { |_k, stat| stat[:loc] }.reverse.to_h
+    end
+
+    def rel_path(p)
+      Pathname.new(p).relative_path_from(@path).to_s
+    end
+  end
+end

data/lib/count_von_count/formatter.rb

@@ -0,0 +1,84 @@
+require "yaml"
+require "json"
+require "terminal-table"
+module CountVonCount
+  module Formatters
+    class Base
+      attr_reader :path
+      attr_reader :output_dir
+      def initialize(path, output = nil)
+        @path = path
+        @output_dir = output
+      end
+
+      def write_output(countObj)
+        formatted = serialize(countObj)
+        if output_dir
+          write_file(formatted)
+        else
+          write_stdout(formatted)
+        end
+      end
+
+      private
+      def write_file(formatted)
+        output_file = path.join(output_dir).join("results.#{extension}")
+        output_file.open("w") do |f|
+          f << formatted
+        end
+      end
+
+      def write_stdout(formatted)
+        puts formatted
+      end
+
+      def extension
+        raise 'Must extend this method'
+      end
+      def serialize(countObj)
+        raise 'Must extend this method'
+      end
+    end
+    class Text < Base
+      def extension
+        "txt"
+      end
+      def serialize(countObj)
+        output = build_table("Code", countObj[:code]).to_s
+        output += "\n\n"
+        output += build_table("Tests", countObj[:tests]).to_s
+        output
+      end
+      def build_table(name, countObj)
+        head = [""] + countObj[:total].keys.map(&:to_s)
+        rows = []
+        rows << ["total"] + countObj[:total].values
+        rows << :separator
+        rows << [{value: "By Dir", colspan: 7, align: :center}]
+        rows << :separator
+        rows.push *countObj[:by_dir].map{ |d, v| [d] + v.values }
+        rows << :separator
+        rows << [{value: "By File", colspan: 7, align: :center}]
+        rows << :separator
+        rows.push *countObj[:by_file].map{ |f, v| [f] + v.values }
+        Terminal::Table.new title: name, headings: head, rows: rows
+      end
+    end
+    class Json < Base
+      def extension
+        "json"
+      end
+      def serialize(countObj)
+        countObj.to_json
+      end
+    end
+    class Yaml < Base
+      def extension
+        "yaml"
+      end
+      def serialize(countObj)
+        countObj.to_yaml
+      end
+    end
+  end
+end

data/lib/count_von_count/stat.rb

@@ -0,0 +1,115 @@
+module CountVonCount
+  class Stat
+     PATTERNS = {
+      rb: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^=begin/,
+        end_block_comment: /^=end/,
+        class:  /^\s*class\s+[_A-Z]/,
+        module: /^\s*module\s+[_A-Z]/,
+        method: /^\s*def\s+[_a-z]/,
+      },
+      js: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      coffee: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^\s*###/,
+        end_block_comment: /^\s*###/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /[-=]>/,
+      }
+    }
+
+    def self.get_pattern(type)
+      return PATTERNS[type]
+    end
+
+    def self.sum(stats)
+      stats.reduce(Stat.new) do |prev, val|
+        prev + val
+      end
+    end
+
+    VALS = %i(all loc methods modules classes comments)
+    attr_accessor *VALS
+    def initialize(all = 0, loc = 0, methods = 0, modules = 0, classes = 0, comments = 0)
+      @all = all
+      @loc = loc
+      @methods = methods
+      @modules = modules
+      @classes = classes
+      @comments = comments
+    end
+
+    def + (other)
+      r = self.class.new
+      VALS.each do |v|
+        r.send("#{v.to_s}=", (self.send(v) + other.send(v)))
+      end
+      r
+    end
+
+    def == (other)
+      VALS.each do |v|
+        return false if self.send(v) != other.send(v)
+      end
+      true
+    end
+
+    def process(file)
+      File.open(file) do |io|
+        ft = file_type(file)
+        patterns = PATTERNS[ft] || {}
+        process_io(io, patterns)
+      end
+    end
+
+    def process_io(io, patterns)
+      comment_started = false
+
+      while line = io.gets
+        @all += 1
+
+        if comment_started
+          @comments += 1
+          if patterns[:end_block_comment] && line =~ patterns[:end_block_comment]
+            comment_started = false
+          end
+          next
+        else
+          if patterns[:begin_block_comment] && line =~ patterns[:begin_block_comment]
+            @comments += 1
+            comment_started = true
+            next
+          end
+        end
+
+        @classes   += 1 if patterns[:class] && line =~ patterns[:class]
+        @methods   += 1 if patterns[:method] && line =~ patterns[:method]
+        @modules   += 1 if patterns[:module] && line =~ patterns[:module]
+        if (patterns[:line_comment] && line =~ patterns[:line_comment])
+          @comments += 1
+        elsif line !~ /^\s*$/
+          @loc += 1
+        end
+      end
+    end
+
+
+    def to_h
+      {all: all, loc: loc, methods: methods, modules: modules, classes: classes, comments: comments}
+    end
+
+    def file_type(file_path)
+      File.extname(file_path).sub(/\A\./, '').downcase.to_sym
+    end
+
+    def empty?
+      loc == 0
+    end
+  end
+end

data/lib/count_von_count/version.rb

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

data/lib/count_von_count.rb

@@ -0,0 +1,40 @@
+require 'pathname'
+require_relative "count_von_count/counter"
+require_relative "count_von_count/stat"
+require_relative "count_von_count/formatter"
+module CountVonCount
+  def self.new(path, code_paths=nil, test_paths=nil, no_default=false, format=:txt, output = nil)
+    code_paths = code_paths || []
+    test_paths = test_paths || []
+    path = Pathname.new(path).realpath
+    unless no_default
+      code_paths = default_code_paths + code_paths
+      test_paths = default_test_paths + test_paths
+    end
+    raise "No code paths given" if code_paths.empty?
+
+    formatter = formatters[format].new(path, output)
+    CountVonCount::Counter.new(path, code_paths, test_paths, formatter)
+  end
+
+  def self.default_code_paths
+    return [
+      "app/**/*.rb",
+      "lib/**/*.rb"
+    ]
+  end
+
+  def self.default_test_paths
+    return [
+      "spec/**/*_spec.rb"
+    ]
+  end
+
+  def self.formatters
+    {
+      txt: CountVonCount::Formatters::Text,
+      json: CountVonCount::Formatters::Json,
+      yaml: CountVonCount::Formatters::Yaml
+    }
+  end
+end

data/spec/counter_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+def fp(p)
+  Pathname.new(fixture_path).join(p)
+end
+describe CountVonCount::Counter do
+  let(:formatter) do
+    MockFormatter.new
+  end
+  let(:code_glob) do
+    ["app/**/*.rb"]
+  end
+  let(:counter) do
+    return CountVonCount::Counter.new(fixture_path, code_glob, [], formatter)
+  end
+
+  let(:counter_test) do
+    return CountVonCount::Counter.new(fixture_path, code_glob, code_glob, formatter)
+  end
+
+  describe "#expand_globs" do
+    it "should expand the list of files to include the ones we expect" do
+      expect(counter.expand_globs(code_glob)).to eq [fp("app/controllers/test_controller.rb"), fp("app/models/foo.rb"), fp("app/models/test.rb")]
+    end
+  end
+
+  describe "#run" do
+    it "should try to output a hash in the format we expect" do
+      allow(formatter).to receive(:write_output) do |output|
+        %i(total by_dir by_file).each do |k|
+          expect(output[:code]).to have_key(k)
+        end
+        %w(app/models app/controllers).each do |d|
+          expect(output[:code][:by_dir]).to have_key(d)
+        end
+        %w(app/models/test.rb app/models/test.rb app/controllers/test_controller.rb).each do |d|
+          expect(output[:code][:by_file]).to have_key(d)
+        end
+      end
+      counter.run
+    end
+
+    it "shouldn't have a test section if no tests" do
+      allow(formatter).to receive(:write_output) do |output|
+        expect(output[:test]).to be_nil
+      end
+      counter.run
+    end
+
+    it "should have a test section if there are tests" do
+      allow(formatter).to receive(:write_output) do |output|
+        expect(output[:tests]).to be_truthy
+      end
+      counter_test.run
+    end
+  end
+end

data/spec/fixture/app/controllers/test_controller.rb

@@ -0,0 +1,7 @@
+class TestController < ApplicationController
+  def index
+  end
+
+  def module
+  end
+end

data/spec/fixture/app/models/foo.rb

@@ -0,0 +1,2 @@
+class Foo < ActiveRecord::Base
+end

data/spec/fixture/app/models/test.rb

@@ -0,0 +1,11 @@
+class Test < ActiveRecord::Base
+
+  include FriendlyId
+  friendly_id :name
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  alias_method :to_param, :friendly_id
+
+end

data/spec/fixture/js/test.js

@@ -0,0 +1,12 @@
+// line comment
+function test() {
+}
+
+/*
+ * block comment
+ */
+
+var stuff = 'foo'
+;(function() {
+  console.log(stuff)
+})()

data/spec/fixture/test.rb

@@ -0,0 +1,26 @@
+module FooModule
+  class FooClass
+    def one
+      x = 4 + 2
+      y = 6 + 8
+    end
+    def two
+    end
+    # one comment
+    # another comment
+    # def a_comment
+
+    STUFF = 'foo'
+
+=begin
+4
+lines here
+=end
+
+  class SubClass
+    def stuff
+    end
+  end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+
+SimpleCov.start
+
+def fixture_path
+  Pathname.new(__FILE__).dirname.join("./fixture").realpath
+end
+
+require 'rubygems'
+require 'rspec'
+require 'count_von_count'
+
+class MockFormatter < CountVonCount::Formatters::Base
+  def initialize
+  end
+  def write_output(obj)
+  end
+end

data/spec/stat_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+Stat = CountVonCount::Stat
+
+def stat_num(n)
+  Stat.new(*Array.new(6, n))
+end
+
+CONTENTS = <<-CON
+module Thing
+  class Foo
+    # comment
+    def stuff
+    end
+    def other
+      4 + 4
+    end
+=begin
+one
+two
+=end
+  end
+end
+
+CON
+
+describe Stat do
+  let(:stat) do
+    return Stat.new
+  end
+
+  describe "#initialize" do
+    it "should initiliaze to empty values" do
+      %i(all loc methods modules classes comments).each do |val|
+        expect(stat.send(val)).to eq(0)
+      end
+    end
+  end
+
+  describe "#+" do
+    it "should add together two stats to create a new stat" do
+      expect(stat_num(1) + stat_num(2)).to eq(stat_num(3))
+    end
+  end
+
+  describe "::sum" do
+    it "should sum an array of stats" do
+      stats = (1..4).map{ |n| stat_num(n) }
+      sum = (1..4).reduce(:+)
+      expect(Stat.sum(stats)).to eq(stat_num(sum))
+    end
+  end
+
+  describe "#parse_by_io" do
+    it "should parse a file and updates its numbers" do
+      vals = {
+        all: 15,
+        loc: 9,
+        methods: 2,
+        modules: 1,
+        classes: 1,
+        comments: 5
+      }
+
+      stat.process_io(StringIO.new(CONTENTS), Stat.get_pattern(:rb))
+      vals.each do |k, v|
+        expect(stat.send(k)).to eq(v), "expect #{k} to equal #{v} got #{stat.send(k)}"
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: count_von_count
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Addison Higham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Count lines of code with granularity and output it various formats
+email: ahigham@instructure.com
+executables:
+- count_von_count
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/count_von_count
+- count_von_count.gemspec
+- lib/count_von_count.rb
+- lib/count_von_count/cli.rb
+- lib/count_von_count/counter.rb
+- lib/count_von_count/formatter.rb
+- lib/count_von_count/stat.rb
+- lib/count_von_count/version.rb
+- spec/counter_spec.rb
+- spec/fixture/app/controllers/test_controller.rb
+- spec/fixture/app/models/foo.rb
+- spec/fixture/app/models/test.rb
+- spec/fixture/js/test.js
+- spec/fixture/test.rb
+- spec/spec_helper.rb
+- spec/stat_spec.rb
+homepage: http://github.com/addisonj/count_von_count
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Count lines of code and report it
+test_files: []
+has_rdoc: