analyst 0.0.1 → 0.13.1

data/lib/analyst/rethink/parser.rb

@@ -0,0 +1,346 @@
+require 'pry'
+
+module Z
+
+  class Parser
+    extend Forwardable
+
+    attr_reader :corpus
+
+    def_delegators :@corpus, :classes, :associations
+
+    def initialize(path)
+      @corpus = Corpus.new(path)
+    end
+
+    def class_graph
+      {
+        nodes: corpus.classes,
+        edges: corpus.associations
+        #nodes: [1,2,3],
+        #edges: [{source: 1, target: 2, strength: 1}, {source: 2, target: 1, strength: 4}]
+      }
+    end
+  end
+
+
+  class Corpus
+
+    attr_reader :path, :classes, :associations
+
+    def initialize(path)
+      @path = path
+      parse!
+    end
+
+    def files
+      @files ||= file_paths.map {|path| File.new(path)}
+    end
+
+    def parse!
+      @classes = extract_classes
+      @associations = link_associations
+      #@associations = combine_identical_associations
+    end
+
+    private
+
+    def extract_classes
+      classes = []
+      files.each {|f| f.classes.each {|c| merge_class(classes, c) } }
+      classes
+    end
+
+    def link_associations
+      all = classes.map(&:associations).flatten
+      all.each do |assoc|
+        target = classes.detect {|c| c.full_name == assoc.target_class }
+        if target
+          assoc.target = target
+        else
+          puts "WARNING: Couldn't find target: #{assoc.target_class}"
+        end
+      end
+    end
+
+    def file_paths
+      if ::File.directory?(path)
+        Dir.glob(::File.join(path, "**", "*.rb"))
+      else
+        [path]
+      end
+    end
+
+    def merge_class(classes, klass)
+      existing = classes.find {|c| c.full_name == klass.full_name}
+      if existing
+        existing.merge(klass)
+      else
+        classes << klass
+      end
+    end
+
+  end
+
+
+  class File
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def contents
+      @contents ||= ::File.open(path, 'r').read
+    end
+
+    def ast
+      @ast ||= ::Parser::CurrentRuby.parse(contents)
+    end
+
+    def classes
+      return @classes if @classes
+      @classes = []
+      parse!
+      @classes
+    end
+
+    def parse!
+      parse_ast
+      true
+    end
+
+    private
+
+    # to log node types that haven't been dealt with
+    def unhandled_node_types
+      @unhandled_node_types ||= Set.new
+    end
+
+    # contains Module, Class, Method... eventually Block and other stuff maybe
+    def context_stack
+      @context_stack ||= [Entities::Empty.new]
+    end
+
+    def node_parsers
+      @node_parsers ||= Hash.new(:default_node_parser).merge!(
+        :class => :class_node_parser,
+        :module => :module_node_parser,
+        :def => :method_node_parser,
+        :send => :send_node_parser
+        # TODO: make a method parser, which pushes the the context_stack so that things inside method bodies
+        # are treated differently than those inside class or module bodies.  same with Block (right?)
+      )
+    end
+
+    # search the whole tree for classes
+    def parse_ast(node=ast)
+      # files can start with (module), (class), or (begin)
+      # EDIT: or (send), or (def), or.... just about anything
+      return unless node.respond_to? :type
+      send(node_parsers[node.type], node)
+    end
+
+    def default_node_parser(node)
+      unhandled_node_types.add(node.type)
+      return unless node.respond_to? :children
+      node.children.each { |cnode| parse_ast(cnode) }
+    end
+
+    def class_node_parser(node)
+      name_node, super_node, content_node = node.children
+      klass = Entities::Class.new(context_stack.last, node)
+      @classes << klass
+      context_stack.push klass
+      parse_ast(content_node)
+      context_stack.pop
+    end
+
+    def module_node_parser(node)
+      name_node, content_node = node.children
+      mod = Entities::Module.new(context_stack.last, node)
+      context_stack.push mod
+      parse_ast(content_node)
+      context_stack.pop
+    end
+
+    def method_node_parser(node)
+      name, args_node, content_node = node.children
+      method = Entities::Method.new(context_stack.last, node)
+      context_stack.push method
+      parse_ast(content_node)
+      context_stack.pop
+    end
+
+    def send_node_parser(node)
+      target_node, method_name, *args = node.children
+      # if method_name is an association, then analyze the args to see what class it's associated with!
+      # and "it", btw, is the context_stack.last... so ya, also make sure this analysis is only done when we're in a
+      # class, NOT when we're in a method, NOT when we're in a defs, NOT when we're in an (sclass) (comes from
+      # class << self) -- got that?? those nodes should push something like 'Unsupported' onto the stack, or something
+      # just to keep track of where we are at any given point, and make sure we only care about sends that
+      # are truly at the right scope.
+      context_stack.last.handle_send_node(node)
+      # basically, if it's a class, it'll see if this is an association.  if so, it'll store it by name. later on, we go
+      # thru and connect the pointers.
+    end
+  end
+
+
+  module Entities
+
+    class Entity
+      attr_reader :parent
+
+      def handle_send_node(node)
+        # abstract method.  btw, this feels wrong -- send should be an entity too.  but for now, whatevs.
+      end
+
+      def full_name
+        throw "this is abstract method, fool"
+      end
+
+      def inspect
+        "\#<#{self.class}:#{object_id} full_name=#{full_name}>"
+      end
+    end
+
+
+    class Empty < Entity
+      def full_name
+        ''
+      end
+    end
+
+
+    class Method < Entity
+      attr_reader :ast
+
+      def initialize(parent, ast)
+        @parent = parent
+        @ast = ast
+      end
+
+      def name
+        ast.children.first.to_s
+      end
+
+      def full_name
+        parent.full_name + '#' + name
+      end
+    end
+
+
+    class Module < Entity
+      attr_reader :ast
+
+      def initialize(parent, ast)
+        @parent = parent
+        @ast = ast
+      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
+
+      # 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
+
+
+    class Class < Module
+
+      # pretend, for now, that we always have an AR.  i.e., always look for associations.
+      ASSOCIATIONS = [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many]
+
+      def handle_send_node(node)
+        # FIXME: this doesn't feel right, cuz (send) should probably be an entity too, especially
+        # since you can have nested sends... but i'm doing it this way for now.
+        target, method_name, *args = node.children
+        if ASSOCIATIONS.include? method_name
+          add_association(method_name, args)
+        end
+      end
+
+      def associations
+        @associations ||= []
+      end
+
+      def merge(other_class)
+        other_class.associations.each do |other_assoc|
+          duplicate = associations.detect do |assoc|
+            assoc.type == other_assoc.type && assoc.target_class == other_assoc.target_class
+          end
+          unless duplicate
+            associations << Association.new(type: other_assoc.type, source: self, target_class: other_assoc.target_class)
+          end
+        end
+      end
+
+      private
+
+      def add_association(method_name, args)
+        if args.size > 1
+          # args.last is a hash that might contain a class_name or a through
+          target_class = hash_val_str(args.last, :class_name)
+        end
+        target_class ||= begin
+                           symbol_node = args.first
+                           symbol_name = symbol_node.children.first
+                           table_name = ::ActiveSupport::Inflector.pluralize(symbol_name)
+                           ::ActiveSupport::Inflector.classify(table_name)
+                         end
+        assoc = Association.new(type: method_name, source: self, target_class: target_class)
+        associations << assoc
+      end
+
+      # give it a (hash) node and a key (a symbol) and it'll look for that key in the hash and
+      # return the associated value as long as it's a string.  if key isn't found, returns nil.
+      # if key is found but val isn't (str), throw exception. yep, this is pretty bespoke.
+      def hash_val_str(node, key)
+        return unless node.type == :hash
+        pair = node.children.detect do |pair_node|
+          key_sym_node = pair_node.children.first
+          key == key_sym_node.children.first
+        end
+        if pair
+          val_node = pair.children.last
+          throw "Bad type. Expected (str), got (#{val_node.type})" unless val_node.type == :str
+          val_node.children.first
+        end
+      end
+    end
+
+  end
+
+
+  class Association
+    attr_reader :type, :source, :target_class
+    attr_accessor :target
+
+    def initialize(type:, source:, target_class:)
+      @type = type
+      @source = source
+      @target_class = target_class
+    end
+  end
+
+end
+

data/lib/analyst/version.rb

@@ -1,3 +1,3 @@
 module Analyst
-  VERSION = "0.0.1"
+  VERSION = "0.13.1"
 end

data/lib/analyst.rb

@@ -1,5 +1,20 @@
-require "analyst/version"
+require 'ephemeral'
+require 'poro_plus'
+require 'fileutils'
+require 'haml'
+
+require_relative "analyst/analyzer"
+require_relative "analyst/cli"
+require_relative "analyst/formatters/base"
+require_relative "analyst/formatters/csv"
+require_relative "analyst/formatters/html"
+require_relative "analyst/formatters/html_index"
+require_relative "analyst/formatters/text"
+require_relative "analyst/line_of_code"
+require_relative "analyst/parsed_file"
+require_relative "analyst/parsed_method"
+require_relative "analyst/parser"
+require_relative "analyst/version"
 
 module Analyst
-  # Your code goes here...
 end

data/spec/analyzer_spec.rb

@@ -0,0 +1,122 @@
+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") }
+  let(:content_3)   { File.read("spec/fixtures/eg_class.rb") }
+  let(:content_4)   { File.read("spec/fixtures/eg_mod_class.rb") }
+  let(:content_5)   { File.read("spec/fixtures/eg_module.rb") }
+  let(:content_6)   { File.read("spec/fixtures/eg_mod_class_2.rb") }
+
+  context "#extract_class_name" do
+
+    context "from Class Foo" do
+      it "returns Foo" do
+        expect(Analyzer.new(content_3).extract_class_name).to eq("Foo")
+      end
+    end
+
+    context "from Module::Class Foo" do
+      it "returns Foo::Bar" do
+        expect(Analyzer.new(content_4).extract_class_name).to eq("Foo::Bar")
+      end
+    end
+
+    context "from Module; Class" do
+      it "returns Extracted::Thing" do
+        expect(Analyzer.new(content_6).extract_class_name).to eq("Extracted::Thing")
+      end
+    end
+
+    context "from Module" do
+      it "returns Something" do
+        expect(Analyzer.new(content_5).extract_class_name).to eq("Something")
+      end
+    end
+  end
+
+  describe "#complexity" do
+    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
+
+  describe "extract_class_name" do
+    context "from a file with a class in it" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_class.rb")) }
+      it "should return the name of the class" do
+        expect(analyzer.extract_class_name).to eq "Gown"
+      end
+    end
+    context "from a file with a class inside a module" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/module_with_class.rb")) }
+      it "should return the name of the class" do
+        expect(analyzer.extract_class_name).to eq "Symbolics::Insects::Bee"
+      end
+    end
+    context "from a file with no class in it" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_method.rb")) }
+      it "should return 'Unknown'" do
+        expect(analyzer.extract_class_name).to eq "Unknown"
+      end
+    end
+
+  end
+
+  describe "extract_methods" do
+    # Note: should implicitly trust private method #methods_from
+    context "from a file with a single method" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_method.rb")) }
+      it "should return a single method" do
+        expect(analyzer.extract_methods.count).to eq 1
+      end
+      it "should extract the method name" do
+        expect(analyzer.extract_methods[0].name).to eq "#read_poem"
+      end
+      it "should extract the method content" do
+        expect(analyzer.extract_methods[0].content).to eq 'def read_poem
+  return "I meant to find her when I came/Death had the same design"
+end'
+      end
+      it "should set type to :instance" do
+        expect(analyzer.extract_methods[0].type).to eq :instance
+      end
+    end
+    context "from a file with multiple methods" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/multiple_methods.rb")) }
+      it "should return multiple methods" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["#bake_treats", "#lower_from_window"]
+      end
+    end
+    context "from a file with nested methods" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/nested_methods.rb")) }
+      it "should return the root method, and its child" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["#grow_flowers", "#water_earth"]
+      end
+    end
+    context "from a file with a class" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_class.rb")) }
+      it "should return the class and its methods" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["#initialize", "#color"]
+      end
+    end
+  end
+
+end

data/spec/cli_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Analyst::CLI" do
+
+  let(:cli) { Analyst::CLI.new([
+      path: "foo/bar.rb",
+      format: 'text'
+    ]
+  )}
+
+  let(:summary_1) {
+    {
+      results_file: "doc/analyst/file_1.rb.htm",
+      path_to_file: "file_1.rb",
+      class_name: "File_1",
+      complexity: 13
+    }
+  }
+
+  let(:summary_2) {
+    {
+      results_file: "doc/analyst/file_2.rb.htm",
+      path_to_file: "file_2.rb",
+      class_name: "File_2",
+      complexity: 11
+    }
+  }
+
+  before do
+    allow(cli).to receive(:summaries) { [summary_1, summary_2] }
+  end
+
+  describe "#formatter" do
+    it "returns a csv formatter" do
+      allow(cli).to receive(:options) { {'format' => 'csv'} }
+      expect(cli.send(:formatter)).to eq Formatters::Csv
+    end
+    it "returns an html formatter" do
+      allow(cli).to receive(:options) { {'format' => 'html'} }
+      expect(cli.send(:formatter)).to eq Formatters::Html
+    end
+    it "returns a text formatter" do
+      allow(cli).to receive(:options) { {'format' => 'text'} }
+      expect(cli.send(:formatter)).to eq Formatters::Text
+    end
+  end
+
+end

data/spec/fixtures/eg_class.rb

@@ -0,0 +1,8 @@
+require 'analyst'
+
+class Foo
+  def say_hello
+    "Oh hi there."
+  end
+end
+

data/spec/fixtures/eg_mod_class.rb

@@ -0,0 +1,2 @@
+class Foo::Bar
+end

data/spec/fixtures/eg_mod_class_2.rb

@@ -0,0 +1,5 @@
+module Extracted
+  class Thing
+  end
+end
+

data/spec/fixtures/eg_module.rb

@@ -0,0 +1,2 @@
+module Something
+end

data/spec/fixtures/module_with_class.rb

@@ -0,0 +1,9 @@
+module Symbolics
+  module Insects
+    class Bee
+      def correspond(letter)
+        @letter = letter
+      end
+    end
+  end
+end

data/spec/fixtures/multiple_methods.rb

@@ -0,0 +1,7 @@
+def bake_treats
+  return :a_basket_of_cookies
+end
+
+def lower_from_window(window)
+  window.insert(bake_treats)
+end

data/spec/fixtures/nested_methods.rb

@@ -0,0 +1,8 @@
+def grow_flowers(seed, water, earth)
+  def water_earth(water, earth)
+    earth.insert(water)
+  end
+  
+  earth.insert.seed
+  50.times(water_earth(water, earth))
+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