analyst 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f928fc2a5aaf979b7d338ba06a0a588cd07cf98e
-  data.tar.gz: 3108a32bef9afb6a87a26023da2b7e5e751ab774
+  metadata.gz: b3e243d014bb8326cde40ec9a77530dc26cd2d77
+  data.tar.gz: e70309a0752dacbccddd636e99e4406691a61d44
 SHA512:
-  metadata.gz: c9a8c882c5e080ae9612f7531cbac8037c703b3ca0a73206c07db9de3e94c16021c41a7f62add65a854cefda1d2c8d8746bb72ea08125a3e84875864cb66f75c
-  data.tar.gz: d7d3a8615db9efe5c88471b7f30dc6eedb5bf3e5caff532f0ff689abc2621a67ac9e02c12309b03d3f941ba4280ca41ff2da7f6faed5c0164f16ec7673624d7e
+  metadata.gz: fdb9ed57212aca0e6e6cdc243519989e34535cd43342f8c5773751122fb6795b73b2d1ce6282349ae4af8777ad0214709748fda1f05a274cd2fb50263d368c5e
+  data.tar.gz: 9e0456a47ff03f707d1dfa30ae61bfaf17501ffd5e24786a6c4c448fb478d2ccb8326e4aae6eaef759e15b9dbba54e8c7e6d0d2dfb5f7a80d47b2f243a9f5166

data/analyst.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Analyst::VERSION
   spec.authors       = ["Coraline Ada Ehmke", "Mike Ziwisky"]
   spec.email         = ["coraline@idolhands.com", "mikezx@gmail.com"]
-  spec.summary       = %q{Engine for analyzing Ruby source code.}
-  spec.description   = %q{Engine for analyzing Ruby source code.}
+  spec.summary       = %q{A nice API for interacting with parsed Ruby source code.}
+  spec.description   = %q{A nice API for interacting with parsed Ruby source code.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -18,7 +18,7 @@ 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 "ephemeral", ">= 2.4.0"
   spec.add_dependency "poro_plus"
   spec.add_dependency "haml"
   spec.add_dependency "parser"
@@ -31,5 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
 
 end

data/lib/analyst/entities/begin.rb

@@ -0,0 +1,13 @@
+module Analyst
+
+  module Entities
+    module Begin
+
+      def self.new(node, parent)
+        node.children.map { |child| Analyst::Parser.process_node(child, parent) }
+      end
+
+    end
+  end
+end
+

data/lib/analyst/entities/class.rb

@@ -0,0 +1,97 @@
+#TODO add == to association
+# TODO look thru the singleton_methods for ones on (self),
+#   and also look for the ones from 'class << self' constructs, which will be
+#   found in (sclass) nodes (which will be some sort of Entity)
+
+module Analyst
+
+  module Entities
+    class Class < Analyst::Entities::Module
+
+      alias :macros :method_calls
+
+      def imethods
+        @imethods ||= contents.select { |entity| entity.is_a? Analyst::Entities::InstanceMethod }
+      end
+
+      def cmethods
+        some_methods = smethods.select { |method| method.target.type == :self }
+        other_methods = singleton_class_blocks { |block| block.target.type == :self }.map(&:smethods).flatten
+        some_methods + other_methods
+      end
+
+      def singleton_class_blocks
+        contents.select { |entity| entity.is_a? Analyst::Entities::SingletonClass }
+      end
+
+      private
+
+      def smethods
+        @smethods ||= contents.select do |entity|
+          entity.is_a? Analyst::Entities::SingletonMethod
+        end
+      end
+
+      # ASSOCIATIONS = [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many]
+
+      # attr_reader :associations
+
+      # def initialize(node, parent)
+      #   @associations = []
+      #   super
+      # 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
+
+      # 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
+
+      # # 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

data/lib/analyst/entities/empty.rb

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

data/lib/analyst/entities/entity.rb

@@ -0,0 +1,67 @@
+# An entity is a named node of a given type which may have additional properties
+module Analyst
+  module Entities
+    class Entity
+
+      attr_reader :parent
+
+      def initialize(ast, parent)
+        @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
+
+      # TODO: should every Entity have these accessors? maybe they're mixins... but would that provide any benefit?
+      def classes
+        @classes ||= begin
+          nested_classes = top_level_classes.map(&:classes).flatten
+          namespaced_classes = top_level_modules.map(&:classes).flatten
+          top_level_classes + nested_classes + namespaced_classes
+        end
+      end
+
+      def top_level_modules
+        @top_level_modules ||= contents_of_type(Entities::Module)
+      end
+
+      def top_level_classes
+        @top_level_classes ||= contents_of_type(Entities::Class)
+      end
+
+      def method_calls
+        @method_calls ||= contents_of_type(Entities::MethodCall)
+      end
+
+      def full_name
+        throw "Subclass #{self.class.name} must implement #full_name"
+      end
+
+      def inspect
+        "\#<#{self.class}:#{object_id} full_name=#{full_name}>"
+      rescue
+        "\#<#{self.class}:#{object_id}>"
+      end
+
+      private
+
+      attr_reader :ast
+
+      def contents_of_type(klass)
+        contents.select { |entity| entity.is_a? klass }
+      end
+
+      def contents
+        @contents ||= Array(Analyst::Parser.process_node(content_node, self))
+      end
+
+      def content_node
+        ast.children.last
+      end
+
+    end
+  end
+end

data/lib/analyst/entities/method.rb

@@ -0,0 +1,41 @@
+module Analyst
+  module Entities
+
+    class InstanceMethod < Entity
+      def name
+        ast.children.first.to_s
+      end
+      def full_name
+        parent.full_name + '#' + name
+      end
+    end
+
+    # TODO HERE
+    class ClassMethod < Entity
+      def name
+        ast.children.first.to_s
+      end
+      def full_name
+        parent.full_name + '::' + name
+      end
+    end
+
+    class SingletonMethod < Entity
+
+      # NOTE: not a public API -- used by Entities::Class
+      def target
+        target, name, params, content = ast.children
+        target
+      end
+
+      def name
+        ast.children[1].to_s
+      end
+
+      def full_name
+        parent.full_name + '::' + name
+      end
+    end
+
+  end
+end

data/lib/analyst/entities/method_call.rb

@@ -0,0 +1,28 @@
+module Analyst
+  module Entities
+    class MethodCall < Entity
+
+      def name
+        name_node.to_s
+      end
+
+      def full_name
+        name
+      end
+
+      # TODO: figure out how to resolve this to an Entity. we never want
+      # to expose the AST to the outside.
+      def target_node
+        ast.children.first
+      end
+
+      private
+
+      def name_node
+        ast.children[1]
+      end
+
+    end
+  end
+end
+

data/lib/analyst/entities/module.rb

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

data/lib/analyst/entities/root.rb

@@ -0,0 +1,22 @@
+module Analyst
+
+  module Entities
+    class Root < Entity
+
+      def full_name
+        ""
+      end
+
+      private
+
+      def contents
+        @contents ||= begin
+          child_nodes = ast.children
+          child_nodes.map { |child| Analyst::Parser.process_node(child, self) }.flatten
+        end
+      end
+
+    end
+  end
+end
+

data/lib/analyst/entities/singleton_class.rb

@@ -0,0 +1,21 @@
+module Analyst
+
+  module Entities
+    class SingletonClass < Entity
+
+      def full_name
+        parent.full_name + "!SINGLETON"
+      end
+
+      def name
+        parent.name + "!SINGLETON"
+      end
+
+      def smethods
+        @smethods ||= contents.select { |entity| entity.is_a? Analyst::Entities::InstanceMethod }
+      end
+
+    end
+  end
+
+end

data/lib/analyst/parser.rb

@@ -1,76 +1,51 @@
 require 'fileutils'
+require 'pry'
 
 module Analyst
 
   class Parser
 
-    attr_reader :start_path, :parsed_files
-    attr_reader :threshold, :formatter
-    attr_reader :start_time
+    extend Forwardable
 
-    OUTPUT_DIRECTORY = "doc/Analyst"
+    attr_reader :start_path
 
-    def initialize(path, formatter, threshold=0)
-      @start_path = path
-      @formatter  = formatter
-      @threshold  = threshold
-      @start_time = Time.now
-      reset_output_directory
-    end
-
-    def parsed_files
-      @parsed_files = source_files.map do |path_to_file|
-         parse_source_file(path_to_file)
-      end
-    end
-
-    def report
-      self.parsed_files.each do |file|
-        print "."
-        formatter.new(file, OUTPUT_DIRECTORY, file.source).export
-      end
-      puts
-      write_report_index
-      report_complexity
-    end
+    def_delegators :root, :classes, :top_level_classes
 
-    private
+    # TODO: Empty -> Unhandled (or something like that)
+    PROCESSORS = Hash.new(Entities::Empty).merge!(
+      :root => Entities::Root,
+      :class => Entities::Class,
+      :def => Entities::InstanceMethod,
+      :defs => Entities::SingletonMethod,
+      :begin => Entities::Begin,
+      :module => Entities::Module,
+      :send => Entities::MethodCall,
+      :sclass => Entities::SingletonClass
+    # :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?)
+    )
 
-    def reset_output_directory
-      begin
-        FileUtils.remove_dir(OUTPUT_DIRECTORY)
-      rescue Errno::ENOENT
-      end
-      FileUtils.mkpath(OUTPUT_DIRECTORY)
+    def self.process_node(node, parent)
+      return if node.nil? # TODO: maybe a Entities:Nil would be appropriate? maybe?
+      PROCESSORS[node.type].new(node, parent)
     end
 
-    def source_files
-      if File.directory?(start_path)
-        return Dir.glob(File.join(start_path, "**", "*.rb"))
-      else
-        return [start_path]
-      end
+    def initialize(ast)
+      @ast = ast
     end
 
-    def parse_source_file(path_to_file, options={})
-      ParsedFile.new(path_to_file: path_to_file)
+    def inspect
+      "\#<#{self.class}:#{object_id}>"
     end
 
-    def report_complexity
-      return if self.threshold == 0
-      complexities = self.parsed_files.map(&:complexity)
-      return if complexities.max.to_i <= self.threshold
-      puts "Maximum complexity of #{complexities.max} exceeds #{options['threshold']} threshold!"
-      exit 1
-    end
+    private
 
-    def write_report_index
-      return unless self.formatter.writes_to_file_system?
-      puts "Results written to #{OUTPUT_DIRECTORY} "
-      return unless self.formatter.has_index?
-      formatter.index_class.new(parsed_files.map(&:summary), OUTPUT_DIRECTORY).export
+    def root
+      @root ||= self.class.process_node(@ast, nil)
     end
 
   end
 
-end
+end

data/lib/analyst/version.rb

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

data/lib/analyst.rb

@@ -4,17 +4,48 @@ 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/entities/entity"
+require_relative "analyst/entities/empty"
+require_relative "analyst/entities/root"
+require_relative "analyst/entities/begin"
+require_relative "analyst/entities/module"
+require_relative "analyst/entities/class"
+require_relative "analyst/entities/method"
+require_relative "analyst/entities/method_call"
+require_relative "analyst/entities/singleton_class"
 require_relative "analyst/parser"
 require_relative "analyst/version"
 
 module Analyst
+  def self.new(path_to_files)
+    Analyst::Parser.new(FileProcessor.new(path_to_files).ast)
+  end
+
+  class FileProcessor
+
+    attr_reader :path_to_files
+
+    def initialize(path_to_files)
+      @path_to_files = path_to_files
+    end
+
+    def source_files
+      if File.directory?(path_to_files)
+        return Dir.glob(File.join(path_to_files, "**", "*.rb"))
+      else
+        return [path_to_files]
+      end
+    end
+
+    def ast
+      ::Parser::AST::Node.new(
+        :root, source_files.map do |file|
+          content = File.open(file, "r").read
+          ::Parser::CurrentRuby.parse(content)
+        end
+      )
+    end
+
+  end
+
 end

data/spec/class_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Analyst::Entities::Class do
+
+  let(:parser) { Analyst.new("./spec/fixtures/music.rb") }
+  let(:artist) { parser.classes.detect { |klass| klass.full_name == "Artist" } }
+  let(:singer) { parser.classes.detect { |klass| klass.full_name == "Singer" } }
+
+  describe "#method_calls" do
+    it "lists all method invocations within a class definition" do
+      macro_names = artist.macros.map(&:name)
+      expect(macro_names).to match_array ["attr_accessor"]
+    end
+  end
+
+  describe "#imethods" do
+    it "returns a list of instance methods" do
+      method_names = artist.imethods.map(&:name)
+      expect(method_names).to match_array ["initialize", "starve"]
+    end
+  end
+
+  describe "#cmethods" do
+    it "returns a list of class methods" do
+      class_method_names = singer.cmethods.map(&:name)
+      expect(class_method_names).to match_array ["superstar", "sellouts"]
+    end
+  end
+
+end

data/spec/fixtures/music.rb

@@ -0,0 +1,70 @@
+class Artist
+
+  attr_accessor :stage_name
+
+  def initialize(name, attrs)
+    @name = name
+    @attrs = attrs
+    @stage_name = attrs[:stage_name]
+  end
+
+  def starve
+    Song.produce(10)
+  end
+end
+
+class Singer < Artist
+
+  SUPER_ATTRS = { singing: 10, dancing: 10, looks: 10 }
+
+  class << self
+    def sellouts
+      where(:album_sales > 10)
+    end
+  end
+
+  def self.superstar
+    first = %w[Michael Beyonce Cee-lo Devin]
+    last = %w[Jackson Knowles Green Townsend]
+
+    new("#{first.sample} #{last.sample}", SUPER_ATTRS.dup)
+  end
+
+  def sing
+    "♬ Hang the DJ! ♬"
+  end
+end
+
+class Song
+
+  def initialize(popularity)
+    @popularity = popularity
+  end
+end
+
+module Instruments
+
+  class Stringed
+
+    def initialize(num_strings)
+      @num_strings = num_strings
+    end
+  end
+
+  class Guitar < Stringed
+
+    def initialize(sound)
+      super(6)
+      @sound = sound
+    end
+  end
+
+end
+
+module Performances
+  module Equipment
+    class Amp
+    end
+  end
+end
+

data/spec/method_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Analyst::Entities::InstanceMethod do
+
+  it "has specs" do
+    expect(false).to be_truthy
+  end
+
+end