solargraph-arc 0.2.0

data/lib/solargraph/arc/delegate.rb

@@ -0,0 +1,34 @@
+module Solargraph
+  module Arc
+    class Delegate
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def process(source_map, ns)
+        return [] unless source_map.code.include?("delegate")
+
+        walker = Walker.from_source(source_map.source)
+        pins   = []
+
+        walker.on :send, [nil, :delegate] do |ast|
+          methods = ast.children[2..-1]
+            .map {|c| c.children.first }
+            .select {|s| s.is_a?(Symbol) }
+
+          methods.each do |meth|
+            pins << Util.build_public_method(
+              ns,
+              meth.to_s,
+              location: Util.build_location(ast, ns.filename)
+            )
+          end
+        end
+
+        walker.walk
+        Solargraph.logger.debug("[ARC][Delegate] added #{pins.map(&:name)} to #{ns.path}")
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/arc/devise.rb

@@ -0,0 +1,94 @@
+module Solargraph
+  module Arc
+    class Devise
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def initialize
+        @seen_devise_closures = []
+      end
+
+      def process(source_map, ns)
+        if source_map.filename.include?("app/models")
+          process_model(source_map, ns)
+        elsif source_map.filename.end_with?("app/controllers/application_controller.rb")
+          process_controller(source_map, ns)
+        else
+          []
+        end
+      end
+
+      private
+
+      def process_model(source_map, ns)
+        walker = Walker.from_source(source_map.source)
+        pins   = []
+
+        walker.on :send, [nil, :devise] do |ast|
+          @seen_devise_closures << ns
+
+          modules = ast.children[2..-1]
+            .map {|c| c.children.first }
+            .select {|s| s.is_a?(Symbol) }
+
+          modules.each do |mod|
+            pins << Util.build_module_include(
+              ns,
+              "Devise::Models::#{mod.to_s.capitalize}",
+              Util.build_location(ast, ns.filename)
+            )
+          end
+        end
+
+        walker.walk
+        Solargraph.logger.debug("[ARC][Devise] added #{pins.map(&:name)} to #{ns.path}") if pins.any?
+        pins
+      end
+
+      def process_controller(source_map, ns)
+        pins = [
+          Util.build_module_include(
+            ns,
+            "Devise::Controllers::Helpers",
+            Util.dummy_location(ns.filename)
+          )
+        ]
+
+        mapping_pins = @seen_devise_closures.map do |model_ns|
+          ast = Walker.normalize_ast(source_map.source)
+          mapping = model_ns.name.underscore
+
+          [
+            Util.build_public_method(
+              ns,
+              "authenticate_#{mapping}!",
+              location: Util.build_location(ast, ns.filename)
+            ),
+            Util.build_public_method(
+              ns,
+              "#{mapping}_signed_in?",
+              types: ["true", "false"],
+              location: Util.build_location(ast, ns.filename)
+            ),
+            Util.build_public_method(
+              ns,
+              "current_#{mapping}",
+              types: [model_ns.name, "nil"],
+              location: Util.build_location(ast, ns.filename)
+            ),
+            Util.build_public_method(
+              ns,
+              "#{mapping}_session",
+              location: Util.build_location(ast, ns.filename)
+            )
+          ]
+        end.flatten
+
+        pins += mapping_pins
+        Solargraph.logger.debug("[ARC][Devise] added #{pins.map(&:name)} to #{ns.path}") if pins.any?
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/arc/patches.rb

@@ -0,0 +1,50 @@
+module Solargraph
+  class ApiMap
+    # TODO: https://github.com/castwide/solargraph/pull/512
+    def get_complex_type_methods complex_type, context = '', internal = false
+      # This method does not qualify the complex type's namespace because
+      # it can cause conflicts between similar names, e.g., `Foo` vs.
+      # `Other::Foo`. It still takes a context argument to determine whether
+      # protected and private methods are visible.
+      return [] if complex_type.undefined? || complex_type.void?
+      result = Set.new
+      complex_type.each do |type|
+        if type.duck_type?
+          result.add Pin::DuckMethod.new(name: type.to_s[1..-1])
+          result.merge get_methods('Object')
+        else
+          unless type.nil? || type.name == 'void'
+            visibility = [:public]
+            if type.namespace == context || super_and_sub?(type.namespace, context)
+              visibility.push :protected
+              visibility.push :private if internal
+            end
+            result.merge get_methods(type.namespace, scope: type.scope, visibility: visibility)
+          end
+        end
+      end
+      result.to_a
+    end
+  end
+
+  class YardMap
+    # TODO: remove after https://github.com/castwide/solargraph/pull/509 is merged
+    def spec_for_require path
+      name = path.split('/').first
+      spec = Gem::Specification.find_by_name(name, @gemset[name])
+
+      # Avoid loading the spec again if it's going to be skipped anyway
+      #
+      return spec if @source_gems.include?(spec.name)
+      # Avoid loading the spec again if it's already the correct version
+      if @gemset[spec.name] && @gemset[spec.name] != spec.version
+        begin
+          return Gem::Specification.find_by_name(spec.name, "= #{@gemset[spec.name]}")
+        rescue Gem::LoadError
+          Solargraph.logger.warn "Unable to load #{spec.name} #{@gemset[spec.name]} specified by workspace, using #{spec.version} instead"
+        end
+      end
+      spec
+    end
+  end
+end

data/lib/solargraph/arc/rails_api.rb

@@ -0,0 +1,90 @@
+module Solargraph
+  module Arc
+    class RailsApi
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def global yard_map
+        return [] if yard_map.required.empty?
+
+        ann    = File.read(File.dirname(__FILE__) + "/annotations.rb")
+        source = Solargraph::Source.load_string(ann, "annotations.rb")
+        map    = Solargraph::SourceMap.map(source)
+
+        Solargraph.logger.debug("[Arc][Rails] found #{map.pins.size} pins in annotations")
+
+        overrides = YAML.load_file(File.dirname(__FILE__) + "/types.yml").map do |meth, data|
+          if data["return"]
+            Util.method_return(meth, data["return"])
+          elsif data["yieldself"]
+            Solargraph::Pin::Reference::Override.from_comment(
+              meth,
+              "@yieldself [#{data['yieldself'].join(',')}]"
+            )
+          elsif data["yieldparam"]
+            Solargraph::Pin::Reference::Override.from_comment(
+              meth,
+              "@yieldparam [#{data['yieldparam'].join(',')}]"
+            )
+          end
+        end
+
+        ns = Solargraph::Pin::Namespace.new(
+          name:  "ActionController::Base",
+          gates: ["ActionController::Base"]
+        )
+
+        definitions = [
+          Util.build_public_method(
+            ns,
+            "response",
+            types: ["ActionDispatch::Response"],
+            location: Util.dummy_location("whatever.rb")
+          ),
+          Util.build_public_method(
+            ns,
+            "request",
+            types: ["ActionDispatch::Request"],
+            location: Util.dummy_location("whatever.rb")
+          ),
+          Util.build_public_method(
+            ns,
+            "session",
+            types: ["ActionDispatch::Request::Session"],
+            location: Util.dummy_location("whatever.rb")
+          ),
+          Util.build_public_method(
+            ns,
+            "flash",
+            types: ["ActionDispatch::Flash::FlashHash"],
+            location: Util.dummy_location("whatever.rb")
+          )
+        ]
+
+        map.pins + definitions + overrides
+      end
+
+      def local(source_map, ns)
+        return [] unless source_map.filename.include?("db/migrate")
+        node = Walker.normalize_ast(source_map.source)
+
+        pins = [
+          Util.build_module_include(
+            ns,
+            "ActiveRecord::ConnectionAdapters::SchemaStatements",
+            Util.build_location(node, ns.filename)
+          ),
+          Util.build_module_extend(
+            ns,
+            "ActiveRecord::ConnectionAdapters::SchemaStatements",
+            Util.build_location(node, ns.filename)
+          )
+        ]
+
+        Solargraph.logger.debug("[ARC][RailsApi] added #{pins.map(&:name)} to #{ns.path}")
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/arc/relation.rb

@@ -0,0 +1,60 @@
+module Solargraph
+  module Arc
+    class Relation
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def process(source_map, ns)
+        return [] unless source_map.filename.include?("app/models")
+
+        walker = Walker.from_source(source_map.source)
+        pins   = []
+
+        walker.on :send, [nil, :belongs_to] do |ast|
+          pins << singular_association(ns, ast)
+        end
+
+        walker.on :send, [nil, :has_one] do |ast|
+          pins << singular_association(ns, ast)
+        end
+
+        walker.on :send, [nil, :has_many] do |ast|
+          pins << plural_association(ns, ast)
+        end
+
+        walker.on :send, [nil, :has_and_belongs_to_many] do |ast|
+          pins << plural_association(ns, ast)
+        end
+
+        walker.walk
+        Solargraph.logger.debug("[ARC][Relation] added #{pins.map(&:name)} to #{ns.path}") if pins.any?
+        pins
+      end
+
+      # TODO: handle custom class for relation
+      def plural_association(ns, ast)
+        relation_name = ast.children[2].children.first
+
+        Util.build_public_method(
+          ns,
+          relation_name.to_s,
+          types: ["ActiveRecord::Associations::CollectionProxy<#{relation_name.to_s.singularize.camelize}>"],
+          location: Util.build_location(ast, ns.filename)
+        )
+      end
+
+      # TODO: handle custom class for relation
+      def singular_association(ns, ast)
+        relation_name = ast.children[2].children.first
+
+        Util.build_public_method(
+          ns,
+          relation_name.to_s,
+          types: [relation_name.to_s.camelize],
+          location: Util.build_location(ast, ns.filename)
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/arc/schema.rb

@@ -0,0 +1,87 @@
+module Solargraph
+  module Arc
+    class Schema
+      ColumnData = Struct.new(:type, :ast)
+
+      RUBY_TYPES = {
+        decimal: 'BigDecimal',
+        float: 'BigDecimal',
+        integer: 'Integer',
+        date: 'Date',
+        datetime: 'ActiveSupport::TimeWithZone',
+        string: 'String',
+        boolean: 'Boolean',
+        text: 'String',
+        jsonb: 'Hash',
+        bigint: 'Integer',
+        inet: 'IPAddr'
+      }
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def initialize
+        @schema_present = File.exist?("db/schema.rb")
+      end
+
+      def process(source_map, ns)
+        return [] unless @schema_present
+        return [] unless source_map.filename.include?("app/models")
+
+        table_name = infer_table_name(ns)
+        table      = schema[table_name]
+
+        return [] unless table
+
+        pins = table.map do |column, data|
+          Util.build_public_method(
+            ns,
+            column,
+            types: [RUBY_TYPES.fetch(data.type.to_sym)],
+            location: Util.build_location(data.ast, "db/schema.rb")
+          )
+        end
+
+        Solargraph.logger.debug("[ARC][Schema] added #{pins.map(&:name)} to #{ns.path}") if pins.any?
+        pins
+      end
+
+      private
+
+      def schema
+        @extracted_schema ||= begin
+          ast = NodeParser.parse(File.read("db/schema.rb"), "db/schema.rb")
+          extract_schema(ast)
+        end
+      end
+
+      # TODO: support custom table names, by parsing `self.table_name = ` invokations
+      # inside model
+      def infer_table_name(ns)
+        ns.name.underscore.pluralize
+      end
+
+      def extract_schema(ast)
+        schema = {}
+
+        walker = Walker.new(ast)
+        walker.on :block, [:send, nil, :create_table] do |ast, query|
+          table_name = ast.children.first.children[2].children.last
+          schema[table_name] = {}
+
+          query.on :send, [:lvar, :t] do |column_ast|
+            name = column_ast.children[2].children.last
+            type = column_ast.children[1]
+
+            next if type == :index
+            schema[table_name][name] = ColumnData.new(type, column_ast)
+          end
+        end
+
+        walker.walk
+        schema
+      end
+    end
+  end
+end

data/lib/solargraph/arc/storage.rb

@@ -0,0 +1,42 @@
+module Solargraph
+  module Arc
+    class Storage
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def process(source_map, ns)
+        return [] unless source_map.filename.include?("app/models")
+
+        walker = Walker.from_source(source_map.source)
+        pins   = []
+
+        walker.on :send, [nil, :has_one_attached] do |ast|
+          name = ast.children[2].children.first
+
+          pins << Util.build_public_method(
+            ns,
+            name.to_s,
+            types: ["ActiveStorage::Attached::One"],
+            location: Util.build_location(ast, ns.filename)
+          )
+        end
+
+        walker.on :send, [nil, :has_many_attached] do |ast|
+          name = ast.children[2].children.first
+
+          pins << Util.build_public_method(
+            ns,
+            name.to_s,
+            types: ["ActiveStorage::Attached::Many"],
+            location: Util.build_location(ast, ns.filename)
+          )
+        end
+
+        walker.walk
+        Solargraph.logger.debug("[ARC][Storage] added #{pins.map(&:name)} to #{ns.path}") if pins.any?
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/arc/types.yml

@@ -0,0 +1,22 @@
+ActionController::Metal#params:
+  return: ["ActionController::Parameters"]
+ActionController::Cookies#cookies:
+  return: ["ActionDispatch::Cookies::CookieJar"]
+ActionDispatch::Flash::FlashHash#now:
+  return: ["ActionDispatch::Flash::FlashNow"]
+ActiveRecord::QueryMethods#where:
+  return: ["self", "ActiveRecord::Relation", "ActiveRecord::QueryMethods::WhereChain"]
+ActiveRecord::QueryMethods#not:
+  return: ["ActiveRecord::QueryMethods::WhereChain"]
+ActiveRecord::FinderMethods#find_by:
+  return: ["self", "nil"]
+Rails.application:
+  return: ["Rails::Application"]
+ActionDispatch::Routing::RouteSet#draw:
+  yieldself: ["ActionDispatch::Routing::Mapper"]
+ActiveRecord::ConnectionAdapters::SchemaStatements#create_table:
+  yieldparam: ["ActiveRecord::ConnectionAdapters::TableDefinition"]
+ActiveRecord::ConnectionAdapters::SchemaStatements#create_join_table:
+  yieldparam: ["ActiveRecord::ConnectionAdapters::TableDefinition"]
+ActiveRecord::ConnectionAdapters::SchemaStatements#change_table:
+  yieldparam: ["ActiveRecord::ConnectionAdapters::Table"]

data/lib/solargraph/arc/util.rb

@@ -0,0 +1,61 @@
+module Solargraph
+  module Arc
+    module Util
+      def self.build_public_method(ns, name, types: nil, location: nil, attribute: false, scope: :instance)
+        opts = {
+          name:      name,
+          location:  location,
+          closure:   ns,
+          scope:     scope,
+          attribute: attribute
+        }
+
+        comments = []
+        comments << "@return [#{types.join(',')}]" if types
+
+        opts[:comments] = comments.join("\n")
+
+        Solargraph::Pin::Method.new(**opts)
+      end
+
+      def self.build_module_include(ns, module_name, location)
+        Solargraph::Pin::Reference::Include.new(
+          closure:  ns,
+          name:     module_name,
+          location: location
+        )
+      end
+
+      def self.build_module_extend(ns, module_name, location)
+        Solargraph::Pin::Reference::Extend.new(
+          closure:  ns,
+          name:     module_name,
+          location: location
+        )
+      end
+
+      def self.dummy_location(path)
+        Solargraph::Location.new(
+          path,
+          Solargraph::Range.from_to(0, 0, 0, 0)
+        )
+      end
+
+      def self.build_location(ast, path)
+        Solargraph::Location.new(
+          path,
+          Solargraph::Range.from_to(
+            ast.location.first_line,
+            0,
+            ast.location.last_line,
+            ast.location.column
+          )
+        )
+      end
+
+      def self.method_return(path, type)
+        Solargraph::Pin::Reference::Override.method_return(path, type)
+      end
+    end
+  end
+end

data/lib/solargraph/arc/version.rb

@@ -0,0 +1,5 @@
+module Solargraph
+  module Arc
+    VERSION = "0.2.0"
+  end
+end

data/lib/solargraph/arc/walker.rb

@@ -0,0 +1,89 @@
+module Solargraph
+  module Arc
+    class Walker
+      class Hook
+        attr_reader :args, :proc, :node_type
+        def initialize(node_type, args, &block)
+          @node_type = node_type
+          @args = args
+          @proc = Proc.new(&block)
+        end
+      end
+
+      # https://github.com/castwide/solargraph/issues/522
+      def self.normalize_ast(source)
+        ast = source.node
+
+        if ast.is_a?(::Parser::AST::Node)
+          ast
+        else
+          NodeParser.parse(source.code, source.filename)
+        end
+      end
+
+      def self.from_source(source)
+        self.new(self.normalize_ast(source))
+      end
+
+      def initialize(ast)
+        @ast   = ast
+        @hooks = Hash.new([])
+      end
+
+      def on(node_type, args=[], &block)
+        @hooks[node_type] << Hook.new(node_type, args, &block)
+      end
+
+      def walk
+        if @ast.is_a?(Array)
+          @ast.each { |node| traverse(node) }
+        else
+          traverse(@ast)
+        end
+      end
+
+      private
+
+      def traverse(node)
+        return unless node.is_a?(::Parser::AST::Node)
+
+        @hooks[node.type].each do |hook|
+          try_match(node, hook)
+        end
+
+        node.children.each {|child| traverse(child) }
+      end
+
+      def try_match(node, hook)
+        return unless node.type == hook.node_type
+        return unless node.children
+
+        matched = hook.args.empty? || if node.children.first.is_a?(::Parser::AST::Node)
+          node.children.any? { |child| child.is_a?(::Parser::AST::Node) && match_children(hook.args[1..-1], child.children) }
+        else
+          match_children(hook.args, node.children)
+        end
+
+        if matched
+          if hook.proc.arity == 1
+            hook.proc.call(node)
+          elsif hook.proc.arity == 2
+            walker = Walker.new(node)
+            hook.proc.call(node, walker)
+            walker.walk
+          end
+        end
+      end
+
+      def match_children(args, children)
+        args.each_with_index.all? do |arg, i|
+          if children[i].is_a?(::Parser::AST::Node)
+            children[i].type == arg
+          else
+            children[i] == arg
+          end
+        end
+      end
+    end
+  end
+end