orbacle 0.1.0

data/lib/orbacle/builder/context.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class Builder
+    class Context
+      AnalyzedKlass = Struct.new(:klass_id, :method_visibility)
+
+      def initialize(filepath, selfie, nesting, analyzed_klass, analyzed_method, lenv)
+        @filepath = filepath.freeze
+        @selfie = selfie.freeze
+        @nesting = nesting.freeze
+        @analyzed_klass = analyzed_klass.freeze
+        @analyzed_method = analyzed_method.freeze
+        @lenv = lenv.freeze
+      end
+
+      attr_reader :filepath, :selfie, :nesting, :analyzed_klass, :analyzed_method, :lenv
+
+      def with_selfie(new_selfie)
+        self.class.new(filepath, new_selfie, nesting, analyzed_klass, analyzed_method, lenv)
+      end
+
+      def with_nesting(new_nesting)
+        self.class.new(filepath, selfie, new_nesting, analyzed_klass, analyzed_method, lenv)
+      end
+
+      def scope
+        nesting.to_scope
+      end
+
+      def with_analyzed_klass(new_klass_id)
+        self.class.new(filepath, selfie, nesting, AnalyzedKlass.new(new_klass_id, :public), analyzed_method, lenv)
+      end
+
+      def with_visibility(new_visibility)
+        self.class.new(filepath, selfie, nesting, AnalyzedKlass.new(analyzed_klass.klass_id, new_visibility), analyzed_method, lenv)
+      end
+
+      def with_analyzed_method(new_analyzed_method_id)
+        self.class.new(filepath, selfie, nesting, analyzed_klass, new_analyzed_method_id, lenv)
+      end
+
+      def merge_lenv(new_lenv)
+        self.class.new(filepath, selfie, nesting, analyzed_klass, analyzed_method, lenv.merge(new_lenv))
+      end
+
+      def lenv_fetch(key)
+        lenv.fetch(key, [])
+      end
+
+      def with_lenv(new_lenv)
+        self.class.new(filepath, selfie, nesting, analyzed_klass, analyzed_method, new_lenv)
+      end
+
+      def analyzed_klass_id
+        analyzed_klass.klass_id
+      end
+
+      def with_merged_lenvs(lenv1, lenv2)
+        final_lenv = {}
+
+        var_names = (lenv1.keys + lenv2.keys).uniq
+        var_names.each do |var_name|
+          final_lenv[var_name] = (lenv1.fetch(var_name, []) + lenv2.fetch(var_name, [])).uniq
+        end
+
+        with_lenv(final_lenv)
+      end
+    end
+  end
+end

data/lib/orbacle/builder/operator_assignment_processors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class Builder
+    module OperatorAssignmentProcessors
+      def handle_op_asgn(ast, context)
+        partial_assignment_ast, operator_name, argument_ast = ast.children
+
+        return process(
+          complete_assignment(
+            partial_assignment_ast,
+            Parser::AST::Node.new(:send, [
+              build_accessor_based_on_assignment(partial_assignment_ast),
+              operator_name,
+              argument_ast])),
+             context)
+      end
+
+      def handle_or_asgn(ast, context)
+        partial_assignment_ast, argument_ast = ast.children
+
+        return process(
+          complete_assignment(
+            partial_assignment_ast,
+            Parser::AST::Node.new(:or, [
+              build_accessor_based_on_assignment(partial_assignment_ast),
+              argument_ast])),
+             context)
+      end
+
+      def handle_and_asgn(ast, context)
+        partial_assignment_ast, argument_ast = ast.children
+
+        return process(
+          complete_assignment(
+            partial_assignment_ast,
+            Parser::AST::Node.new(:and, [
+              build_accessor_based_on_assignment(partial_assignment_ast),
+              argument_ast])),
+             context)
+      end
+
+      def build_accessor_based_on_assignment(assignment_ast)
+        case assignment_ast.type
+        when :lvasgn
+          var_name = assignment_ast.children[0]
+          Parser::AST::Node.new(:lvar, [var_name])
+        when :ivasgn
+          var_name = assignment_ast.children[0]
+          Parser::AST::Node.new(:ivar, [var_name])
+        when :cvasgn
+          var_name = assignment_ast.children[0]
+          Parser::AST::Node.new(:cvar, [var_name])
+        when :casgn
+          scope = assignment_ast.children[0]
+          var_name = assignment_ast.children[1]
+          Parser::AST::Node.new(:const, [scope, var_name])
+        when :send
+          send_obj = assignment_ast.children[0]
+          asgn_method_name = assignment_ast.children[1]
+          args = assignment_ast.children[2..-1]
+          Parser::AST::Node.new(:send, [send_obj, asgn_method_name, *args])
+        when :gvasgn
+          var_name = assignment_ast.children[0]
+          Parser::AST::Node.new(:gvar, [var_name])
+        else raise ArgumentError
+        end
+      end
+
+      def complete_assignment(partial_assignment_ast, full_rhs_ast)
+        if partial_assignment_ast.type == :send
+          send_obj_ast, accessor_method_name, _ = partial_assignment_ast.children
+          partial_assignment_ast.updated(nil, [send_obj_ast, "#{accessor_method_name}=", full_rhs_ast])
+        elsif [:lvasgn, :ivasgn, :cvasgn, :casgn, :gvasgn].include?(partial_assignment_ast.type)
+          partial_assignment_ast.append(full_rhs_ast)
+        end
+      end
+    end
+  end
+end

data/lib/orbacle/class_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class ClassType
+    def initialize(name)
+      @name = name
+    end
+
+    attr_reader :name
+
+    def ==(other)
+      self.class == other.class &&
+        self.name == other.name
+    end
+
+    def hash
+      [
+        self.class,
+        self.name,
+      ].hash ^ BIG_VALUE
+    end
+    alias eql? ==
+
+    def each_possible_type
+      yield self
+    end
+
+    def bottom?
+      false
+    end
+  end
+end

data/lib/orbacle/command_line_interface.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'pathname'
+require 'logger'
+require 'fileutils'
+require 'orbacle'
+require 'lsp'
+require 'json'
+
+module Orbacle
+  class CommandLineInterface
+    class Options
+      def initialize
+        @dir = Dir.pwd
+        @stats_file = Pathname.new(Dir.pwd).join("stats.json")
+      end
+      attr_reader :dir, :stats_file
+
+      def define_options(parser)
+        parser.banner = 'Usage: ./orbacle [options]'
+
+        parser.on('-d DIR', '--dir', 'Directory in which project resides') do |dir|
+          @dir = dir
+        end
+
+        parser.on("-h", "--help", "Prints this help") do
+          puts parser
+          exit
+        end
+      end
+    end
+
+    def call(args)
+      options = Options.new
+      OptionParser.new do |parser|
+        options.define_options(parser)
+      end.parse!(args)
+      call_command(args[0], options)
+    end
+
+    def call_command(command, options)
+      case command
+      when 'index' then index(options)
+      when 'file-server' then file_server(options)
+      when 'generate-datajs' then generate_datajs(options)
+      else no_command
+      end
+    end
+
+    private
+
+    def index(options)
+      logger = Logger.new(STDOUT)
+      project_root = options.dir
+
+      engine = Engine.new(logger)
+      engine.index(project_root)
+    ensure
+      File.open(options.stats_file, "w") {|f| f.write(engine.stats_recorder.all_stats.to_json) }
+    end
+
+    def file_server(options)
+      logger = Logger.new('/tmp/orbacle.log', 'monthly')
+      logger.level = Logger::INFO
+
+      engine = Engine.new(logger)
+      lang_server = LangServer.new(logger, engine)
+      server = Lsp::FileLanguageServer.new(lang_server, logger: logger)
+      server.start
+    end
+
+    def generate_datajs(options)
+      logger = Logger.new(STDOUT)
+
+      require 'base64'
+      project_root = options.dir
+      engine = Engine.new(logger)
+      tree, typing_result, graph = engine.index(project_root)
+
+      nodes = graph.vertices
+      filepaths = nodes.map {|n| n.location&.uri }.compact.uniq
+      type_pretty_printer = TypePrettyPrinter.new
+
+      File.open("data.js", "w") do |f|
+        f.puts "window.orbacleFiles = ["
+        filepaths.each do |filepath|
+          f.puts "  ['#{filepath[project_root.to_s.size..-1]}', `#{Base64.encode64(File.read(filepath))}`],"
+        end
+        f.puts "];"
+        f.puts "window.orbacleNodes = ["
+        sorted_nodes = nodes.reject {|n| n.location&.uri.nil? }
+        sorted_nodes.each do |node|
+          filepath = node.location.uri[project_root.to_s.size..-1]
+          pretty_type = type_pretty_printer.(typing_result[node])
+          f.puts "['#{node.type}', '#{pretty_type}', '#{filepath}', #{node.location&.start&.line&.to_i}, #{node.location&.start&.character&.to_i}, #{node.location&.end&.line&.to_i}, #{node.location&.end&.character&.to_i}],"
+        end
+        f.puts "];"
+      end
+    end
+
+    def no_command
+      puts "No command given."
+      exit
+    end
+  end
+end

data/lib/orbacle/const_name.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class ConstName
+    def self.from_string(str)
+      raise ArgumentError if str.start_with?("::")
+      new(str.split("::"))
+    end
+
+    def initialize(elems)
+      @elems = elems
+      raise ArgumentError if elems.empty?
+    end
+
+    attr_reader :elems
+
+    def ==(other)
+      elems == other.elems
+    end
+
+    def name
+      elems.last
+    end
+
+    def to_string
+      elems.join("::")
+    end
+
+    def scope
+      Scope.new(elems[0..-2], false)
+    end
+  end
+end

data/lib/orbacle/const_ref.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class ConstRef
+    def self.from_ast(ast, nesting)
+      full_name = AstUtils.const_to_string(ast)
+      from_full_name(full_name, nesting)
+    end
+
+    def self.from_full_name(full_name, nesting)
+      if full_name.start_with?("::")
+        name = full_name[2..-1]
+        new(ConstName.from_string(name), true, nesting)
+      else
+        new(ConstName.from_string(full_name), false, nesting)
+      end
+    end
+
+    def initialize(const_name, is_absolute, nesting)
+      @const_name = const_name
+      @is_absolute = is_absolute
+      @nesting = nesting
+    end
+
+    attr_reader :const_name, :is_absolute, :nesting
+
+    def to_full_const_name
+      if absolute?
+        const_name
+      else
+        ConstName.new([*nesting.to_primitive, const_name.to_string])
+      end
+    end
+
+    def absolute?
+      @is_absolute
+    end
+
+    def relative_name
+      const_name.to_string
+    end
+
+    def name
+      const_name.name
+    end
+
+    def ==(other)
+      const_name == other.const_name &&
+        is_absolute == other.is_absolute &&
+        nesting == other.nesting
+    end
+  end
+end

data/lib/orbacle/constants_tree.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class ConstantsTree
+    ScopeLevel = Struct.new(:elements, :children) do
+      def self.empty
+        new([], build_empty_hash)
+      end
+
+      def self.build_empty_hash
+        Hash.new {|h, k| h[k] = ScopeLevel.empty }
+      end
+    end
+
+    def initialize
+      @tree = ScopeLevel.build_empty_hash
+    end
+
+    def add_element(scope, name, element)
+      current_children = @tree
+      scope.elems.each do |scope_level|
+        current_children = current_children[scope_level].children
+      end
+      current_children[name].elements << element
+    end
+
+    def find_by_const_name(const_name)
+      scope_children = children_of_scope(const_name.scope)
+      scope_children[const_name.name].elements.first
+    end
+
+    def select_by_const_ref(const_ref)
+      nesting = const_ref.nesting
+      while !nesting.empty?
+        result = select_by_scope_and_name(nesting.to_scope.increase_by_ref(const_ref).decrease, const_ref.name)
+        return result if !result.empty?
+        nesting = nesting.decrease_nesting
+      end
+      select_by_scope_and_name(Scope.empty.increase_by_ref(const_ref).decrease, const_ref.name)
+    end
+
+    def find_by_const_ref(const_ref)
+      select_by_const_ref(const_ref).first
+    end
+
+    def find(&block)
+      find_in_children(@tree, &block)
+    end
+
+    private
+    def select_by_scope_and_name(scope, name)
+      scope_level = children_of_scope(scope)[name]
+      scope_level.elements
+    end
+
+    def children_of_scope(scope)
+      scope.elems.reduce(@tree) do |current_scope_level, scope_elem|
+        current_scope_level[scope_elem].children
+      end
+    end
+
+    def find_in_children(children, &block)
+      children.each do |_child_name, child_level|
+        child_level.elements.each do |constant|
+          return constant if block.call(constant)
+        end
+        result_in_child_level = find_in_children(child_level.children, &block)
+        return result_in_child_level if result_in_child_level
+      end
+      nil
+    end
+  end
+end