analyst 0.14.2 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2741a5ba1447921d472b3a13e573b8d35bf1d39c
-  data.tar.gz: 6db0b7297d497d41d406c2b67cf1d760cb751d76
+  metadata.gz: 7b73349858dc8cc8e23a7bcee486149fa81fa14b
+  data.tar.gz: e8d736fd3c97802f6a8bf7db970ae730385938e0
 SHA512:
-  metadata.gz: 5d4f07efff500a960139db14696b1d35bd85321ee83f0f178a708d20fa80ca4ec1c5c49b9e83d41d30611d9610aacc3743924737d410ec875e5103ec5c31b667
-  data.tar.gz: b18f69c1fa2cfc2357ef97c3ad6ee0685e6a1395d333dfceefc1fdbb76751b29ec624e20c4411e277e176945dabc95f7183de3de6c60df89945a02fce0aa3129
+  metadata.gz: 121c7e0d71706490dd637a48d718002a217b4fa2c190708ed9cd8c8d2fef02758cb118f0704afbd3fa397922571f09fa9270ee2dd53eb5b68266678309d9b0cb
+  data.tar.gz: 6306167886e6d7f9e4d1b6ff3bff588525805d18a6aec93b03f0c85164def809851bcfa0c54e617002813a52f43ab5a354f9e8da3f8300dadd7c71ff00539d0f

data/analyst.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "ephemeral", ">= 2.4.0"
-  spec.add_dependency "poro_plus"
   spec.add_dependency "haml"
   spec.add_dependency "parser"
   spec.add_dependency "rainbow"
@@ -32,5 +30,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "awesome_print"
 
 end
+

data/lib/analyst/entities/array.rb

@@ -0,0 +1,15 @@
+module Analyst
+
+  module Entities
+    class Array < Entity
+
+      handles_node :array
+
+      private
+
+      def contents
+        @contents ||= ast.children.map { |child| process_node(child) }
+      end
+    end
+  end
+end

data/lib/analyst/entities/class.rb

@@ -8,8 +8,14 @@ module Analyst
   module Entities
     class Class < Analyst::Entities::Module
 
+      handles_node :class
+
       alias :macros :method_calls
 
+      def kind
+        "Class"
+      end
+
       def imethods
         @imethods ||= contents.select { |entity| entity.is_a? Analyst::Entities::InstanceMethod }
       end
@@ -36,65 +42,6 @@ module Analyst
         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

data/lib/analyst/entities/code_block.rb

@@ -0,0 +1,18 @@
+module Analyst
+
+  module Entities
+    class CodeBlock < Entity
+      extend Forwardable
+
+      handles_node :begin
+
+      def_delegators :parent, :name, :full_name
+
+      def contents
+        @contents ||= ast.children.map { |child| process_node(child) }
+      end
+
+    end
+  end
+end
+

data/lib/analyst/entities/conditional.rb

@@ -0,0 +1,19 @@
+module Analyst
+
+  module Entities
+    class Conditional < Entity
+
+      handles_node :if
+      handles_node :or
+      handles_node :and
+      handles_node :or_asgn
+      handles_node :and_asgn
+
+      private
+
+      def contents
+        @contents ||= ast.children.map { |child| process_node(child) }.compact
+      end
+    end
+  end
+end

data/lib/analyst/entities/constant.rb

@@ -0,0 +1,41 @@
+module Analyst
+
+  module Entities
+    class Constant < Entity
+
+      handles_node :const
+
+      def name
+        const_node_array(ast).join("::")
+      end
+
+      def full_name
+        name
+      end
+
+      def constants
+        []
+      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]
+      # TODO: should really be nested Entities::Constants all the way down.
+      # ((cbase) can probably use the same Entity, or maybe it's a subclass of Constant)
+      def const_node_array(node)
+        return [] if node.nil?
+        return [''] if node.type == :cbase
+        raise "expected (const) or (cbase) 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/entity.rb

@@ -1,21 +1,21 @@
+require_relative '../processor'
+
 # An entity is a named node of a given type which may have additional properties
 module Analyst
   module Entities
     class Entity
 
-      attr_reader :parent
+      attr_reader :parent, :ast
+
+      def self.handles_node(type)
+        Analyst::Processor.register_processor(type, self)
+      end
 
       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
@@ -24,6 +24,21 @@ module Analyst
         end
       end
 
+      def modules
+        @modules ||= begin
+          nested_modules = top_level_modules.map(&:modules).flatten
+          top_level_modules + nested_modules
+        end
+      end
+
+      def constants
+        @constants ||= top_level_constants + contents.map(&:constants).flatten
+      end
+
+      def top_level_constants
+        @top_level_constants ||= contents_of_type(Entities::Constant)
+      end
+
       def top_level_modules
         @top_level_modules ||= contents_of_type(Entities::Module)
       end
@@ -36,26 +51,67 @@ module Analyst
         @method_calls ||= contents_of_type(Entities::MethodCall)
       end
 
+      # TODO: rethink the different kinds of Methods. there's really only one
+      # kind of Method, right??
+      # ref: http://www.devalot.com/articles/2008/09/ruby-singleton
+      def methods
+        @methods ||= contents_of_type(Entities::InstanceMethod)
+      end
+
+      def conditionals
+        @conditionals ||= contents_of_type(Entities::Conditional)
+      end
+
+      def location
+        "#{file_path}:#{line_number}"
+      end
+
+      def file_path
+        parent.file_path
+      end
+
+      def line_number
+        ast.loc.line
+      end
+
+      def source
+        origin_source[source_range]
+      end
+
+      def origin_source
+        parent.origin_source
+      end
+
       def full_name
         throw "Subclass #{self.class.name} must implement #full_name"
       end
 
       def inspect
-        "\#<#{self.class}:#{object_id} full_name=#{full_name}>"
+        "\#<#{self.class} location=#{location} full_name=#{full_name}>"
       rescue
-        "\#<#{self.class}:#{object_id}>"
+        "\#<#{self.class} location=#{location}>"
       end
 
       private
 
-      attr_reader :ast
+      def source_range
+        Range.new(ast.loc.expression.begin_pos, ast.loc.expression.end_pos)
+      end
 
       def contents_of_type(klass)
         contents.select { |entity| entity.is_a? klass }
       end
 
       def contents
-        @contents ||= Array(Analyst::Parser.process_node(content_node, self))
+        @contents ||= if actual_contents.is_a? Entities::CodeBlock
+                        actual_contents.contents
+                      else
+                        Array(actual_contents)
+                      end
+      end
+
+      def actual_contents
+        @actual_contents ||= process_node(content_node)
       end
 
       def content_node
@@ -63,7 +119,7 @@ module Analyst
       end
 
       def process_node(node, parent=self)
-        Analyst::Parser.process_node(node, parent) }
+        Analyst::Processor.process_node(node, parent)
       end
 
       def process_nodes(nodes, parent=self)

data/lib/analyst/entities/file.rb

@@ -0,0 +1,42 @@
+module Analyst
+
+  module Entities
+
+    class File < Entity
+
+      handles_node :analyst_file
+
+      def full_name
+        ""
+      end
+
+      def file_path
+        parent.source_data_for(self)
+      end
+
+      def origin_source
+        ::File.open(file_path, 'r').read
+      end
+
+      def contents
+        @contents ||= actual_contents.map do |child|
+          # skip top-level CodeBlocks
+          child.is_a?(Entities::CodeBlock) ? child.contents : child
+        end.flatten
+      end
+
+      private
+
+      def source_range
+        0..-1
+      end
+
+      def actual_contents
+        @actual_contents ||= ast.children.map { |child| process_node(child) }
+      end
+
+    end
+
+  end
+
+end

data/lib/analyst/entities/hash.rb

@@ -2,13 +2,26 @@ module Analyst
 
   module Entities
     class Hash < Entity
+
+      handles_node :hash
+
       def pairs
         @pairs ||= process_nodes(ast.children)
       end
 
-      def to_hash
-        @pairs.inject({}) do |hash, pair|
-          hash[pair.key] = pair.value
+      # Convenience method to turn this Entity into an actual ::Hash.
+      # If `extract_values` is true, then all keys and values that respond
+      # to `#value` will be replaced by the value they return from that call.
+      # Otherwise they'll be left as Analyst::Entities::Entity objects.
+      def to_hash(extract_values:true)
+        pairs.inject({}) do |hash, pair|
+          key = pair.key
+          val = pair.value
+          if extract_values
+            key = key.value if key.respond_to?(:value)
+            val = val.value if val.respond_to?(:value)
+          end
+          hash[key] = val
           hash
         end
       end

data/lib/analyst/entities/interpolated_string.rb

@@ -2,6 +2,9 @@ module Analyst
   module Entities
 
     class InterpolatedString < Entity
+
+      handles_node :dstr
+
       def name
         throw "Needs implementation"
       end

data/lib/analyst/entities/method.rb

@@ -2,19 +2,31 @@ module Analyst
   module Entities
 
     class InstanceMethod < Entity
+
+      handles_node :def
+
+      def kind
+        "Instance Method"
+      end
+
       def name
         ast.children.first.to_s
       end
+
       def full_name
         parent.full_name + '#' + name
       end
     end
 
-    # TODO HERE
     class ClassMethod < Entity
+      def kind
+        "Class Method"
+      end
+
       def name
         ast.children.first.to_s
       end
+
       def full_name
         parent.full_name + '::' + name
       end
@@ -22,6 +34,8 @@ module Analyst
 
     class SingletonMethod < Entity
 
+      handles_node :defs
+
       # NOTE: not a public API -- used by Entities::Class
       def target
         target, name, params, content = ast.children

data/lib/analyst/entities/method_call.rb

@@ -2,6 +2,8 @@ module Analyst
   module Entities
     class MethodCall < Entity
 
+      handles_node :send
+
       def name
         name_node.to_s
       end
@@ -13,17 +15,31 @@ module Analyst
       def arguments
         @arguments ||= begin
           args = ast.children[2..-1]
-          args.map { |arg| Analyst::Parser.process_node(arg, self) }
+          args.map { |arg| process_node(arg) }
         end
       end
 
-      # TODO: figure out how to resolve this to an Entity. we never want
-      # to expose the AST to the outside.
+      def constants
+        if target.is_a? Analyst::Entities::Constant
+          super << target
+        else
+          super
+        end
+      end
+
+      private
+
+      def contents
+        arguments
+      end
+
       def target_node
         ast.children.first
       end
 
-      private
+      def target
+        process_node(target_node)
+      end
 
       def name_node
         ast.children[1]

data/lib/analyst/entities/module.rb

@@ -2,8 +2,14 @@ module Analyst
   module Entities
     class Module < Entity
 
+      handles_node :module
+
+      def kind
+        "Module"
+      end
+
       def name
-        const_node_array(name_node).join('::')
+        name_entity.name
       end
 
       def full_name
@@ -12,21 +18,12 @@ module Analyst
 
       private
 
-      def name_node
-        ast.children.first
+      def name_entity
+        @name_entity ||= process_node(name_node)
       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]
+      def name_node
+        ast.children.first
       end
     end
   end

data/lib/analyst/entities/pair.rb

@@ -2,6 +2,9 @@ module Analyst
 
   module Entities
     class Pair < Entity
+
+      handles_node :pair
+
       def key
         process_node(ast.children[0])
       end

data/lib/analyst/entities/root.rb

@@ -1,19 +1,43 @@
 module Analyst
 
   module Entities
+
     class Root < Entity
 
+      handles_node :analyst_root
+
+      def initialize(ast, source_data)
+        @source_data = source_data
+        super(ast, nil)
+      end
+
       def full_name
         ""
       end
 
+      def source_data_for(entity)
+        source_data[actual_contents.index(entity)]
+      end
+
+      def file_path
+        throw "Entity tree malformed - Source or File should have caught this call"
+      end
+
+      def origin_source
+        throw "Entity tree malformed - Source or File hsould have caught this call"
+      end
+
       private
 
+      attr_reader :source_data
+
       def contents
-        @contents ||= begin
-          child_nodes = ast.children
-          child_nodes.map { |child| Analyst::Parser.process_node(child, self) }.flatten
-        end
+        # skip all top-level entities, cuz they're all Files and Sources
+        @contents ||= actual_contents.map(&:contents).flatten
+      end
+
+      def actual_contents
+        @actual_contents ||= ast.children.map { |child| process_node(child) }
       end
 
     end

data/lib/analyst/entities/singleton_class.rb

@@ -3,6 +3,8 @@ module Analyst
   module Entities
     class SingletonClass < Entity
 
+      handles_node :sclass
+
       def full_name
         parent.full_name + "!SINGLETON"
       end

data/lib/analyst/entities/source.rb

@@ -0,0 +1,42 @@
+module Analyst
+
+  module Entities
+
+    class Source < Entity
+
+      handles_node :analyst_source
+
+      def full_name
+        ""
+      end
+
+      def file_path
+        "$PARSED FROM SOURCE$"
+      end
+
+      def origin_source
+        parent.source_data_for(self)
+      end
+
+      def contents
+        @contents ||= actual_contents.map do |child|
+          # skip top-level CodeBlocks
+          child.is_a?(Entities::CodeBlock) ? child.contents : child
+        end.flatten
+      end
+
+      private
+
+      def source_range
+        0..-1
+      end
+
+      def actual_contents
+        @actual_contents ||= ast.children.map { |child| process_node(child) }
+      end
+
+    end
+
+  end
+
+end

data/lib/analyst/entities/string.rb

@@ -1,12 +1,25 @@
 module Analyst
 
   module Entities
-    module String
+    class String < Entity
 
-      def self.new(node, parent)
+      handles_node :str
+
+      def value
         ast.children.first
       end
 
+      def name
+      end
+
+      def full_name
+      end
+
+      private
+
+      def content_node
+      end
+
     end
   end
 end