system_navigation 0.1.0

data/lib/system_navigation/instruction_stream/instruction/attr_instruction.rb

@@ -0,0 +1,90 @@
+class SystemNavigation
+  class InstructionStream
+    class Instruction
+      class AttrInstruction < Instruction
+        def self.parse(method, sym)
+          instr = self.new(method)
+          self.attrreaderinstr(instr, sym) || self.attrwriterinstr(instr, sym)
+        end
+
+        def self.attrreaderinstr(instr, sym)
+          instr.accept(AttrReaderInstruction.new(sym)) && instr.parse
+        end
+
+        def self.attrwriterinstr(instr, sym)
+          instr.accept(AttrWriterInstruction.new(sym)) && instr.parse
+        end
+
+        attr_accessor :visitor
+        attr_reader :method
+
+        def initialize(method)
+          @method = method
+        end
+
+        def accept(visitor)
+          visitor.visit(self)
+        end
+
+        def parse
+          [self.visitor]
+        end
+
+        private
+
+        def convert_accessor_to_name(sym)
+          sym.to_s.tr('@', '').downcase
+        end
+      end
+
+      class AttrReaderInstruction < AttrInstruction
+        def initialize(sym)
+          @sym = sym
+        end
+
+        def visit(obj)
+          matched = obj.method.original_name.to_s == convert_accessor_to_name(@sym)
+          obj.visitor = self if matched
+          matched
+        end
+
+        def reads_ivar?(_sym)
+          true
+        end
+
+        def writes_ivar?(_sym)
+          false
+        end
+
+        def putobjects?(sym)
+          @sym == sym
+        end
+      end
+
+      class AttrWriterInstruction < AttrInstruction
+        def initialize(sym)
+          @sym = sym
+        end
+
+        def visit(obj)
+          name = obj.method.original_name.to_s
+          matched = (name[-1] == '=') && (name[0..-2] == convert_accessor_to_name(@sym))
+          obj.visitor = self if matched
+          matched
+        end
+
+        def reads_ivar?(_sym)
+          false
+        end
+
+        def writes_ivar?(_sym)
+          true
+        end
+
+        def putobjects?(sym)
+          @sym == sym
+        end
+      end
+    end
+  end
+end

data/lib/system_navigation/method_hash.rb

@@ -0,0 +1,49 @@
+class SystemNavigation
+  class MethodHash < Hash
+    def self.create(**args)
+      self.new(args)
+    end
+
+
+    def initialize(based_on: nil, include_super: nil)
+      @hash = super()
+
+      if based_on
+        @hash.merge!({
+          public: {
+            instance: based_on.public_instance_methods(include_super),
+            singleton: based_on.singleton_class.public_instance_methods(include_super)
+          },
+          private: {
+            instance: based_on.private_instance_methods(include_super),
+            singleton: based_on.singleton_class.private_instance_methods(include_super)
+          },
+          protected: {
+            instance: based_on.protected_instance_methods(include_super),
+            singleton: based_on.singleton_class.protected_instance_methods(include_super)
+          }
+        })
+      else
+        @hash.merge!(empty_hash)
+      end
+    end
+
+    def as_array
+      self.values.map { |h| h[:instance] + h[:singleton] }.flatten.compact
+    end
+
+    def empty?
+      self == empty_hash
+    end
+
+    protected
+
+    def empty_hash
+      {
+        public: {instance: [], singleton: []},
+        private: {instance: [], singleton: []},
+        protected: {instance: [], singleton: []}
+      }
+    end
+  end
+end

data/lib/system_navigation/method_query.rb

@@ -0,0 +1,98 @@
+class SystemNavigation
+  class MethodQuery
+    def self.execute(collection:, query:, behavior: nil, **rest)
+      args = [query]
+      args << rest unless rest.empty?
+      self.new(collection, behavior).__send__(*args)
+    end
+
+    def initialize(collection, behavior)
+      @collection = collection
+      @behavior = behavior
+    end
+
+    def convert_to_methods
+      self.instance_and_singleton_do(
+        for_instance: proc { |_scope, _selectors, selector|
+          @behavior.instance_method(selector)
+        },
+
+        for_singleton: proc { |_scope, _selectors, selector|
+          @behavior.singleton_class.instance_method(selector)
+        }
+      )
+    end
+
+    def tupleize
+      self.instance_and_singleton_do(
+        for_all: proc { |_scope, _selectors, method| [method.name, method] }
+      )
+    end
+
+    def find_literal(literal:)
+      self.instance_and_singleton_do(
+        for_all: proc { |_scope, _selectors, method|
+          compiled_method = CompiledMethod.compile(method)
+          compiled_method.unwrap if compiled_method.has_literal?(literal)
+        }
+      )
+    end
+
+    def all_in_the_same_file?
+      self.instance_and_singleton_do(
+        for_all: proc { |_scope, _selectors, method| method.source_location[0] }
+      ).as_array.uniq.count == 1
+    end
+
+    def find_accessing_methods(ivar:, only_set:, only_get:)
+      self.instance_and_singleton_do(
+        for_all: proc { |_scope, _selectors, method|
+          compiled_method = CompiledMethod.compile(method)
+          if only_set
+            compiled_method.unwrap if compiled_method.writes_field?(ivar)
+          elsif only_get
+            compiled_method.unwrap if compiled_method.reads_field?(ivar)
+          else
+            if compiled_method.reads_field?(ivar) ||
+               compiled_method.writes_field?(ivar)
+              compiled_method.unwrap
+            end
+          end
+        }
+      )
+    end
+
+    def select_sent_messages
+      self.instance_and_singleton_do(
+        for_all: proc { |_scope, _selectors, method|
+          compiled_method = CompiledMethod.compile(method)
+          compiled_method.sent_messages.uniq.map(&:to_sym)
+        }
+      )
+    end
+
+    protected
+
+    def instance_and_singleton_do(for_instance: nil, for_singleton: nil, for_all: nil)
+      for_instance = for_all && for_singleton = for_all if for_all
+
+      @collection.inject(MethodHash.new) do |h, (scope, selectors)|
+        self.evaluate(callable: for_instance, group: :instance, hash: h,
+                      scope: scope, selectors: selectors)
+        self.evaluate(callable: for_singleton, group: :singleton, hash: h,
+                      scope: scope, selectors: selectors)
+        h
+      end
+    end
+
+    def evaluate(callable:, group:, hash:, scope:, selectors:)
+      return if callable.nil?
+
+      result = selectors[group].map do |selector|
+        callable.call(scope, selectors, selector)
+      end
+
+      hash[scope][group].concat(result)
+    end
+  end
+end

data/lib/system_navigation/module_refinement.rb

@@ -0,0 +1,226 @@
+class SystemNavigation
+  module ModuleRefinement
+    refine Module do
+      def with_all_sub_and_superclasses
+        Enumerator.new do |y|
+          self.with_all_subclasses.each { |klass| y << klass }
+          self.with_all_superclasses.each { |klass| y << klass }
+        end
+      end
+
+      def with_all_subclasses
+        Enumerator.new do |y|
+          self.all_subclasses.push(self).each { |subclass| y << subclass }
+        end
+      end
+
+      def all_subclasses
+        all_subclasses = []
+
+        ObjectSpace.each_object(self.singleton_class) do |klass|
+          all_subclasses.unshift(klass) if klass != self
+        end
+
+        all_subclasses
+      end
+
+      def with_all_superclasses
+        if self.superclass
+          Enumerator.new do |y|
+            y.yield self.superclass
+            self.superclass.with_all_superclasses.each { |klass| y << klass }
+          end
+        else
+          []
+        end
+      end
+
+      def select_methods_that_access(ivar, only_get, only_set)
+        own_methods = self.own_methods
+        if ancestor_methods.any?
+          ancestor_methods.each do |methods|
+            own_methods.merge!(methods) do |_group, old_h, new_h|
+              old_h.merge!(new_h) { |_key, oldval, newval| oldval | newval }
+            end
+          end
+        end
+
+        MethodQuery.execute(
+          collection: own_methods,
+          query: :find_accessing_methods,
+          ivar: ivar,
+          only_get: only_get,
+          only_set: only_set,
+          behavior: self).as_array
+      end
+
+      def select_methods_that_refer_to(literal)
+        MethodQuery.execute(
+          collection: self.own_methods,
+          query: :find_literal,
+          literal: literal,
+          behavior: self).as_array
+      end
+
+      def reachable_selectors
+        MethodHash.create(based_on: self, include_super: true)
+      end
+
+      def own_selectors
+        MethodHash.create(based_on: self, include_super: false)
+      end
+
+      def reachable_methods
+        MethodQuery.execute(
+          collection: self.reachable_selectors,
+          query: :convert_to_methods,
+          behavior: self)
+      end
+
+      def own_methods
+        MethodQuery.execute(
+          collection: self.own_selectors,
+          query: :convert_to_methods,
+          behavior: self)
+      end
+
+      def reachable_method_hash
+        MethodQuery.execute(
+          collection: self.reachable_methods,
+          query: :tupleize)
+      end
+
+      def own_method_hash
+        MethodQuery.execute(
+          collection: self.own_methods,
+          query: :tupleize)
+      end
+
+      def which_global_selectors_refer_to(literal)
+        who = []
+
+        self.own_selectors_and_methods do |selector, method|
+          if method.has_literal?(literal)
+            who << selector
+          end
+        end
+
+        who
+      end
+
+      def belongs_to?(gem_name)
+        gemspec = Gem::Specification.find_all_by_name(gem_name).last
+
+        return false if gemspec.nil? || self.own_selectors.empty?
+
+        pattern = %r{(?:/gems/#{gem_name}-#{gemspec.version}/)|(?:/lib/ruby/[[0-9]\.]+/#{gem_name}/)}
+        match_location = proc { |locations|
+          !!locations.max_by { |_k, value| value }[0].match(pattern)
+        }
+
+        if self.contains_only_rb_methods?
+          if self.all_neighbour_methods?
+            self.own_methods.as_array.all? do |method|
+              method.source_location.first.match(pattern)
+            end
+          else
+            grouped_locations = self.group_locations_by_path
+            return false if grouped_locations.empty?
+
+            if grouped_locations.all? { |l| l[0].match(pattern) }
+              true
+            else
+              match_location.call(grouped_locations)
+            end
+          end
+        else
+          grouped_locations = self.group_locations_by_path
+          grouped_locations.delete_if { |k, v| k.nil? }
+
+          if grouped_locations.empty?
+            false
+          else
+            match_location.call(grouped_locations)
+          end
+        end
+      end
+
+      def contains_only_rb_methods?
+        self.own_methods.as_array.all? { |method| method.source_location }
+      end
+
+      def all_neighbour_methods?
+        MethodQuery.execute(
+          collection: self.own_methods,
+          query: :all_in_the_same_file?)
+      end
+
+      def group_locations_by_path
+        Hash[
+          self.own_methods.as_array.map do |method|
+            method.source_location && method.source_location.first || nil
+          end.group_by(&:itself).map do |key, value|
+            [key, value.count]
+          end.reject { |k, _v| k.nil? }
+        ]
+      end
+
+      def select_matching_methods(string, match_case)
+        self.own_methods.as_array.select do |method|
+          compiled_method = CompiledMethod.compile(method)
+          if compiled_method.source_contains?(string, match_case)
+            compiled_method.unwrap
+          end
+        end
+      end
+
+      def select_c_methods
+        self.own_methods.as_array.select do |method|
+          compiled_method = CompiledMethod.compile(method)
+          if compiled_method.c_method?
+            compiled_method.unwrap
+          end
+        end
+      end
+
+      def select_rb_methods
+        self.own_methods.as_array.select do |method|
+          compiled_method = CompiledMethod.compile(method)
+          if compiled_method.rb_method?
+            compiled_method.unwrap
+          end
+        end
+      end
+
+      def select_senders_of(message)
+        self.own_methods.as_array.select do |method|
+          compiled_method = CompiledMethod.compile(method)
+          if compiled_method.sends_message?(message)
+            compiled_method.unwrap
+          end
+        end
+      end
+
+      def all_messages
+        MethodQuery.execute(
+          collection: self.own_methods,
+          query: :select_sent_messages)
+      end
+
+      def which_selectors_store_into(ivar)
+        self.selectors.select do |sel|
+          meth = self.instance_method(sel)
+          meth.writes_field?(ivar)
+        end
+      end
+
+      def ancestor_methods
+        AncestorMethodFinder.find_all_ancestors(of: self)
+      end
+
+      def includes_selector?(selector)
+        self.own_selectors.as_array.include?(selector)
+      end
+    end
+  end
+end