solargraph-rails 0.3.1 → 1.0.0.pre.1

data/lib/solargraph/rails/schema.rb

@@ -0,0 +1,100 @@
+module Solargraph
+  module Rails
+    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',
+        json: 'Hash',
+        bigint: 'Integer',
+        uuid: 'String',
+        inet: 'IPAddr'
+      }
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.reset
+        @instance = nil
+      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
+
+        if pins.any?
+          Solargraph.logger.debug(
+            "[Rails][Schema] added #{pins.map(&:name)} to #{ns.path}"
+          )
+        end
+        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, %i[lvar t] do |column_ast|
+            name = column_ast.children[2].children.last
+            type = column_ast.children[1]
+
+            next if type == :index
+            next if type == :check_constraint
+            schema[table_name][name] = ColumnData.new(type, column_ast)
+          end
+        end
+
+        walker.walk
+        schema
+      end
+    end
+  end
+end

data/lib/solargraph/rails/storage.rb

@@ -0,0 +1,48 @@
+module Solargraph
+  module Rails
+    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
+        if pins.any?
+          Solargraph.logger.debug(
+            "[Rails][Storage] added #{pins.map(&:name)} to #{ns.path}"
+          )
+        end
+        pins
+      end
+    end
+  end
+end

data/lib/solargraph/rails/types.yml

@@ -0,0 +1,24 @@
+ActionController::Metal#params:
+  return: ["ActionController::Parameters"]
+ActiveRecord::FinderMethods#find:
+  return: ["self", "Array<self>"]
+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/rails/util.rb

@@ -0,0 +1,68 @@
+module Solargraph
+  module Rails
+    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(
+          File.expand_path(path),
+          Solargraph::Range.from_to(0, 0, 0, 0)
+        )
+      end
+
+      def self.build_location(ast, path)
+        Solargraph::Location.new(
+          File.expand_path(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/rails/version.rb

@@ -1,5 +1,5 @@
 module Solargraph
   module Rails
-    VERSION = '0.3.1'
+    VERSION = '1.0.0.pre.1'
   end
 end

data/lib/solargraph/rails/walker.rb

@@ -0,0 +1,89 @@
+module Solargraph
+  module Rails
+    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_with_comments(source.code, source.filename)
+        end
+      end
+
+      def self.from_source(source)
+        self.new(*self.normalize_ast(source))
+      end
+
+      attr_reader :ast, :comments
+      def initialize(ast, comments = {})
+        @comments = comments
+        @ast = ast
+        @hooks = Hash.new([])
+      end
+
+      def on(node_type, args = [], &block)
+        @hooks[node_type] << Hook.new(node_type, args, &block)
+      end
+
+      def walk
+        @ast.is_a?(Array) ? @ast.each { |node| traverse(node) } : traverse(@ast)
+      end
+
+      private
+
+      def traverse(node)
+        return unless node.is_a?(::Parser::AST::Node)
+
+        @hooks[node.type].each { |hook| try_match(node, hook) }
+
+        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? do |child|
+              child.is_a?(::Parser::AST::Node) &&
+                match_children(hook.args[1..-1], child.children)
+            end
+          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

data/lib/solargraph-rails.rb

@@ -1,36 +1,71 @@
-# frozen_string_literal: true
-
 require 'solargraph'
-require 'solargraph/rails/version'
-require_relative 'solargraph/rails/pin_creator'
-require_relative 'solargraph/rails/ruby_parser'
-require_relative 'solargraph/rails/files_loader'
-require_relative 'solargraph/rails/meta_source/association/belongs_to_matcher'
-require_relative 'solargraph/rails/meta_source/association/has_many_matcher'
-require_relative 'solargraph/rails/meta_source/association/has_one_matcher'
-require_relative 'solargraph/rails/meta_source/association/has_and_belongs_to_many_matcher'
+require 'active_support/core_ext/string/inflections'
+
+require_relative 'solargraph/rails/util.rb'
+require_relative 'solargraph/rails/schema.rb'
+require_relative 'solargraph/rails/annotate.rb'
+require_relative 'solargraph/rails/autoload.rb'
+require_relative 'solargraph/rails/model.rb'
+require_relative 'solargraph/rails/devise.rb'
+require_relative 'solargraph/rails/walker.rb'
+require_relative 'solargraph/rails/rails_api.rb'
+require_relative 'solargraph/rails/delegate.rb'
+require_relative 'solargraph/rails/storage.rb'
+require_relative 'solargraph/rails/debug.rb'
+require_relative 'solargraph/rails/version.rb'
 
 module Solargraph
   module Rails
-    class DynamicAttributes < Solargraph::Convention::Base
-      def global yard_map
-        Solargraph::Environ.new(pins: parse_models)
-      end
+    class NodeParser
+      extend Solargraph::Parser::Legacy::ClassMethods
+    end
 
-      private
+    class Convention < Solargraph::Convention::Base
+      def global(yard_map)
+        Solargraph::Environ.new(
+          pins: Solargraph::Rails::RailsApi.instance.global(yard_map)
+        )
+      rescue => error
+        Solargraph.logger.warn(
+          error.message + "\n" + error.backtrace.join("\n")
+        )
+        EMPTY_ENVIRON
+      end
 
-      def parse_models
+      def local(source_map)
         pins = []
+        ds =
+          source_map.document_symbols.select do |n|
+            n.is_a?(Solargraph::Pin::Namespace)
+          end
+        ns = ds.first
 
-        FilesLoader.new(
-          Dir[File.join(Dir.pwd, 'app', 'models', '**', '*.rb')]
-        ).each { |file, contents| pins.push *PinCreator.new(file, contents).create_pins }
+        return EMPTY_ENVIRON unless ns
 
-        pins
+        pins += run_feature { Schema.instance.process(source_map, ns) }
+        pins += run_feature { Annotate.instance.process(source_map, ns) }
+        pins += run_feature { Model.instance.process(source_map, ns) }
+        pins += run_feature { Storage.instance.process(source_map, ns) }
+        pins += run_feature { Autoload.instance.process(source_map, ns, ds) }
+        pins += run_feature { Devise.instance.process(source_map, ns) }
+        pins += run_feature { Delegate.instance.process(source_map, ns) }
+        pins += run_feature { RailsApi.instance.local(source_map, ns) }
+
+        Solargraph::Environ.new(pins: pins)
+      end
+
+      private
+
+      def run_feature(&block)
+        yield
+      rescue => error
+        Solargraph.logger.warn(
+          error.message + "\n" + error.backtrace.join("\n")
+        )
+        []
       end
     end
   end
 end
 
-
-Solargraph::Convention.register Solargraph::Rails::DynamicAttributes
+Solargraph::Convention.register(Solargraph::Rails::Convention)

data/script/generate_definitions.rb

@@ -0,0 +1,134 @@
+require File.join(Dir.pwd, ARGV.first, 'config/environment')
+
+class Model < ActiveRecord::Base
+end
+
+def own_instance_methods(klass, test = klass.new)
+  (instance_methods(klass, test) - Object.methods).select do |m|
+    m.source_location && m.source_location.first.include?('gem')
+  end
+end
+
+def own_class_methods(klass)
+  (class_methods(klass) - Object.methods).select do |m|
+    m.source_location && m.source_location.first.include?('gem')
+  end
+end
+
+def instance_methods(klass, test = klass.new)
+  klass
+    .instance_methods(true)
+    .sort
+    .reject { |m| m.to_s.start_with?('_') || (test && !test.respond_to?(m)) }
+    .map { |m| klass.instance_method(m) }
+end
+
+def class_methods(klass)
+  klass
+    .methods(true)
+    .sort
+    .reject { |m| m.to_s.start_with?('_') || !klass.respond_to?(m) }
+    .map { |m| klass.method(m) }
+end
+
+def build_report(klass, test: klass.new)
+  result = {}
+  distribution = {}
+
+  own_class_methods(klass).each do |meth|
+    distribution[meth.source_location.first] ||= []
+    distribution[meth.source_location.first] << ".#{meth.name}"
+
+    result["#{klass.to_s}.#{meth.name}"] = { types: ['undefined'], skip: false }
+  end
+
+  own_instance_methods(klass, test).each do |meth|
+    distribution[meth.source_location.first] ||= []
+    distribution[meth.source_location.first] << "##{meth.name}"
+
+    result["#{klass.to_s}##{meth.name}"] = { types: ['undefined'], skip: false }
+  end
+
+  pp distribution
+  result
+end
+
+def core_ext_report(klass, test = klass.new)
+  result = {}
+  distribution = {}
+
+  class_methods(klass)
+    .select(&:source_location)
+    .select do |meth|
+      loc = meth.source_location.first
+      loc.include?('activesupport') && loc.include?('core_ext')
+    end
+    .each do |meth|
+      distribution[meth.source_location.first] ||= []
+      distribution[meth.source_location.first] << ".#{meth.name}"
+
+      result["#{klass.to_s}.#{meth.name}"] = {
+        types: ['undefined'],
+        skip: false
+      }
+    end
+
+  instance_methods(klass, test)
+    .select(&:source_location)
+    .select do |meth|
+      loc = meth.source_location.first
+      loc.include?('activesupport') && loc.include?('core_ext')
+    end
+    .each do |meth|
+      distribution[meth.source_location.first] ||= []
+      distribution[meth.source_location.first] << "##{meth.name}"
+
+      result["#{klass.to_s}##{meth.name}"] = {
+        types: ['undefined'],
+        skip: false
+      }
+    end
+
+  result
+end
+
+report = build_report(ActiveRecord::Base, test: Model.new)
+File.write('activerecord.yml', report.deep_stringify_keys.to_yaml)
+
+report = build_report(ActionController::Base)
+File.write('actioncontroller.yml', report.deep_stringify_keys.to_yaml)
+
+report = build_report(ActiveJob::Base)
+File.write('activejob.yml', report.deep_stringify_keys.to_yaml)
+
+Rails.application.routes.draw do
+  report = build_report(self.class, test: false)
+  File.write('routes.yml', report.deep_stringify_keys.to_yaml)
+end
+
+# [Array, String, Time, Date, Class, DateTime, File, Hash, Integer, Kernel].each do |klass|
+#   test = case klass
+#   when Time
+#     Time.now
+#   when Date
+#     Date.today
+#   when File
+#     false
+#   else
+#     klass.new rescue false
+#   end
+#
+#   report = core_ext_report(klass, test=test)
+#   File.write("#{klass.to_s}.yml", report.deep_stringify_keys.to_yaml)
+# end
+
+# binding.pry
+
+# File.write("activerecord.yml", result.deep_stringify_keys.to_yaml)
+
+# report = build_report(
+#   ActionController::Base,
+#   own_class_methods(ActionController::Base),
+#   own_instance_methods(ActionController::Base)
+# )
+# File.write("actioncontroller.yml", report.deep_stringify_keys.to_yaml)

data/solargraph-rails.gemspec

@@ -1,30 +1,32 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "solargraph/rails/version"
+require 'solargraph/rails/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "solargraph-rails"
-  spec.version       = Solargraph::Rails::VERSION
-  spec.authors       = ["Fritz Meissner"]
-  spec.email         = ["fritz.meissner@gmail.com"]
+  spec.name = 'solargraph-rails'
+  spec.version = Solargraph::Rails::VERSION
+  spec.authors = ['Fritz Meissner']
+  spec.email = ['fritz.meissner@gmail.com']
 
-  spec.summary       = %q{Solargraph plugin that adds Rails-specific code through a Convention}
-  spec.description   = %q{Add reflection on ActiveModel dynamic attributes that will be created at runtime}
-  spec.homepage      = 'https://github.com/iftheshoefritz/solargraph-rails'
-  spec.license       = "MIT"
+  spec.summary =
+    'Solargraph plugin that adds Rails-specific code through a Convention'
+  spec.description =
+    'Add reflection on ActiveModel dynamic attributes that will be created at runtime'
+  spec.homepage = 'https://github.com/iftheshoefritz/solargraph-rails'
+  spec.license = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.files =
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 2.2.10"
-  spec.add_development_dependency "rake", "~> 12.3.3"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.3'
+  spec.add_development_dependency 'rake', '~> 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 
-  spec.add_runtime_dependency "solargraph", ">= 0.41.1"
-  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency 'solargraph', '~> 0.44.2'
+  spec.add_runtime_dependency 'activesupport'
 end