steep 1.10.0 → 2.0.0

data/lib/steep/server/target_group_files.rb

@@ -1,205 +1,178 @@
 module Steep
   module Server
     class TargetGroupFiles
-      attr_reader :project
-
-      attr_reader :source_paths, :signature_paths
-
-      attr_reader :library_paths
-
-      def initialize(project)
-        @project = project
-        @source_paths = {}
-        @signature_paths = {}
-        @library_paths = {}
-      end
+      class PathEnumerator
+        def initialize
+          @paths = {}
+        end
 
-      def add_path(path)
-        if target_group = project.group_for_signature_path(path)
-          signature_paths[path] = target_group
-          return true
+        def empty?
+          @paths.empty?
         end
-        if target_group = project.group_for_source_path(path)
-          source_paths[path] = target_group
-          return true
+
+        def paths
+          @paths.keys
         end
 
-        false
-      end
+        def registered_path?(path)
+          @paths.key?(path)
+        end
 
-      def add_library_path(target, *paths)
-        (library_paths[target.name] ||= Set[]).merge(paths)
-      end
+        def []=(path, target_group)
+          @paths[path] = target_group
+        end
 
-      def each_library_path(target, &block)
-        if block
-          library_paths.fetch(target.name).each(&block)
-        else
-          enum_for(_ = __method__, target)
+        def [](path)
+          @paths[path]
         end
-      end
 
-      def library_path?(path)
-        library_paths.each_value.any? { _1.include?(path) }
-      end
+        def each(&block)
+          if block
+            @paths.each do |path, target_group|
+              target = target_of(target_group)
+              group = group_of(target_group)
 
-      def signature_path_target(path)
-        case target_group = signature_paths.fetch(path, nil)
-        when Project::Target
-          target_group
-        when Project::Group
-          target_group.target
+              yield [path, target, group]
+            end
+          else
+            enum_for(_ = __method__)
+          end
         end
-      end
 
-      def source_path_target(path)
-        case target_group = source_paths.fetch(path, nil)
-        when Project::Target
-          target_group
-        when Project::Group
-          target_group.target
+        def target(path)
+          if target_group = @paths.fetch(path, nil)
+            target_of(target_group)
+          end
         end
-      end
 
-      def target_group_for_source_path(path)
-        ret = source_paths.fetch(path, nil)
-        case ret
-        when Project::Group
-          [ret.target, ret]
-        when Project::Target
-          [ret, nil]
-        end
-      end
+        def target_group(path)
+          if target_group = @paths.fetch(path, nil)
+            target = target_of(target_group)
+            group = group_of(target_group)
 
-      def target_group_for_signature_path(path)
-        ret = signature_paths.fetch(path, nil)
-        case ret
-        when Project::Group
-          [ret.target, ret]
-        when Project::Target
-          [ret, nil]
+            [target, group]
+          end
         end
-      end
 
-      def each_group_signature_path(target, no_group = false, &block)
-        if block
-          signature_paths.each_key do |path|
-            t, g = target_group_for_signature_path(path)
-
-            if target.is_a?(Project::Target)
-              if no_group
-                yield path if t == target && g == nil
-              else
-                yield path if t == target
-              end
-            else
-              yield path if g == target
+        def each_project_path(except: nil, &block)
+          if block
+            @paths.each_key do |path|
+              target, group = target_group(path) || raise
+
+              next if target == except
+
+              yield [path, target, group, group || target]
             end
+          else
+            enum_for(_ = __method__, except: except)
           end
-        else
-          enum_for(_ = __method__, target, no_group)
         end
-      end
 
-      def each_target_signature_path(target, group, &block)
-        raise unless group.target == target if group
+        def each_target_path(target, except: nil, &block)
+          if block
+            @paths.each_key do |path|
+              t, g = target_group(path) || raise
 
-        if block
-          signature_paths.each_key do |path|
-            t, g = target_group_for_signature_path(path)
+              if except
+                next if g == except
+              end
 
-            next unless target == t
-            next if group && group == g
+              next unless t == target
 
-            yield path
+              yield [path, t, g, g || t]
+            end
+          else
+            enum_for(_ = __method__, target, except: except)
           end
-        else
-          enum_for(_ = __method__, target, group)
         end
-      end
 
-      def each_project_signature_path(target, &block)
-        if block
-          signature_paths.each do |path, target_group|
-            t =
-              case target_group
-              when Project::Target
-                target_group
-              when Project::Group
-                target_group.target
+        def each_group_path(target_group, include_sub_groups: false, &block)
+          if block
+            if include_sub_groups
+              target_group.is_a?(Project::Target) or raise "target_group must be a target if `include_sub_groups:` is given. (#{target_group.name})"
+              each_target_path(target_group, &block)
+            else
+              @paths.each do |path, tg|
+                if tg == target_group
+                  t, g = target_group(path) || raise
+                  yield [path, t, g, g || t]
+                end
               end
-
-            if target
-              next if t.unreferenced
-              next if t == target
             end
+          else
+            enum_for(_ = __method__, target_group, include_sub_groups: include_sub_groups)
+          end
+        end
 
-            yield path
+        def target_of(target_group)
+          case target_group
+          when Project::Target
+            target_group
+          when Project::Group
+            target_group.target
           end
-        else
-          enum_for(_ = __method__, target)
         end
-      end
 
-      def each_group_source_path(target, no_group = false, &block)
-        if block
-          source_paths.each_key do |path|
-            t, g = target_group_for_source_path(path)
-
-            if target.is_a?(Project::Target)
-              if no_group
-                yield path if t == target && g == nil
-              else
-                yield path if t == target
-              end
-            else
-              yield path if g == target
-            end
+        def group_of(target_group)
+          case target_group
+          when Project::Group
+            target_group
           end
-        else
-          enum_for(_ = __method__, target, no_group)
         end
       end
 
-      def each_target_source_path(target, group, &block)
-        raise unless group.target == target if group
+      attr_reader :project
 
-        if block
-          source_paths.each_key do |path|
-            t, g = target_group_for_source_path(path)
+      attr_reader :source_paths, :signature_paths, :inline_paths
 
-            next unless target == t
-            next if group && group == g
+      attr_reader :library_paths
 
-            yield path
-          end
-        else
-          enum_for(_ = __method__, target, group)
+      def initialize(project)
+        @project = project
+        @source_paths = PathEnumerator.new
+        @signature_paths = PathEnumerator.new
+        @inline_paths = PathEnumerator.new
+        @library_paths = {}
+      end
+
+      def add_path(path)
+        if target_group = project.group_for_signature_path(path)
+          signature_paths[path] = target_group
+          return true
         end
+        if target_group = project.group_for_inline_source_path(path)
+          inline_paths[path] = target_group
+          return true
+        end
+        if target_group = project.group_for_source_path(path)
+          source_paths[path] = target_group
+          return true
+        end
+
+        false
       end
 
-      def each_project_source_path(target, &block)
-        if block
-          source_paths.each do |path, target_group|
-            t =
-              case target_group
-              when Project::Target
-                target_group
-              when Project::Group
-                target_group.target
-              end
+      def registered_path?(path)
+        source_paths.registered_path?(path) ||
+          signature_paths.registered_path?(path) ||
+          inline_paths.registered_path?(path)
+      end
 
-            if target
-              next if t.unreferenced
-              next if t == target
-            end
+      def add_library_path(target, *paths)
+        (library_paths[target.name] ||= Set[]).merge(paths)
+      end
 
-            yield path
-          end
+      def each_library_path(target, &block)
+        if block
+          library_paths.fetch(target.name).each(&block)
         else
           enum_for(_ = __method__, target)
         end
       end
+
+      def library_path?(path)
+        library_paths.each_value.any? { _1.include?(path) }
+      end
     end
   end
 end