analyst 0.0.1 → 0.13.1

data/lib/analyst/formatters/html_index.rb

@@ -0,0 +1,47 @@
+module Formatters
+
+  class HtmlIndex
+
+    include Formatters::Base
+
+    attr_reader :file_summary, :output_directory
+
+    def initialize(file_summary, output_directory=nil)
+      @file_summary = file_summary
+      @output_directory = output_directory
+    end
+
+    def content
+      Haml::Engine.new(output_template).render(
+        Object.new, {
+          file_summary: file_summary,
+          date: Time.now.strftime("%Y/%m/%d"),
+          time: Time.now.strftime("%l:%M %P")
+        }
+      )
+    end
+
+    def export
+      begin
+        File.open(path_to_results, 'w') {|outfile| outfile.write(content)}
+      rescue Exception => e
+        puts "Unable to write output: #{e} #{e.backtrace}"
+      end
+    end
+
+    def filename
+      "index.htm"
+    end
+
+    def output_path
+      FileUtils.mkpath(self.output_directory)
+      self.output_directory
+    end
+
+    def output_template
+      File.read(File.dirname(__FILE__) + "/templates/index.html.haml")
+    end
+
+  end
+
+end

data/lib/analyst/formatters/templates/index.html.haml

@@ -0,0 +1,92 @@
+!!!
+%html
+  %head
+    %title
+      Analyst
+    %link{href: "http://cdn.datatables.net/1.10.0/css/jquery.dataTables.css", rel: "stylesheet"}
+    %script{language: "javascript", src: "http://code.jquery.com/jquery-1.11.0.min.js", type: "text/javascript"}
+    %script{language: "javascript", src: "http://code.jquery.com/jquery-migrate-1.2.1.min.js", type: "text/javascript"}
+    %script{language: "javascript", src: "http://cdn.datatables.net/1.10.0/js/jquery.dataTables.js", type: "text/javascript"}
+
+    %style{media: "screen", type: "text/css"}
+      body { background: #593232; color: #fff; font-family: arial, sans-serif; padding: 2em; }
+      table { box-shadow: 0 5px 0 rgba(0,0,0,.8); background: #444; border-spacing: 0; border: 5px solid #000; border-radius: 25px; border-collapse: collapse; min-width: 50%; }
+      th.sorting_asc, th.sorting_desc { text-transform: uppercase !important; font-size: .8em !important; background-image: none !important; background: rgba(64, 41, 41, .5) !important;}
+      th.sorting { background-position: left !important; border-right: 1px solid #222; text-transform: uppercase !important; font-size: .8em !important}
+      tr.header th:first-child { border-radius: 6px 0 0 0; }
+      tr.header th:last-child { border-radius: 0 6px 0 0; }
+      tr.header th:only-child { border-radius: 6px 6px 0 0; }
+      tr.header { background-color: #222; }
+      tr.even { background: rgba(128, 128, 128, 0.5) !important;}
+      tr.odd { background: rgba(128, 128, 128, 0.25) !important}
+      tr.even:hover, tr.odd:hover { background: rgba(128, 128, 128, 0.75) !important;}
+      th { background: #000; text-align: left; padding: .5em; }
+      td { text-align: left; padding: .5em; padding-left: 1.25em !important;}
+      td.center { text-align: center; }
+      td.sorting_1 { background: none !important; padding-left: 1.25em !important; }
+      tfoot { background: #000; border-top: 10px solid #000; font-family: courier; margin-top: 4em; font-size: .75em;  }
+      a:link, a:visited { color: #aaa }
+      div.file_meta { float: left; height: 3em; width: 30%; }
+      h1 { color:#fff; font-size: 1.25em; margin-top: .25em; }
+      h2 { color:#fff; font-size: .75em; margin-top: -1em; }
+      h3 { color:#fff; font-size: 1em; float: right; margin-top: 1em; }
+      td.sorting_1 { background: none !important; padding-left: 1.25em !important; }
+      div.dataTables_filter { margin-bottom: 2em !important; }
+      div.dataTables_filter label { color: #fff; }
+      div.dataTables_paginate { display: none !important; }
+      div.dataTables_info { display: none !important; }
+
+  %body
+    %table{class: "output-table"}
+      %thead
+        %tr.header
+          %th{colspan: 4}
+            .file_meta
+              %h1
+                Project Overview
+        %tr
+          %th
+            File
+          %th
+            Module/Class Name
+          %th
+            Complexity
+          %th
+            Details
+      %tbody
+        - file_summary.each do |summary|
+          %tr
+            %td
+              %a{href: "#{summary[:path_to_file]}.htm"}
+                = summary[:path_to_file]
+            %td
+              - if summary[:class_name].size > 25
+                = "..."
+                = summary[:class_name][-24..-1]
+              - else
+                = summary[:class_name]
+            %td
+              = summary[:complexity]
+            %td
+              %a{href: "#{summary[:path_to_file]}.htm"}
+                View Details
+      %tfoot
+        %tr
+          %td.center{colspan: 4}
+            %em
+              Analyzed on
+              = date
+              at
+              = time
+              by
+              %a{href: "https://gitlab.com/coraline/Analyst", target: "_new"}
+                Analyst
+    :javascript
+      $(document).ready(function(){
+        $('.output-table').dataTable({
+          bLengthChange: false,
+          iDisplayLength: 25000,
+          "order": [[2, "desc"]]
+        });
+      });
+

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

@@ -0,0 +1,114 @@
+!!!
+%html
+  %head
+    %title
+      Analyst:
+      = class_name
+    %link{href: "http://cdn.datatables.net/1.10.0/css/jquery.dataTables.css", rel: "stylesheet"}
+    %script{language: "javascript", src: "http://code.jquery.com/jquery-1.11.0.min.js", type: "text/javascript"}
+    %script{language: "javascript", src: "http://code.jquery.com/jquery-migrate-1.2.1.min.js", type: "text/javascript"}
+    %script{language: "javascript", src: "http://cdn.datatables.net/1.10.0/js/jquery.dataTables.js", type: "text/javascript"}
+    %script{language: "javascript", src: "http://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.0/highlight.min.js", type: "text/javascript"}
+    :css
+      #{Rouge::Theme.find('thankful_eyes').render(scope: '.highlight')}
+      body { background: #593232; color: #fff; font-family: arial, sans-serif; padding: 2em; }
+      div.column { float: left; width: 45%; margin-left: 4%; }
+      div.file_listing { padding: .1em; border-radius: 5px; background: #000; width: 100%; border: 1px solid #000;}
+      div.file_meta { float: left; height: 3em; width: 30%; }
+      h1 { color:#fff; font-size: 1.25em; margin-top: .25em; }
+      h2 { color:#fff; font-size: .75em; margin-top: -1em; }
+      h3 { color:#fff; font-size: 1.1em;margin-top: 1em; }
+      h3.highlighted { background: rgba(170, 161, 57, .6); border-radius: 100px; padding: .25em; padding-left: 1em; color: #000;}
+      h3.highlighted-method { background: rgba(153, 51, 80, .6); border-radius: 100px; padding-left: 1em; }
+      li { margin-bottom: 1em;}
+      pre { line-height: 1.75em;}
+      pre.lineno { margin-top: -1.4em !important;}
+      span.highlighted { padding-left: 1em; display: inline-block; position: absolute; left: 0px; padding-right: 90%}
+      a:link, a:visited { color: #aaa }
+
+      .file_listing table { width: 100%; box-shadow: 0 5px 0 rgba(0,0,0,.8); border-spacing: 0; border: 5px solid #000; border-radius: 5px; border-collapse: collapse; min-width: 50%; }
+      .file_listing td { text-align: left; padding: .5em; padding-left: 1.25em !important;}
+      .file_listing td.gutter { background-color: rgb(109, 109, 109) !important; }
+      .file_listing tfoot { background: #000; border-top: 10px solid #000; font-family: courier; margin-top: 4em; font-size: .75em;  }
+      .file_listing th { background: #000; text-align: left; padding: .5em; }
+      .file_listing tr.faint td { opacity: 0.5; font-style: italic; }
+      .file_listing tr.header { background-color: #222; }
+      .file_listing tr { background: rgba(0, 0, 0, 0.25) !important; border-bottom: 1px solid #000;}
+      .file_listing th { background: #000; text-align: left; padding: .5em;}
+      .file_listing td { text-align: left; padding: .5em; padding-left: 1.25em !important;}
+      .file_listing td.center { text-align: center; }
+      .file_listing td.sorting_1 { background: none !important; padding-left: 1.25em !important; }
+      .file_listing tfoot { background: #000; font-family: courier; margin-top: 4em; font-size: .75em;  }
+
+      table { box-shadow: 0 5px 0 rgba(0,0,0,.8); background: #444; border-spacing: 0; border: 5px solid #000; border-radius: 25px; border-collapse: collapse; min-width: 50%; }
+      th.sorting_asc, th.sorting_desc { text-transform: uppercase !important; font-size: .8em !important; background-image: none !important; background: rgba(64, 41, 41, .5) !important;}
+      th.sorting { background-position: left !important; border-right: 1px solid #222; text-transform: uppercase !important; font-size: .8em !important}
+      tr.header th:first-child { border-radius: 6px 0 0 0; }
+      tr.header th:last-child { border-radius: 0 6px 0 0; }
+      tr.header th:only-child { border-radius: 6px 6px 0 0; }
+      tfoot tr { border-radius: 6px 6px 6px 6px; }
+      tr.header { background-color: #222; }
+      tr.even { background: rgba(128, 128, 128, 0.5) !important;}
+      tr.odd { background: rgba(128, 128, 128, 0.25) !important}
+      tr.even:hover, tr.odd:hover { background: rgba(128, 128, 128, 0.75) !important;}
+      th { background: #000; text-align: left; padding: .5em;}
+      td { text-align: left; padding: .5em; padding-left: 1.25em !important;}
+      td.center { text-align: center; }
+      td.sorting_1 { background: none !important; padding-left: 1.25em !important; }
+      tfoot { background: #000; font-family: courier; margin-top: 4em; font-size: .75em;  }
+
+      h1 { color:#fff; font-size: 1.25em; margin-top: .25em; }
+      h2 { color:#fff; font-size: .75em; margin-top: -1em; }
+      h3 { color:#fff; font-size: 1em; float: right; margin-top: 1em; }
+
+      div.dataTables_filter { display: none !important; }
+      div.dataTables_paginate { display: none !important; }
+      div.dataTables_info { display: none !important; }
+
+
+  %body
+    .container
+      %table{class: "output-table"}
+        %thead
+          %tr.header
+            %th{colspan: 3}
+              .file_meta
+                %h1
+                  = class_name
+                %h2
+                  = path_to_file
+              .file_meta_right
+                %h3
+                  = "Overall Complexity: #{complexity}"
+          %tr
+            = header
+        %tbody
+          = rows
+        %tfoot
+          %tr
+            %td.center{colspan: 3}
+              %em
+                Analyzed on
+                = date
+                at
+                = time
+                by
+                %a{href: "https://gitlab.com/coraline/Analyst", target: "_new"}
+                  Analyst
+    %br
+    %input{onclick: "history.back(-1)", type: "button", value: "Back"}
+
+    %br
+
+    .file_listing
+      = source_lines
+
+    :javascript
+      $(document).ready(function(){
+        $('.output-table').dataTable({
+          bLengthChange: false,
+          iDisplayLength: 25000,
+          "order": [[2, "desc"]]
+        });
+      });
+

data/lib/analyst/formatters/text.rb

@@ -0,0 +1,56 @@
+module Formatters
+
+  require 'terminal-table'
+  require 'rainbow/ext/string'
+
+  class Text
+
+    include Formatters::Base
+
+    def self.has_index?
+      false
+    end
+
+    def self.writes_to_file_system?
+      false
+    end
+
+    def color_for(row)
+      return :green if row.complexity == 0
+      return :yellow if row.complexity <= file.average_complexity
+      return :red if row.complexity > file.average_complexity
+      return :white
+    end
+
+    def header
+      ["Class/Module", "Method", "Complexity"]
+    end
+
+    def export
+      return if rows.empty?
+      table = Terminal::Table.new(
+        title: file.path_to_file.color(:white),
+        headings: header,
+        rows: rows,
+        style: {width: 90}
+      )
+      table.align_column(3, :right)
+      puts table
+    end
+
+    def rows
+      file.methods.map do |method|
+        color = color_for(method)
+        [wrap("#{file.class_name}").color(color), wrap("#{method.name}".color(color)), "#{method.complexity}".color(color)]
+      end
+    end
+
+    def wrap(string)
+      return string if string.length < 25
+      string[0..20] << "..."
+    end
+
+  end
+
+end
+

data/lib/analyst/fukuzatsu/analyzer.rb

@@ -0,0 +1,162 @@
+require 'parser/current'
+
+class Analyzer
+
+  CONDITIONALS = [:if, :or_asgn, :and_asgn, :or, :and]
+
+  attr_accessor :content, :class_name, :edges, :nodes, :exits
+
+  DEFAULT_CLASS_NAME = "Unknown"
+
+  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 class_name
+    find_class(parsed) || DEFAULT_CLASS_NAME
+  end
+
+  def methods
+    @methods ||= methods_from(parsed)
+  end
+
+  def constants
+    @constants ||= constants_from(parsed)
+  end
+
+  def method_names
+    @method_names ||= method_names_from(parsed)
+  end
+
+  def extract_methods
+    @methods ||= methods_from(parsed)
+  end
+
+  def extract_class_name
+    return self.class_name if self.class_name && ! self.class_name.empty?
+    found = find_class(parsed)
+    self.class_name = ! found.empty? && found || DEFAULT_CLASS_NAME
+  end
+
+  private
+
+  def method_list
+    @method_list ||= method_names
+  end
+
+  def method_names_from(node, found=[])
+    return found unless node.respond_to?(:type)
+    if node.type == :def || node.type == :defs
+      name = node.loc.name
+      found << content[name.begin_pos..name.end_pos - 1].to_sym
+    end
+    node.children.each do |child|
+      method_names_from(child, found) if parent_node?(child)
+    end
+    found
+  end
+
+  def constants_from(node, found=[])
+    if node.type == :const
+      expression = node.loc.expression
+      found << content[expression.begin_pos..expression.end_pos - 1]
+    end
+    node.children.each do |child|
+      constants_from(child, found) if parent_node?(child)
+    end
+    found.reject{ |constant| constant == class_name }
+  end
+
+  def extract_references_from(node, found=[])
+    return found unless node && node.respond_to?(:type)
+    if node.type == :send
+      reference = node.loc.expression
+      found << node.children.last
+    end
+    node.children.each do |child|
+      extract_references_from(child, found)
+    end
+    found.select{|name| method_list.include?(name)}
+  end
+
+  def text_at(start_pos, end_pos)
+    content[start_pos..end_pos - 1]
+  end
+
+  def find_class(node)
+    return unless node && node.respond_to?(:type)
+    concat = []
+    if node.type == :module || node.type == :class
+      concat << text_at(node.loc.name.begin_pos, node.loc.name.end_pos)
+    end
+    concat << node.children.map{|child| find_class(child)}.compact
+    concat.flatten.select(&:present?).join('::')
+  end
+
+  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
+      type = case(node.type)
+        when :defs
+          :class
+        when :def
+          :instance
+        when :class
+          :none
+      end
+      methods << ParsedMethod.new(
+        name: content[name.begin_pos..name.end_pos - 1],
+        content: content[expression.begin_pos..expression.end_pos - 1],
+        type: type,
+        refs: extract_references_from(node)
+      )
+    end
+    node.children.each do |child|
+      if parent_node?(child)
+        methods_from(child, methods)
+      end
+    end
+    methods.reject{ |m| m.name.empty? }
+  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/analyst/fukuzatsu/cli.rb

@@ -0,0 +1,42 @@
+require 'thor'
+require 'Analyst'
+
+module Analyst
+
+  class CLI < Thor
+
+    desc_text = "Formats are text (default, to STDOUT), html, and csv. "
+    desc_text << "Example: fuku check foo/ -f html"
+
+    desc "check PATH_TO_FILE [-f FORMAT] [-t MAX_COMPLEXITY_ALLOWED]", desc_text
+    method_option :format, :type => :string, :default => 'text', :aliases => "-f"
+    method_option :threshold, :type => :numeric, :default => 0, :aliases => "-t"
+
+    def check(path="./")
+      parser = Analyst::Parser.new(
+        path,
+        formatter,
+        options['threshold']
+      )
+      parser.parse_files
+      parser.report
+    end
+
+    default_task :check
+
+    private
+
+    def formatter
+      case options['format']
+      when 'html'
+        Formatters::Html
+      when 'csv'
+        Formatters::Csv
+      else
+        Formatters::Text
+      end
+    end
+
+  end
+
+end

data/lib/analyst/fukuzatsu/entity_parser/association.rb

@@ -0,0 +1,24 @@
+module Analyst
+
+  module EntityParser
+
+    class ClassRelation
+      attr_reader :type, :source, :target_class_name, :target
+
+      def initialize(type:, source:, target_class_name:)
+        @type = type
+        @source = source
+        @target_class_name = target_class_name
+      end
+
+      def resolve_target!(entity_list)
+        unless @target = entity_list.detect{ |entity| entity.full_name == self.target_class_name }
+          puts "WARNING: Couldn't find target: #{self.target_class_name}"
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/analyst/fukuzatsu/entity_parser/entities/class.rb

@@ -0,0 +1,92 @@
+#TODO add == to association
+
+module Analyst
+
+  module EntityParser
+    module Entities
+      class ActiveModel < Entity
+
+        ASSOCIATIONS = [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many]
+
+        attr_reader :associations
+
+        def initialize
+          @associations = []
+        end
+
+        def handle_send(node)
+          target, method_name, *args = node.children
+          if ASSOCIATIONS.include?(method_name)
+            add_association(method_name, args)
+          end
+        end
+
+        # When a class is reopened, merge its associations
+        def merge_associations_from(klass)
+          klass.associations.each do |association|
+            associations << Association.new(
+              type: association.type,
+              source: self,
+              target_class: association.target_class
+            )
+          end
+          associations.uniq!
+        end
+
+        def name
+          const_node_array(ast.children.first).join('::')
+        end
+
+        def full_name
+          parent.full_name.empty? ? name : parent.full_name + '::' + name
+        end
+
+        private
+
+        def add_association(method_name, args)
+          target_class = value_from_hash_node(args.last, :class_name)
+          target_class ||= begin
+                             symbol_node = args.first
+                             symbol_name = symbol_node.children.first
+                             symbol_name.pluralize.classify
+                           end
+          association = Association.new(type: method_name, source: self, target_class: target_class)
+          associations << association
+        end
+
+        private
+
+        # takes a (const) node and returns an array specifying the fully-qualified
+        # constant name that it represents.  ya know, so CoolModule::SubMod::SweetClass
+        # would be parsed to:
+        # (const
+        #   (const
+        #     (const nil :CoolModule) :SubMod) :SweetClass)
+        # and passing that node here would return [:CoolModule, :SubMod, :SweetClass]
+        def const_node_array(node)
+          return [] if node.nil?
+          raise "expected (const) node or nil, got (#{node.type})" unless node.type == :const
+          const_node_array(node.children.first) << node.children[1]
+        end
+
+        # Fetches value from hash node iff key is symbol and value is str
+        # Raises an exception if value is not str
+        # Returns nil if key is not found
+        def value_from_hash_node(node, key)
+          return unless node.type == :hash
+          pair = node.children.detect do |pair_node|
+            key_symbol_node = pair_node.children.first
+            key == key_symbol_node.children.first
+          end
+          if pair
+            value_node = pair.children.last
+            throw "Bad type. Expected (str), got (#{value_node.type})" unless value_node.type == :str
+            value_node.children.first
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/analyst/fukuzatsu/entity_parser/entities/empty.rb

@@ -0,0 +1,13 @@
+module Analyst
+
+  module EntityParser
+    module Entities
+      class Empty < Entity
+        def full_name
+          ""
+        end
+      end
+    end
+  end
+
+end

data/lib/analyst/fukuzatsu/entity_parser/entities/entity.rb

@@ -0,0 +1,29 @@
+module Analyst
+  module EntityParser
+    module Entities
+      class Entity
+
+        attr_reader :ast, :parent
+
+        def initialize(parent, ast)
+          @parent = parent
+          @ast = ast
+        end
+
+        def handle_send_node(node)
+          # raise "Subclass must implement handle_send_node"
+          # abstract method.  btw, this feels wrong -- send should be an entity too.  but for now, whatevs.
+        end
+
+        def full_name
+          throw "Subclass must implement #full_name"
+        end
+
+        def inspect
+          "\#<#{self.class}:#{object_id} full_name=#{full_name}>"
+        end
+
+      end
+    end
+  end
+end

data/lib/analyst/fukuzatsu/entity_parser/entities/method.rb

@@ -0,0 +1,16 @@
+module Analyst
+
+  module EntityParser
+    module Entities
+      class Method < Entity
+        def name
+          ast.children.first.to_s
+        end
+        def full_name
+          parent.full_name + '#' + name
+        end
+      end
+    end
+  end
+
+end