ocran 1.3.18 → 1.4.0

data/lib/ocran/file_path_set.rb

@@ -1,69 +1,69 @@
-# frozen_string_literal: true
-require "pathname"
-require_relative "refine_pathname"
-
-module Ocran
-  class FilePathSet
-    using RefinePathname
-    include Enumerable
-
-    def initialize
-      @set = {}
-    end
-
-    def add(source, target)
-      add?(source, target)
-      self
-    end
-
-    # Adds a source and target path pair to the set and validates the paths before adding.
-    # This method performs various checks to ensure the source path is an absolute path
-    # and the target path is a relative path that does not include '.' or '..'.
-    # If a conflict is detected (i.e., different source for the same target),
-    # it raises an exception.
-    #
-    # @param [String, Pathname] source - The source file path; must be an absolute path.
-    # @param [String, Pathname] target - The target file path; must be a relative path.
-    # @return [self, nil] Returns self if the path pair is added successfully,
-    #                     returns nil if the same source and target pair is already present.
-    # @raise [ArgumentError] If the source is not an absolute path, if the target is not a relative path,
-    #                        or if the target includes '.' or '..'.
-    # @raise [RuntimeError] If a conflicting source is found for the same target.
-    def add?(source, target)
-      source = Pathname.new(source) unless source.is_a?(Pathname)
-      source = source.cleanpath
-      unless source.absolute?
-        raise ArgumentError, "Source path must be absolute, given: #{source}"
-      end
-
-      target = Pathname.new(target) unless target.is_a?(Pathname)
-      target = target.cleanpath
-      unless target.relative?
-        raise ArgumentError, "Target path must be relative, given: #{target}"
-      end
-      if %w(. ..).include?(target.each_filename.first)
-        raise ArgumentError, "Relative paths such as '.' or '..' are not allowed, given: #{target}"
-      end
-
-      if (path = @set[target])
-        if path.eql?(source)
-          return nil
-        else
-          raise "Conflicting sources for the same target. Target: #{target}, Existing Source: #{path}, Given Source: #{source}"
-        end
-      end
-
-      @set[target] = source
-      self
-    end
-
-    def each
-      return to_enum(__method__) unless block_given?
-      @set.each { |target, source| yield(source, target) }
-    end
-
-    def to_a
-      each.to_a
-    end
-  end
-end
+# frozen_string_literal: true
+require "pathname"
+require_relative "refine_pathname"
+
+module Ocran
+  class FilePathSet
+    using RefinePathname
+    include Enumerable
+
+    def initialize
+      @set = {}
+    end
+
+    def add(source, target)
+      add?(source, target)
+      self
+    end
+
+    # Adds a source and target path pair to the set and validates the paths before adding.
+    # This method performs various checks to ensure the source path is an absolute path
+    # and the target path is a relative path that does not include '.' or '..'.
+    # If a conflict is detected (i.e., different source for the same target),
+    # it raises an exception.
+    #
+    # @param [String, Pathname] source - The source file path; must be an absolute path.
+    # @param [String, Pathname] target - The target file path; must be a relative path.
+    # @return [self, nil] Returns self if the path pair is added successfully,
+    #                     returns nil if the same source and target pair is already present.
+    # @raise [ArgumentError] If the source is not an absolute path, if the target is not a relative path,
+    #                        or if the target includes '.' or '..'.
+    # @raise [RuntimeError] If a conflicting source is found for the same target.
+    def add?(source, target)
+      source = Pathname.new(source) unless source.is_a?(Pathname)
+      source = source.cleanpath
+      unless source.absolute?
+        raise ArgumentError, "Source path must be absolute, given: #{source}"
+      end
+
+      target = Pathname.new(target) unless target.is_a?(Pathname)
+      target = target.cleanpath
+      unless target.relative?
+        raise ArgumentError, "Target path must be relative, given: #{target}"
+      end
+      if %w(. ..).include?(target.each_filename.first)
+        raise ArgumentError, "Relative paths such as '.' or '..' are not allowed, given: #{target}"
+      end
+
+      if (path = @set[target])
+        if path.eql?(source)
+          return nil
+        else
+          raise "Conflicting sources for the same target. Target: #{target}, Existing Source: #{path}, Given Source: #{source}"
+        end
+      end
+
+      @set[target] = source
+      self
+    end
+
+    def each
+      return to_enum(__method__) unless block_given?
+      @set.each { |target, source| yield(source, target) }
+    end
+
+    def to_a
+      each.to_a
+    end
+  end
+end

data/lib/ocran/gem_spec_queryable.rb

@@ -1,172 +1,172 @@
-# frozen_string_literal: true
-require "rubygems"
-require "pathname"
-require_relative "refine_pathname"
-
-module Ocran
-  module GemSpecQueryable
-    using RefinePathname
-
-    GEM_SCRIPT_RE = /\.rbw?$/
-    GEM_EXTRA_RE = %r{(
-      # Auxiliary files in the root of the gem
-      ^(\.\/)?(History|Install|Manifest|README|CHANGES|Licen[sc]e|Contributors|ChangeLog|BSD|GPL).*$ |
-      # Installation files in the root of the gem
-      ^(\.\/)?(Rakefile|setup.rb|extconf.rb)$ |
-      # Documentation/test directories in the root of the gem
-      ^(\.\/)?(doc|ext|examples|test|tests|benchmarks|spec)\/ |
-      # Directories anywhere
-      (^|\/)(\.autotest|\.svn|\.cvs|\.git)(\/|$) |
-      # Unlikely extensions
-      \.(rdoc|c|cpp|c\+\+|cxx|h|hxx|hpp|obj|o|a)$
-    )}xi
-    GEM_NON_FILE_RE = /(#{GEM_EXTRA_RE}|#{GEM_SCRIPT_RE})/
-
-    class << self
-      # find_gem_path method searches for the path of the gem containing the
-      # specified path. The 'path' argument is a file or directory path.
-      # It checks each gem's installation path in Gem.path to see if the
-      # specified path is a subpath. Returns the gem's path if found, or
-      # nil if not found.
-      def find_gem_path(path)
-        return unless defined?(Gem)
-
-        Gem.path.find { |gem_path| Pathname(path).subpath?(gem_path) }
-      end
-
-      # find_spec_file method searches for the path of the gemspec file of
-      # the gem containing the specified path. The 'path' argument is a file
-      # or directory path. It searches within the "gems" directory in each
-      # directory listed in Gem.path to check if the specified path is a
-      # subpath. If the gemspec file exists, it returns its path; otherwise,
-      # it returns nil.
-      def find_spec_file(path)
-        return unless defined?(Gem)
-
-        feature = Pathname(path)
-        Gem.path.each do |gem_path|
-          gems_dir = File.join(gem_path, "gems")
-          next unless feature.subpath?(gems_dir)
-
-          full_name = feature.relative_path_from(gems_dir).each_filename.first
-          spec_path = File.join(gem_path, "specifications", "#{full_name}.gemspec")
-          return spec_path if File.exist?(spec_path)
-        end
-        nil
-      end
-
-      # find_spec method searches and returns a Gem::Specification object
-      # based on the specified path. Internally, it uses find_spec_file to
-      # obtain the path to the gemspec file, and if that file exists, it
-      # calls Gem::Specification.load to load the gem's specifications.
-      # Returns the loaded Gem::Specification object, or nil if the gemspec
-      # file does not exist.
-      def find_spec(path)
-        return unless defined?(Gem)
-
-        spec_file = find_spec_file(path)
-        spec_file && Gem::Specification.load(spec_file)
-      end
-
-      def scanning_gemfile(gemfile_path)
-        # Ensure the necessary libraries are loaded to scan the Gemfile.
-        # This is particularly useful in custom-built Ruby environments or
-        # where certain libraries might be excluded.
-        %w[rubygems bundler].each do |lib|
-          require lib
-        rescue LoadError
-          raise "Couldn't scan Gemfile, unable to load #{lib}"
-        end
-
-        ENV["BUNDLE_GEMFILE"] = gemfile_path.to_s
-        # Bundler.load.specs includes the spec for Bundler itself
-        Bundler.load.specs.to_a
-      end
-
-      # Fall back to gem detection
-      def detect_gems_from(features, verbose: false)
-        features.inject([]) do |gems, feature|
-          if gems.any? { |spec| feature.subpath?(spec.gem_dir) }
-            # Skip if found in known Gem dir
-          elsif (spec = GemSpecQueryable.find_spec(feature))
-            gems << spec
-          else
-            puts "Failed to load gemspec for #{feature}" if verbose
-          end
-
-          gems
-        end
-      end
-
-      def gem_inclusion_set(spec_name, gem_options)
-        include = [:loaded, :files]
-        gem_options.each do |negate, option, list|
-          next unless list.nil? || list.include?(spec_name)
-
-          case option
-          when :minimal
-            include = [:loaded]
-          when :guess
-            include = [:loaded, :files]
-          when :all
-            include = [:scripts, :files]
-          when :full
-            include = [:scripts, :files, :extras]
-          when :spec
-            include = [:spec]
-          when :scripts, :files, :extras
-            if negate
-              include.delete(option)
-            else
-              include.push(option)
-            end
-          else
-            raise "Invalid Gem content detection option: #{option}"
-          end
-        end
-        include.uniq!
-        include
-      end
-    end
-
-    def gem_root = Pathname(gem_dir)
-
-    # Find the selected files
-    def gem_root_files = gem_root.find.select(&:file?)
-
-    def script_files
-      gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
-    end
-
-    def extra_files
-      gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix =~ GEM_EXTRA_RE }
-    end
-
-    def resource_files
-      files = gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix !~ GEM_NON_FILE_RE }
-      files << Pathname(gem_build_complete_path) if File.exist?(gem_build_complete_path)
-      files
-    end
-
-    def find_gem_files(file_sets, features_from_gems)
-      actual_files = file_sets.flat_map do |set|
-        case set
-        when :spec
-          files.map { |file| Pathname(file) }
-        when :loaded
-          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
-        when :files
-          resource_files
-        when :extras
-          extra_files
-        when :scripts
-          script_files
-        else
-          raise "Invalid file set: #{set}. Please specify a valid file set (:spec, :loaded, :files, :extras, :scripts)."
-        end
-      end
-      actual_files.uniq
-      actual_files
-    end
-  end
-end
+# frozen_string_literal: true
+require "rubygems"
+require "pathname"
+require_relative "refine_pathname"
+
+module Ocran
+  module GemSpecQueryable
+    using RefinePathname
+
+    GEM_SCRIPT_RE = /\.rbw?$/
+    GEM_EXTRA_RE = %r{(
+      # Auxiliary files in the root of the gem
+      ^(\.\/)?(History|Install|Manifest|README|CHANGES|Licen[sc]e|Contributors|ChangeLog|BSD|GPL).*$ |
+      # Installation files in the root of the gem
+      ^(\.\/)?(Rakefile|setup.rb|extconf.rb)$ |
+      # Documentation/test directories in the root of the gem
+      ^(\.\/)?(doc|ext|examples|test|tests|benchmarks|spec)\/ |
+      # Directories anywhere
+      (^|\/)(\.autotest|\.svn|\.cvs|\.git)(\/|$) |
+      # Unlikely extensions
+      \.(rdoc|c|cpp|c\+\+|cxx|h|hxx|hpp|obj|o|a)$
+    )}xi
+    GEM_NON_FILE_RE = /(#{GEM_EXTRA_RE}|#{GEM_SCRIPT_RE})/
+
+    class << self
+      # find_gem_path method searches for the path of the gem containing the
+      # specified path. The 'path' argument is a file or directory path.
+      # It checks each gem's installation path in Gem.path to see if the
+      # specified path is a subpath. Returns the gem's path if found, or
+      # nil if not found.
+      def find_gem_path(path)
+        return unless defined?(Gem)
+
+        Gem.path.find { |gem_path| Pathname(path).subpath?(gem_path) }
+      end
+
+      # find_spec_file method searches for the path of the gemspec file of
+      # the gem containing the specified path. The 'path' argument is a file
+      # or directory path. It searches within the "gems" directory in each
+      # directory listed in Gem.path to check if the specified path is a
+      # subpath. If the gemspec file exists, it returns its path; otherwise,
+      # it returns nil.
+      def find_spec_file(path)
+        return unless defined?(Gem)
+
+        feature = Pathname(path)
+        Gem.path.each do |gem_path|
+          gems_dir = File.join(gem_path, "gems")
+          next unless feature.subpath?(gems_dir)
+
+          full_name = feature.relative_path_from(gems_dir).each_filename.first
+          spec_path = File.join(gem_path, "specifications", "#{full_name}.gemspec")
+          return spec_path if File.exist?(spec_path)
+        end
+        nil
+      end
+
+      # find_spec method searches and returns a Gem::Specification object
+      # based on the specified path. Internally, it uses find_spec_file to
+      # obtain the path to the gemspec file, and if that file exists, it
+      # calls Gem::Specification.load to load the gem's specifications.
+      # Returns the loaded Gem::Specification object, or nil if the gemspec
+      # file does not exist.
+      def find_spec(path)
+        return unless defined?(Gem)
+
+        spec_file = find_spec_file(path)
+        spec_file && Gem::Specification.load(spec_file)
+      end
+
+      def scanning_gemfile(gemfile_path)
+        # Ensure the necessary libraries are loaded to scan the Gemfile.
+        # This is particularly useful in custom-built Ruby environments or
+        # where certain libraries might be excluded.
+        %w[rubygems bundler].each do |lib|
+          require lib
+        rescue LoadError
+          raise "Couldn't scan Gemfile, unable to load #{lib}"
+        end
+
+        ENV["BUNDLE_GEMFILE"] = gemfile_path.to_s
+        # Bundler.load.specs includes the spec for Bundler itself
+        Bundler.load.specs.to_a
+      end
+
+      # Fall back to gem detection
+      def detect_gems_from(features, verbose: false)
+        features.inject([]) do |gems, feature|
+          if gems.any? { |spec| feature.subpath?(spec.gem_dir) }
+            # Skip if found in known Gem dir
+          elsif (spec = GemSpecQueryable.find_spec(feature))
+            gems << spec
+          else
+            puts "Failed to load gemspec for #{feature}" if verbose
+          end
+
+          gems
+        end
+      end
+
+      def gem_inclusion_set(spec_name, gem_options)
+        include = [:loaded, :files]
+        gem_options.each do |negate, option, list|
+          next unless list.nil? || list.include?(spec_name)
+
+          case option
+          when :minimal
+            include = [:loaded]
+          when :guess
+            include = [:loaded, :files]
+          when :all
+            include = [:scripts, :files]
+          when :full
+            include = [:scripts, :files, :extras]
+          when :spec
+            include = [:spec]
+          when :scripts, :files, :extras
+            if negate
+              include.delete(option)
+            else
+              include.push(option)
+            end
+          else
+            raise "Invalid Gem content detection option: #{option}"
+          end
+        end
+        include.uniq!
+        include
+      end
+    end
+
+    def gem_root = Pathname(gem_dir)
+
+    # Find the selected files
+    def gem_root_files = gem_root.find.select(&:file?)
+
+    def script_files
+      gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
+    end
+
+    def extra_files
+      gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix =~ GEM_EXTRA_RE }
+    end
+
+    def resource_files
+      files = gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix !~ GEM_NON_FILE_RE }
+      files << Pathname(gem_build_complete_path) if File.exist?(gem_build_complete_path)
+      files
+    end
+
+    def find_gem_files(file_sets, features_from_gems)
+      actual_files = file_sets.flat_map do |set|
+        case set
+        when :spec
+          files.map { |file| Pathname(file) }
+        when :loaded
+          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
+        when :files
+          resource_files
+        when :extras
+          extra_files
+        when :scripts
+          script_files
+        else
+          raise "Invalid file set: #{set}. Please specify a valid file set (:spec, :loaded, :files, :extras, :scripts)."
+        end
+      end
+      actual_files.uniq
+      actual_files
+    end
+  end
+end

data/lib/ocran/host_config_helper.rb

@@ -1,44 +1,57 @@
-require "rbconfig"
-require "pathname"
-
-module Ocran
-  # Variables describing the host's build environment.
-  module HostConfigHelper
-    module_function
-
-    def exec_prefix
-      @exec_prefix ||= Pathname.new(RbConfig::CONFIG["exec_prefix"])
-    end
-
-    def sitelibdir
-      @sitelibdir ||= Pathname.new(RbConfig::CONFIG["sitelibdir"])
-    end
-
-    def bindir
-      @bindir ||= Pathname.new(RbConfig::CONFIG["bindir"])
-    end
-
-    def libruby_so
-      @libruby_so ||= Pathname.new(RbConfig::CONFIG["LIBRUBY_SO"])
-    end
-
-    def exe_extname
-      RbConfig::CONFIG["EXEEXT"] || ".exe"
-    end
-
-    def rubyw_exe
-      @rubyw_exe ||= (RbConfig::CONFIG["rubyw_install_name"] || "rubyw") + exe_extname
-    end
-
-    def ruby_exe
-      @ruby_exe ||= (RbConfig::CONFIG["ruby_install_name"] || "ruby") + exe_extname
-    end
-
-    def all_core_dir
-      RbConfig::CONFIG
-          .slice("rubylibdir", "sitelibdir", "vendorlibdir")
-          .values
-          .map { |path| Pathname.new(path) }
-    end
-  end
-end
+require "rbconfig"
+require "pathname"
+
+module Ocran
+  # Variables describing the host's build environment.
+  module HostConfigHelper
+    module_function
+
+    def exec_prefix
+      @exec_prefix ||= Pathname.new(RbConfig::CONFIG["exec_prefix"])
+    end
+
+    def sitelibdir
+      @sitelibdir ||= Pathname.new(RbConfig::CONFIG["sitelibdir"])
+    end
+
+    def bindir
+      @bindir ||= Pathname.new(RbConfig::CONFIG["bindir"])
+    end
+
+    def libdir
+      @libdir ||= Pathname.new(RbConfig::CONFIG["libdir"])
+    end
+
+    def libruby_so
+      name = RbConfig::CONFIG["LIBRUBY_SO"]
+      return nil if name.nil? || name.empty?
+      @libruby_so ||= Pathname.new(name)
+    end
+
+    def libruby_aliases
+      aliases = RbConfig::CONFIG["LIBRUBY_ALIASES"]
+      return [] if aliases.nil? || aliases.empty?
+      aliases.split.map { |name| Pathname.new(name) }
+    end
+
+    def exe_extname
+      RbConfig::CONFIG["EXEEXT"] || ".exe"
+    end
+
+    def rubyw_exe
+      return nil unless Gem.win_platform?
+      @rubyw_exe ||= (RbConfig::CONFIG["rubyw_install_name"] || "rubyw") + exe_extname
+    end
+
+    def ruby_exe
+      @ruby_exe ||= (RbConfig::CONFIG["ruby_install_name"] || "ruby") + exe_extname
+    end
+
+    def all_core_dir
+      RbConfig::CONFIG
+          .slice("rubylibdir", "sitelibdir", "vendorlibdir")
+          .values
+          .map { |path| Pathname.new(path) }
+    end
+  end
+end