fukuzatsu 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9049fb6f92f869e6d799c87e622079d696eb8f7b
+  data.tar.gz: 7e75d3585e1b60d3d557dec69d74afa14393b8f4
+SHA512:
+  metadata.gz: f3f8382ccb36cc0acbf279213e59d38b3838279d66427a78be19ececa27ccb8b328e966c0990f43fd28bed8adeec8e418343661eb723c69a85e7c3fe85fc797b
+  data.tar.gz: 5c98337d7d5654c973fe0281802fd53f96569625bc8015bbb1ac904d0c3e3eb2c242023f466625b6181943a9cef7fedd8d3ec5a552053493d51401f540e886fc

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.console_history

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fukuzatsu.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Bantik
+
+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,29 @@
+# Fukuzatsu
+
+Fukuzatsu ("complexity") is a tool for measuring code complexity. Its analysis is based on a cycomatic complexity algorithm.
+
+You can learn more about cyclomatic complexity at http://en.wikipedia.org/wiki/Cyclomatic_complexity
+
+Why should you care about this kind of complexity? More complex code tends to attract bugs and to increase the friction around extending features or refactoring code.
+
+Fukuzatsu was inspired by Saikuro, written by Zev Blut.
+
+## Installation
+
+Install the gem:
+
+    $ gem install fukuzatsu
+
+This installs the CLI tool.
+
+## Usage
+
+    fuku parse path/to/file/my_file.rb
+
+## Contributing
+
+1. Fork it
+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

data/Rakefile

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

data/bin/fuku

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

data/fukuzatsu.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fukuzatsu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fukuzatsu"
+  spec.version       = Fukuzatsu::VERSION
+  spec.authors       = ["Bantik"]
+  spec.email         = ["coraline@idolhands.com"]
+  spec.summary       = "A simple code complexity analyzer."
+  spec.description   = "Calculates the cyclomatic complexity of methods within a given file."
+  spec.homepage      = "https://gitlab.com/coraline/fukuzatsu"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "require_all"
+  spec.add_dependency "ephemeral"
+  spec.add_dependency "poro_plus"
+  spec.add_dependency "haml"
+  spec.add_dependency "parser"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "thor"
+
+end

data/lib/fukuzatsu.rb

@@ -0,0 +1,10 @@
+require 'require_all'
+require 'ephemeral'
+require 'poro_plus'
+require 'fileutils'
+require 'haml'
+
+require_all './lib/fukuzatsu/'
+
+module Fukuzatsu
+end

data/lib/fukuzatsu/analyzer.rb

@@ -0,0 +1,82 @@
+require 'parser/current'
+
+class Analyzer
+
+  CONDITIONALS = [:if]
+
+  attr_accessor :content, :class_name, :edges, :nodes, :exits
+
+  def initialize(content)
+    self.content = content
+    self.edges = 0
+    self.nodes = 1
+    self.exits = 1
+  end
+
+  def complexity
+    return unless traverse(parsed)
+    self.edges - self.nodes + exits
+  end
+
+  def extract_methods
+    @methods ||= methods_from(parsed)
+  end
+
+  def extract_class_name
+    return self.class_name if self.class_name
+    name = parsed.children.select{|node| node.type == :class}.first.loc.name
+    self.class_name = self.content[name.begin_pos..(name.end_pos - 1)]
+  end
+
+  private
+
+  def extend_graph
+    self.edges += 2
+    self.nodes += 2
+    self.exits += 1
+  end
+
+  def methods_from(node, methods=[])
+    if node.type == :def || node.type == :defs
+      name = node.loc.name
+      expression = node.loc.expression
+      methods << ParsedMethod.new(
+        name: content[name.begin_pos..name.end_pos - 1],
+        content: content[expression.begin_pos..expression.end_pos - 1],
+        type: node.type == :defs ? :class : :instance
+      )
+    end
+    node.children.each do |child|
+      if parent_node?(child)
+        methods_from(child, methods)
+      end
+    end
+    methods
+  end
+
+  def parent_node?(node)
+    node.respond_to?(:type) || node.respond_to?(:children)
+  end
+
+  def parse!
+    traverse(parsed) && complexity
+  end
+
+  def parsed
+    @parsed ||= Parser::CurrentRuby.parse(content)
+  end
+
+  def traverse(node, accumulator=[], extract_methods=false)
+    accumulator << node.type
+    extend_graph if CONDITIONALS.include?(node.type)
+    node.children.each do |child|
+      if parent_node?(child)
+        accumulator << child.type
+        traverse(child, accumulator)
+      end
+    end
+    accumulator
+  end
+
+end
+

data/lib/fukuzatsu/cli.rb

@@ -0,0 +1,24 @@
+require 'thor'
+require 'fukuzatsu'
+
+module Fukuzatsu
+
+  class CLI < Thor
+
+    desc "parse PATH_TO_FILE -f FORMAT", "Formats are text (default, to STDOUT), html, and csv. Ex: parse foo.rb -f html"
+    method_option :format, :type => :string, :default => 'text', :aliases => "-f"
+    def parse(file)
+      file = ParsedFile.new(path_to_file: file)
+      case options['format']
+      when 'html'
+        Formatters::Html.new(file).export
+      when 'csv'
+        Formatters::Csv.new(file).export
+      else
+        Formatters::Text.new(file).export
+      end
+    end
+
+  end
+
+end

data/lib/fukuzatsu/formatters/base.rb

@@ -0,0 +1,44 @@
+module Formatters
+
+  module Base
+
+    def self.included(klass)
+      klass.send(:attr_accessor, :file)
+    end
+
+    def initialize(file)
+      self.file = file
+    end
+
+    def content
+      [header, rows, footer].flatten.join("\r\n")
+    end
+
+    def columns
+      ["class", "method", "complexity"]
+    end
+
+    def output_path
+      output_path = "doc/fukuzatsu/#{self.file.path_to_file.split('/')[0..-2].join("/")}"
+      FileUtils.mkpath(output_path)
+      output_path
+    end
+
+    def filename
+      self.file.path_to_file.split('/')[-1] + file_extension
+    end
+
+    def export
+      begin
+        outfile = File.open("#{output_path}/#{filename}", 'w')
+        outfile.write(content)
+      rescue Exception => e
+        puts "Unable to write output: #{e} #{e.backtrace}"
+      ensure
+        outfile && outfile.close
+      end
+    end
+
+  end
+
+end

data/lib/fukuzatsu/formatters/csv.rb

@@ -0,0 +1,27 @@
+module Formatters
+
+  class Csv
+
+    include Formatters::Base
+
+    def header
+      columns.join(',')
+    end
+
+    def rows
+      file.methods.inject([]) do |a, method|
+        a << "#{file.class_name},#{method.prefix}#{method.name},#{method.complexity}"
+        a
+      end.join("\r\n")
+    end
+
+    def footer
+    end
+
+    def file_extension
+      ".csv"
+    end
+
+  end
+
+end

data/lib/fukuzatsu/formatters/html.rb

@@ -0,0 +1,50 @@
+module Formatters
+
+  class Html
+
+    include Formatters::Base
+
+    def header
+      columns.map{|col| "<th>#{col.titleize}</th>"}.join("\r\n")
+    end
+
+    def content
+      Haml::Engine.new(template).render(Object.new, {
+          header: header,
+          rows: rows,
+          class_name: file.class_name,
+          path_to_file: file.path_to_file,
+          date: Time.now.strftime("%Y/%m/%d"),
+          time: Time.now.strftime("%l:%M %P")
+        }
+      )
+    end
+
+    def template
+      File.read(File.dirname(__FILE__) + "/templates/output.html.haml")
+    end
+
+    def rows
+      i = 0
+      file.methods.inject([]) do |a, method|
+        i += 1
+        a << "<tr class='#{i % 2 == 1 ? 'even' : 'odd'}'>"
+        a << "  <td>#{file.class_name}</td>"
+        a << "  <td>#{method.prefix}#{method.name}</td>"
+        a << "  <td>#{method.complexity}</td>"
+        a << "</tr>"
+        a
+      end.join("\r\n")
+    end
+
+    def footer
+    end
+
+    def file_extension
+      ".htm"
+    end
+
+
+  end
+
+end

data/lib/fukuzatsu/formatters/templates/output.html.haml

@@ -0,0 +1,44 @@
+!!!
+%html
+  %head
+    %title
+      Fukuzatsu:
+      = class_name
+    %style{media: "screen", type: "text/css"}
+      body { background: #593232; color: #fff; font-family: arial, sans-serif; padding: 2em; }
+      table { border: 10px solid #000; border-collapse: collapse; min-width: 50%; }
+      tr { border-top: 1px solid #000; }
+      tr.header { background: rgba(255, 255, 255, 0.75)}
+      tr.even { background: rgba(128, 128, 128, 0.5);}
+      tr.odd { background: rgba(128, 128, 128, 0.25);}
+      th { background: #000; text-align: left; padding: .5em; text-transform: uppercase; font-size: .8em}
+      td { text-align: left; padding: .5em;}
+      td.center { text-align: center; }
+      tfoot { background: #000; border-top: 10px solid #000; font-family: courier; margin-top: 4em; font-size: .75em;  }
+      a:link, a:visited { color: #aaa }
+      h1 { color:#593232; font-size: 1.25em; }
+      h2 { color:#593232; font-size: .75em; margin-top: -1em}
+  %body
+    %table
+      %thead
+        %tr.header
+          %td{colspan: 3}
+            %h1
+              = class_name
+            %h2
+              = path_to_file
+        %tr
+          = header
+      %tbody
+        = rows
+      %tfoot
+        %tr
+          %td.center{colspan: 3}
+            %em
+              Analyzed on
+              = date
+              at
+              = time
+              by
+              %a{href: "https://gitlab.com/coraline/fukuzatsu", target: "_new"}
+                Fukuzatsu

data/lib/fukuzatsu/formatters/text.rb

@@ -0,0 +1,27 @@
+module Formatters
+
+  class Text
+
+    include Formatters::Base
+
+    def header
+      "#{file.class_name}\t\t#{file.complexity}"
+    end
+
+    def export
+      puts content
+    end
+
+    def rows
+      file.methods.map do |method|
+        "#{file.class_name}\t#{method.prefix}#{method.name}\t#{method.complexity}"
+      end
+    end
+
+    def footer
+    end
+
+  end
+
+end
+

data/lib/fukuzatsu/parsed_file.rb

@@ -0,0 +1,28 @@
+class ParsedFile
+
+  include PoroPlus
+  include Ephemeral::Base
+
+  attr_accessor :path_to_file, :class_name
+
+  def class_name
+    @class_name ||= analyzer.extract_class_name
+  end
+
+  def content
+    @content ||= File.open(path_to_file, "r").read
+  end
+
+  def analyzer
+    Analyzer.new(content)
+  end
+
+  def complexity
+    @complexity ||= analyzer.complexity
+  end
+
+  def methods
+    @methods ||= analyzer.extract_methods
+  end
+
+end

data/lib/fukuzatsu/parsed_method.rb

@@ -0,0 +1,17 @@
+require 'parser/current'
+
+class ParsedMethod
+
+  include PoroPlus
+
+  attr_accessor :name, :content, :type
+
+  def complexity
+    @complexity ||= Analyzer.new(content).complexity
+  end
+
+  def prefix
+    self.type == :class ? "." : "#"
+  end
+
+end

data/lib/fukuzatsu/version.rb

@@ -0,0 +1,3 @@
+module Fukuzatsu
+  VERSION = "0.9.0"
+end

data/spec/analyzer_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Analyzer do
+
+  let(:content_1)   { File.read("spec/fixtures/program_1.rb") }
+  let(:content_2)   { File.read("spec/fixtures/program_2.rb") }
+
+  context "program_1" do
+
+    let(:analyzer)  { Analyzer.new(content_1) }
+
+    it "matches the manual calculation of complexity of 4" do
+      expect(analyzer.complexity).to eq(4)
+    end
+
+  end
+
+  context "program_2" do
+
+    let(:analyzer)  { Analyzer.new(content_2) }
+
+    it "matches the manual calculation of complexity of 5" do
+      expect(analyzer.complexity).to eq(5)
+    end
+
+  end
+
+end

data/spec/fixtures/program_1.rb

@@ -0,0 +1,19 @@
+def spaghetti
+  if 1 < 5
+    p 'hi'
+  else
+    if 4 ==5
+      if 2 > 0
+        p 'bye'
+      else
+        p 'see ya'
+      end
+    else
+      if 2 > 0
+        p 'bye'
+      else
+        p 'see ya'
+      end
+    end
+  end
+end

data/spec/fixtures/program_2.rb

@@ -0,0 +1,25 @@
+def toppings
+
+  if rand(10) < 5
+    return "meatball"
+  end
+
+  if 1 < 5
+    return 'tomato'
+  else
+    if 4 ==5
+      if 2 > 0
+        return "parmesan"
+      else
+        return "romano"
+      end
+    else
+      if 2 > 0
+        return "alfredo"
+      else
+        return "gravy"
+      end
+    end
+  end
+
+end

data/spec/fixtures/program_3.rb

@@ -0,0 +1,66 @@
+require 'fukuzatsu'
+
+class Breathalizer
+
+  INDICATORS = [
+    :if,
+    :def,
+  ]
+
+  attr_accessor :path_to_file, :edges, :nodes, :exits, :accumulator
+
+  def self.parse!(path_to_file)
+    new(path_to_file).parse
+  end
+
+  def initialize(path_to_file)
+    self.accumulator = []
+    self.edges = 0
+    self.nodes = 1
+    self.exits = 1
+    self.path_to_file = path_to_file
+  end
+
+  def file_contents
+    File.open(path_to_file, "r").read
+  end
+
+  def parsed
+    @parsed ||= Parser::CurrentRuby.parse(file_contents)
+  end
+
+  def parse!
+    traverse(parsed)
+    complexity
+  end
+
+  def traverse(node)#, accumulator=[])
+
+    accumulator << node.type
+
+    if node.type == :if || node.type == :begin
+      self.edges += 2
+      self.nodes += 2
+      self.exits += 1
+    elsif node.type == :def
+      self.edges += 1
+      self.nodes += 1
+      self.exits += 1
+    end
+
+    node.children.each do |child|
+      if child.respond_to?(:type) || child.respond_to?(:children)
+        accumulator << child.type
+        traverse(child, accumulator)
+      else
+      end
+    end
+  end
+
+  def complexity
+    p "edges = #{self.edges}, nodes = #{self.nodes}, exits = #{self.exits}"
+    self.edges - self.nodes + exits
+  end
+
+end
+

data/spec/formatters/csv_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Formatters::Csv do
+
+  let(:formatter) { Formatters::Csv.new }
+
+  describe "#header" do
+    it "outputs a header row" do
+      expect(formatter.header).to eq("class,method,complexity,lines")
+    end
+  end
+
+  describe "#rows" do
+
+    let(:expected) {
+      [
+        "Foo,baz,5,10",
+        "Foo,bat,15,100",
+        "Bar,gum,51,110",
+        "Bar,bun,55,101"
+      ]
+    }
+
+    let(:file_1)    { ParsedFile.new(class_name: "Foo") }
+    let(:file_2)    { ParsedFile.new(class_name: "Bar") }
+    let(:method_1)  { ParsedMethod.new(method_name: "baz", complexity: 5, loc: 10)}
+    let(:method_2)  { ParsedMethod.new(method_name: "bat", complexity: 15, loc: 100)}
+    let(:method_3)  { ParsedMethod.new(method_name: "gum", complexity: 51, loc: 110)}
+    let(:method_4)  { ParsedMethod.new(method_name: "bun", complexity: 55, loc: 101)}
+
+    before do
+      file_1.parsed_methods = [method_1, method_2]
+      file_2.parsed_methods = [method_3, method_4]
+      formatter.parsed_files = [file_1, file_2]
+    end
+
+    it "builds an array" do
+      expect(formatter.rows).to eq(expected)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'rspec'
+require 'fukuzatsu'

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: fukuzatsu
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Bantik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require_all
+  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: ephemeral
+  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: poro_plus
+  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: haml
+  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: parser
+  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: rspec
+  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: thor
+  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: Calculates the cyclomatic complexity of methods within a given file.
+email:
+- coraline@idolhands.com
+executables:
+- fuku
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/fuku
+- fukuzatsu.gemspec
+- lib/fukuzatsu.rb
+- lib/fukuzatsu/analyzer.rb
+- lib/fukuzatsu/cli.rb
+- lib/fukuzatsu/formatters/base.rb
+- lib/fukuzatsu/formatters/csv.rb
+- lib/fukuzatsu/formatters/html.rb
+- lib/fukuzatsu/formatters/templates/output.html.haml
+- lib/fukuzatsu/formatters/text.rb
+- lib/fukuzatsu/parsed_file.rb
+- lib/fukuzatsu/parsed_method.rb
+- lib/fukuzatsu/version.rb
+- spec/analyzer_spec.rb
+- spec/fixtures/program_1.rb
+- spec/fixtures/program_2.rb
+- spec/fixtures/program_3.rb
+- spec/formatters/csv_spec.rb
+- spec/spec_helper.rb
+homepage: https://gitlab.com/coraline/fukuzatsu
+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: A simple code complexity analyzer.
+test_files:
+- spec/analyzer_spec.rb
+- spec/fixtures/program_1.rb
+- spec/fixtures/program_2.rb
+- spec/fixtures/program_3.rb
+- spec/formatters/csv_spec.rb
+- spec/spec_helper.rb