analyst 0.0.1 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fc61ed986af62dcb63b684638a07316d1e6739b
-  data.tar.gz: d542092af9a5d11f0fc038e2cba9851d17b346cf
+  metadata.gz: f928fc2a5aaf979b7d338ba06a0a588cd07cf98e
+  data.tar.gz: 3108a32bef9afb6a87a26023da2b7e5e751ab774
 SHA512:
-  metadata.gz: 3535144b55af2c9e36e357abcf09022533b2d8ea69ab5ad6314d7168e350531d9c4cf099727ae3f45243947baafa3d1905a6a0b457f0e31d77dd70f7f04c3db1
-  data.tar.gz: a98f9f76a609656ec6f4b2b6d0b3fdbb23f04b6989d644849fbc141243ecbe87722d9fe6e30139421cbc5372ab1def110c83efb49fdd7d66369597d2bb09f68c
+  metadata.gz: c9a8c882c5e080ae9612f7531cbac8037c703b3ca0a73206c07db9de3e94c16021c41a7f62add65a854cefda1d2c8d8746bb72ea08125a3e84875864cb66f75c
+  data.tar.gz: d7d3a8615db9efe5c88471b7f30dc6eedb5bf3e5caff532f0ff689abc2621a67ac9e02c12309b03d3f941ba4280ca41ff2da7f6faed5c0164f16ec7673624d7e

data/.gitignore

@@ -7,7 +7,7 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
+doc/*/
 lib/bundler/man
 pkg
 rdoc
@@ -20,3 +20,6 @@ tmp
 *.o
 *.a
 mkmf.log
+.console_history
+*.swp
+coverage

data/.rspec

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

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# CODE OF CONDUCT
+
+This project has adopted version 0.4 of the [Contributor Covenant](https://github.com/bantik/contributor_covenant/).
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+If any participant in this project has issues or takes exception with a contribution, they are obligated to provide constructive feedback and never resort to personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+We promise to extend courtesy and respect to everyone involved in this project regardless of gender, gender identity, sexual orientation, ability or disability, ethnicity, religion, or level of experience.

data/README.md

@@ -21,6 +21,7 @@ Or install it yourself as:
 TODO: Write usage instructions here
 
 ## Contributing
+Please note that this project is released with a [Contributor Code of Conduct](https://gitlab.com/coraline/analyst/blob/master/CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
 
 1. Fork it ( https://github.com/[my-github-username]/analyst/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/analyst.gemspec

@@ -18,6 +18,18 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "ephemeral"
+  spec.add_dependency "poro_plus"
+  spec.add_dependency "haml"
+  spec.add_dependency "parser"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "rouge"
+  spec.add_dependency "terminal-table"
+  spec.add_dependency "thor"
+
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+
 end

data/lib/analyst/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/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/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/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/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/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/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

data/lib/analyst/entity_parser/entities/module.rb

@@ -0,0 +1,31 @@
+module Analyst
+
+  module EntityParser
+    module Entities
+      class Module < Entity
+        def name
+          const_node_array(ast.children.first).join('::')
+        end
+        def full_name
+          parent.full_name.empty? ? name : parent.full_name + '::' + name
+        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
+      end
+    end
+  end
+
+end

data/lib/analyst/formatters/base.rb

@@ -0,0 +1,33 @@
+module Formatters
+
+  module Base
+
+    def self.included(klass)
+      klass.send(:attr_accessor, :file)
+      klass.send(:attr_accessor, :source)
+      klass.send(:attr_accessor, :output_directory)
+    end
+
+    def initialize(file, output_directory=nil, source="")
+      self.file = file
+      self.source = source
+      self.output_directory = output_directory
+    end
+
+    def filename
+      File.basename(self.file.path_to_file) + file_extension
+    end
+
+    def output_path
+      output_path = File.dirname(File.join(self.output_directory, self.file.path_to_file))
+      FileUtils.mkpath(output_path)
+      output_path
+    end
+
+    def path_to_results
+      File.join(output_path, filename)
+    end
+
+  end
+
+end

data/lib/analyst/formatters/csv.rb

@@ -0,0 +1,43 @@
+module Formatters
+
+  class Csv
+
+    include Formatters::Base
+
+    def self.has_index?
+      false
+    end
+
+    def self.writes_to_file_system?
+      true
+    end
+
+    def content
+      rows + "\r\n"
+    end
+
+    def export
+      begin
+        File.open(path_to_results, 'a') {|outfile| outfile.write(content)}
+      rescue Exception => e
+        puts "Unable to write output: #{e} #{e.backtrace}"
+      end
+    end
+
+    def file_extension
+      ".csv"
+    end
+
+    def path_to_results
+      File.join(output_directory, "results#{file_extension}")
+    end
+
+    def rows
+      file.methods.map do |method|
+        "#{file.path_to_file},#{file.class_name},#{method.name},#{method.complexity}"
+      end.join("\r\n")
+    end
+
+  end
+
+end

data/lib/analyst/formatters/html.rb

@@ -0,0 +1,87 @@
+require 'rouge'
+
+module Formatters
+
+  class Html
+
+    include Formatters::Base
+
+    def self.has_index?
+      true
+    end
+
+    def self.writes_to_file_system?
+      true
+    end
+
+    def self.index_class
+      Formatters::HtmlIndex
+    end
+
+    def columns
+      ["class", "method", "complexity"]
+    end
+
+    def content
+      Haml::Engine.new(output_template).render(
+        Object.new, {
+          header: header,
+          rows: rows,
+          source_lines: preprocessed,
+          class_name: file.class_name,
+          complexity: file.complexity,
+          path_to_file: file.path_to_file,
+          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 formatter
+      Rouge::Formatters::HTML.new(line_numbers: true)
+    end
+
+    def header
+      columns.map{|col| "<th>#{col.titleize}</th>"}.join("\r\n")
+    end
+
+    def lexer
+      lexer = Rouge::Lexers::Ruby.new
+    end
+
+    def output_template
+      File.read(File.dirname(__FILE__) + "/templates/output.html.haml")
+    end
+
+    def preprocessed
+      formatter.format(lexer.lex(source))
+    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.name}</td>"
+        a << "  <td>#{method.complexity}</td>"
+        a << "</tr>"
+        a
+      end.join("\r\n")
+    end
+
+    def file_extension
+      ".htm"
+    end
+
+  end
+
+end