steep-relaxed 1.9.3.3

data/lib/steep/project/dsl.rb

@@ -0,0 +1,268 @@
+module Steep
+  class Project
+    class DSL
+      module LibraryOptions
+        attr_reader :stdlib_root
+        attr_reader :core_root
+        attr_reader :collection_config_path
+
+        def stdlib_path(core_root:, stdlib_root:)
+          @core_root = Pathname(core_root)
+          @stdlib_root = Pathname(stdlib_root)
+        end
+
+        def repo_path(*paths)
+          @library_configured = true
+          repo_paths.push(*paths.map {|s| Pathname(s) })
+        end
+
+        def collection_config(path)
+          @library_configured = true
+          @collection_config_path = project.absolute_path(path)
+        end
+
+        def disable_collection
+          @library_configured = true
+          @collection_config_path = false
+        end
+
+        def library(*args)
+          @library_configured = true
+          libraries.push(*args)
+        end
+
+        def repo_paths
+          @repo_paths ||= []
+        end
+
+        def libraries
+          @libraries ||= []
+        end
+
+        def library_configured?
+          @library_configured
+        end
+
+        def to_library_options
+          config_path =
+            case collection_config_path
+            when Pathname
+              collection_config_path
+            when nil
+              default = project.absolute_path(RBS::Collection::Config::PATH)
+              if default.file?
+                default
+              end
+            when false
+              nil
+            end
+
+          Options.new.tap do |options|
+            options.libraries.push(*libraries)
+            options.paths = Options::PathOptions.new(
+              core_root: core_root,
+              stdlib_root: stdlib_root,
+              repo_paths: repo_paths
+            )
+            options.collection_config_path = config_path
+          end
+        end
+      end
+
+      module WithPattern
+        def check(*args)
+          sources.concat(args)
+        end
+
+        def ignore(*args)
+          ignored_sources.concat(args)
+        end
+
+        def signature(*args)
+          signatures.concat(args)
+        end
+
+        def ignore_signature(*args)
+          ignored_signatures.concat(args)
+        end
+
+        def sources
+          @sources ||= []
+        end
+
+        def ignored_sources
+          @ignored_sources ||= []
+        end
+
+        def signatures
+          @signatures ||= []
+        end
+
+        def ignored_signatures
+          @ignored_signatures ||= []
+        end
+
+        def source_pattern
+          Pattern.new(patterns: sources, ignores: ignored_sources, ext: ".rb")
+        end
+
+        def signature_pattern
+          Pattern.new(patterns: signatures, ignores: ignored_signatures, ext: ".rbs")
+        end
+      end
+
+      class TargetDSL
+        include LibraryOptions
+        include WithPattern
+
+        attr_reader :name
+        attr_reader :project
+        attr_reader :unreferenced
+        attr_reader :groups
+        attr_reader :implicitly_returns_nil
+
+        def initialize(name, project:)
+          @name = name
+          @core_root = nil
+          @stdlib_root = nil
+          @project = project
+          @collection_config_path = collection_config_path
+          @unreferenced = false
+          @implicitly_returns_nil = false
+          @groups = []
+        end
+
+        def initialize_copy(other)
+          @name = other.name
+          @libraries = other.libraries.dup
+          @sources = other.sources.dup
+          @signatures = other.signatures.dup
+          @ignored_sources = other.ignored_sources.dup
+          @ignored_signatures = other.ignored_signatures.dup
+          @repo_paths = other.repo_paths.dup
+          @core_root = other.core_root
+          @stdlib_root = other.stdlib_root
+          @code_diagnostics_config = other.code_diagnostics_config.dup
+          @project = other.project
+          @collection_config_path = other.collection_config_path
+          @unreferenced = other.unreferenced
+          @implicitly_returns_nil = other.implicitly_returns_nil
+          @groups = other.groups.dup
+        end
+
+        def unreferenced!(value = true)
+          @unreferenced = value
+        end
+
+        def implicitly_returns_nil!(value = true)
+          @implicitly_returns_nil = value
+        end
+
+        def configure_code_diagnostics(hash = nil)
+          if hash
+            code_diagnostics_config.merge!(hash)
+          end
+
+          yield code_diagnostics_config if block_given?
+        end
+
+        def code_diagnostics_config
+          @code_diagnostics_config ||= Diagnostic::Ruby.default.dup
+        end
+
+        def group(name, &block)
+          name = name.to_str.to_sym unless Symbol === name
+          group = GroupDSL.new(name, self)
+
+          Steep.logger.tagged "group=#{name}" do
+            group.instance_exec(&block) if block
+          end
+
+          groups << group
+        end
+      end
+
+      class GroupDSL
+        include WithPattern
+
+        attr_reader :name
+
+        attr_reader :target
+
+        attr_reader :code_diagnostics_config
+
+        def initialize(name, target)
+          @name = name
+          @target = target
+        end
+
+        def configure_code_diagnostics(config = nil)
+          if block_given?
+            if code_diagnostics_config
+              if config
+                code_diagnostics_config.merge!(config)
+              end
+            else
+              @code_diagnostics_config = (config || target.code_diagnostics_config).dup
+            end
+
+            yield (code_diagnostics_config || raise)
+          else
+            @code_diagnostics_config = config&.dup
+          end
+        end
+      end
+
+      include LibraryOptions
+
+      attr_reader :project
+
+      def initialize(project:)
+        @project = project
+      end
+
+      def self.parse(project, code, filename: "Steepfile")
+        Steep.logger.tagged filename do
+          dsl = self.new(project: project)
+          dsl.instance_eval(code, filename)
+          project.global_options = dsl.to_library_options
+        end
+      end
+
+      def self.eval(project, &block)
+        Steep.logger.tagged "DSL.eval" do
+          dsl = self.new(project: project)
+          dsl.instance_exec(&block)
+          project.global_options = dsl.to_library_options
+        end
+      end
+
+      def target(name, &block)
+        name = name.to_str.to_sym unless Symbol === name
+        dsl = TargetDSL.new(name, project: project)
+
+        Steep.logger.tagged "target=#{name}" do
+          dsl.instance_eval(&block) if block
+        end
+
+        target = Project::Target.new(
+          name: dsl.name,
+          source_pattern: dsl.source_pattern,
+          signature_pattern: dsl.signature_pattern,
+          options: dsl.library_configured? ? dsl.to_library_options : nil,
+          code_diagnostics_config: dsl.code_diagnostics_config,
+          project: project,
+          unreferenced: dsl.unreferenced,
+          implicitly_returns_nil: dsl.implicitly_returns_nil
+        )
+
+        dsl.groups.each do
+          group = Group.new(target, _1.name, _1.source_pattern, _1.signature_pattern, _1.code_diagnostics_config || target.code_diagnostics_config)
+          target.groups << group
+        end
+
+        project.targets << target
+      end
+    end
+  end
+end

data/lib/steep/project/group.rb

@@ -0,0 +1,31 @@
+module Steep
+  class Project
+    class Group
+      attr_reader :name
+      attr_reader :source_pattern
+      attr_reader :signature_pattern
+      attr_reader :target
+      attr_reader :code_diagnostics_config
+
+      def initialize(target, name, source_pattern, signature_pattern, code_diagnostics_config)
+        @target = target
+        @name = name
+        @source_pattern = source_pattern
+        @signature_pattern = signature_pattern
+        @code_diagnostics_config = code_diagnostics_config
+      end
+
+      def project
+        target.project
+      end
+
+      def possible_source_file?(path)
+        source_pattern =~ path
+      end
+
+      def possible_signature_file?(path)
+        signature_pattern =~ path
+      end
+    end
+  end
+end

data/lib/steep/project/options.rb

@@ -0,0 +1,63 @@
+module Steep
+  class Project
+    class Options
+      PathOptions = _ = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
+        # @implements PathOptions
+
+        def customized_stdlib?
+          stdlib_root != nil
+        end
+
+        def customized_core?
+          core_root != nil
+        end
+      end
+
+      attr_reader :libraries
+      attr_accessor :paths
+      attr_accessor :collection_config_path
+
+      def initialize
+        @paths = PathOptions.new(repo_paths: [])
+        @libraries = []
+      end
+
+      def collection_lock_path
+        if collection_config_path
+          RBS::Collection::Config.to_lockfile_path(collection_config_path)
+        end
+      end
+
+      def load_collection_lock(force: false)
+        @collection_lock = nil if force
+        @collection_lock ||=
+          if collection_config_path && collection_lock_path
+            case
+            when !collection_config_path.file?
+              collection_config_path
+            when !collection_lock_path.file?
+              collection_lock_path
+            else
+              begin
+                content = YAML.load_file(collection_lock_path)
+                lock_file = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: collection_lock_path, data: content)
+                lock_file.check_rbs_availability!
+                lock_file
+              rescue YAML::SyntaxError, RBS::Collection::Config::CollectionNotAvailable => exn
+                exn
+              end
+            end
+          end
+      end
+
+      def collection_lock
+        case config = load_collection_lock()
+        when RBS::Collection::Config::Lockfile
+          config
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/pattern.rb

@@ -0,0 +1,59 @@
+module Steep
+  class Project
+    class Pattern
+      attr_reader :patterns
+      attr_reader :ignores
+      attr_reader :prefixes
+      attr_reader :ignore_prefixes
+      attr_reader :ext
+
+      def initialize(patterns:, ignores: [], ext:)
+        @patterns = patterns
+        @ignores = ignores
+        @ext = ext
+
+        @prefixes = patterns.map do |pat|
+          if pat == "." || pat == "./"
+            ""
+          else
+            pat.delete_prefix("./").delete_suffix(File::Separator) << File::Separator
+          end
+        end
+        @ignore_prefixes = ignores.map do |pat|
+          if pat == "." || pat == "./"
+            ""
+          else
+            pat.delete_prefix("./").delete_suffix(File::Separator) << File::Separator
+          end
+        end
+      end
+
+      def =~(path)
+        unless path.is_a?(Pathname)
+          path = Pathname(path.to_s)
+        end
+
+        match?(path) && !ignore?(path)
+      end
+
+      def match?(path)
+        test_string(path, patterns, prefixes)
+      end
+
+      def ignore?(path)
+        test_string(path, ignores, ignore_prefixes)
+      end
+
+      def test_string(path, patterns, prefixes)
+        string = path.to_s
+
+        patterns.any? {|pat| File.fnmatch(pat, string, File::FNM_PATHNAME) } ||
+          prefixes.any? {|prefix| File.fnmatch("#{prefix}**/*#{ext}", string, File::FNM_PATHNAME) }
+      end
+
+      def empty?
+        patterns.empty?
+      end
+    end
+  end
+end

data/lib/steep/project/target.rb

@@ -0,0 +1,92 @@
+module Steep
+  class Project
+    class Target
+      attr_reader :name
+      attr_reader :target_options
+
+      attr_reader :source_pattern
+      attr_reader :signature_pattern
+      attr_reader :code_diagnostics_config
+      attr_reader :project
+      attr_reader :unreferenced
+      attr_reader :groups
+      attr_reader :implicitly_returns_nil
+
+      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:, project:, unreferenced:, implicitly_returns_nil:)
+        @name = name
+        @target_options = options
+        @source_pattern = source_pattern
+        @signature_pattern = signature_pattern
+        @code_diagnostics_config = code_diagnostics_config
+        @project = project
+        @unreferenced = unreferenced
+        @groups = []
+        @implicitly_returns_nil = implicitly_returns_nil
+      end
+
+      def options
+        target_options || project.global_options
+      end
+
+      def possible_source_file?(path)
+        if target = groups.find { _1.possible_source_file?(path) }
+          return target
+        end
+
+        if source_pattern =~ path
+          return self
+        end
+
+        nil
+      end
+
+      def possible_signature_file?(path)
+        if target = groups.find { _1.possible_signature_file?(path) }
+          return target
+        end
+
+        if signature_pattern =~ path
+          return self
+        end
+
+        nil
+      end
+
+      def new_env_loader()
+        Target.construct_env_loader(options: options, project: project)
+      end
+
+      def self.construct_env_loader(options:, project:)
+        repo = RBS::Repository.new(no_stdlib: options.paths.customized_stdlib?)
+
+        if options.paths.stdlib_root
+          repo.add(project.absolute_path(options.paths.stdlib_root))
+        end
+
+        options.paths.repo_paths.each do |path|
+          repo.add(project.absolute_path(path))
+        end
+
+        core_root_path =
+          if options.paths.customized_core?
+            if options.paths.core_root
+              project.absolute_path(options.paths.core_root)
+            end
+          else
+            RBS::EnvironmentLoader::DEFAULT_CORE_ROOT
+          end
+
+        loader = RBS::EnvironmentLoader.new(core_root: core_root_path, repository: repo)
+
+        options.libraries.each do |lib|
+          name, version = lib.split(/:/, 2)
+          name or raise
+          loader.add(library: name, version: version)
+        end
+        loader.add_collection(options.collection_lock) if options.collection_lock
+
+        loader
+      end
+    end
+  end
+end

data/lib/steep/project.rb

@@ -0,0 +1,78 @@
+module Steep
+  class Project
+    attr_reader :targets
+    attr_reader :steepfile_path
+    attr_reader :base_dir
+    attr_accessor :global_options
+
+    def initialize(steepfile_path:, base_dir: nil)
+      @targets = []
+      @steepfile_path = steepfile_path
+      @base_dir = if base_dir
+        base_dir
+      elsif steepfile_path
+        steepfile_path.parent
+      else
+        raise ArgumentError, "Project#initialize(base_dir:): neither base_dir nor steepfile_path given"
+      end
+
+      if steepfile_path and !steepfile_path.absolute?
+        raise ArgumentError, "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
+      end
+    end
+
+    def relative_path(path)
+      path.relative_path_from(base_dir)
+    rescue ArgumentError
+      path
+    end
+
+    def absolute_path(path)
+      (base_dir + path).cleanpath
+    end
+
+    def group_for_source_path(path)
+      path = relative_path(path)
+      targets.each do |target|
+        ret = target.possible_source_file?(path)
+        return ret if ret
+      end
+      nil
+    end
+
+    def group_for_path(path)
+      group_for_source_path(path) || group_for_signature_path(path)
+    end
+
+    def group_for_signature_path(path)
+      relative = relative_path(path)
+      targets.each do
+        ret = _1.possible_signature_file?(relative)
+        return ret if ret
+      end
+      nil
+    end
+
+    def target_for_source_path(path)
+      case group = group_for_source_path(path)
+      when Target
+        group
+      when Group
+        group.target
+      end
+    end
+
+    def target_for_signature_path(path)
+      case group = group_for_signature_path(path)
+      when Target
+        group
+      when Group
+        group.target
+      end
+    end
+
+    def target_for_path(path)
+      target_for_source_path(path) || target_for_signature_path(path)
+    end
+  end
+end