purl 0.1.0 → 1.0.0

data/lib/purl/registry_url.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module Purl
+  class RegistryURL
+    # Load registry patterns from JSON configuration
+    def self.load_registry_patterns
+      @registry_patterns ||= begin
+        # Load JSON config directly to avoid circular dependency
+        config_path = File.join(__dir__, "..", "..", "purl-types.json")
+        require "json"
+        config = JSON.parse(File.read(config_path))
+        patterns = {}
+        
+        config["types"].each do |type, type_config|
+          # Only process types that have registry_config
+          next unless type_config["registry_config"]
+          
+          registry_config = type_config["registry_config"]
+          patterns[type] = build_pattern_config(type, registry_config)
+        end
+        
+        patterns
+      end
+    end
+
+    def self.build_pattern_config(type, config)
+      {
+        base_url: config["base_url"],
+        route_patterns: config["route_patterns"] || [],
+        reverse_regex: config["reverse_regex"] ? Regexp.new(config["reverse_regex"]) : nil,
+        pattern: build_generation_lambda(type, config),
+        reverse_parser: config["reverse_regex"] ? build_reverse_parser(type, config) : nil
+      }
+    end
+
+    def self.build_generation_lambda(type, config)
+      case type
+      when "npm"
+        ->(purl) do
+          if purl.namespace
+            "#{config["base_url"]}/#{purl.namespace}/#{purl.name}"
+          else
+            "#{config["base_url"]}/#{purl.name}"
+          end
+        end
+      when "composer", "maven", "swift"
+        ->(purl) do
+          if purl.namespace
+            "#{config["base_url"]}/#{purl.namespace}/#{purl.name}"
+          else
+            raise MissingRegistryInfoError.new(
+              "#{type.capitalize} packages require a namespace",
+              type: purl.type,
+              missing: "namespace"
+            )
+          end
+        end
+      when "golang"
+        ->(purl) do
+          if purl.namespace
+            "#{config["base_url"]}/#{purl.namespace}/#{purl.name}"
+          else
+            "#{config["base_url"]}/#{purl.name}"
+          end
+        end
+      when "pypi"
+        ->(purl) { "#{config["base_url"]}/#{purl.name}/" }
+      when "hackage"
+        ->(purl) do
+          if purl.version
+            "#{config["base_url"]}/#{purl.name}-#{purl.version}"
+          else
+            "#{config["base_url"]}/#{purl.name}"
+          end
+        end
+      when "deno"
+        ->(purl) do
+          if purl.version
+            "#{config["base_url"]}/#{purl.name}@#{purl.version}"
+          else
+            "#{config["base_url"]}/#{purl.name}"
+          end
+        end
+      when "clojars"
+        ->(purl) do
+          if purl.namespace
+            "#{config["base_url"]}/#{purl.namespace}/#{purl.name}"
+          else
+            "#{config["base_url"]}/#{purl.name}"
+          end
+        end
+      when "elm"
+        ->(purl) do
+          if purl.namespace
+            version = purl.version || "latest"
+            "#{config["base_url"]}/#{purl.namespace}/#{purl.name}/#{version}"
+          else
+            raise MissingRegistryInfoError.new(
+              "Elm packages require a namespace",
+              type: purl.type,
+              missing: "namespace"
+            )
+          end
+        end
+      else
+        ->(purl) { "#{config["base_url"]}/#{purl.name}" }
+      end
+    end
+
+    def self.build_reverse_parser(type, config)
+      case type
+      when "npm"
+        ->(match) do
+          namespace = match[1] # @scope or nil
+          name = match[2]
+          version = match[3] # from /v/version or nil
+          { type: type, namespace: namespace, name: name, version: version }
+        end
+      when "gem"
+        ->(match) do
+          name = match[1]
+          version = match[2] # from /versions/version or nil
+          { type: type, namespace: nil, name: name, version: version }
+        end
+      when "maven"
+        ->(match) do
+          namespace = match[1]
+          name = match[2]
+          version = match[3]
+          { type: type, namespace: namespace, name: name, version: version }
+        end
+      when "pypi"
+        ->(match) do
+          name = match[1]
+          version = match[2] unless match[2] == name # avoid duplicate name as version
+          { type: type, namespace: nil, name: name, version: version }
+        end
+      when "cargo"
+        ->(match) do
+          name = match[1]
+          { type: type, namespace: nil, name: name, version: nil }
+        end
+      when "golang"
+        ->(match) do
+          if match[1] && match[2]
+            # Has namespace: pkg.go.dev/namespace/name
+            namespace = match[1]
+            name = match[2]
+          else
+            # No namespace: pkg.go.dev/name
+            namespace = nil
+            name = match[1] || match[2]
+          end
+          { type: type, namespace: namespace, name: name, version: nil }
+        end
+      when "hackage"
+        ->(match) do
+          name = match[1]
+          version = match[2] # from name-version pattern
+          { type: type, namespace: nil, name: name, version: version }
+        end
+      when "deno"
+        ->(match) do
+          name = match[1]
+          version = match[2] # from @version pattern
+          { type: type, namespace: nil, name: name, version: version }
+        end
+      when "homebrew"
+        ->(match) do
+          name = match[1]
+          { type: type, namespace: nil, name: name, version: nil }
+        end
+      when "elm"
+        ->(match) do
+          namespace = match[1]
+          name = match[2]
+          version = match[3] unless match[3] == "latest"
+          { type: type, namespace: namespace, name: name, version: version }
+        end
+      else
+        ->(match) do
+          { type: type, namespace: nil, name: match[1], version: nil }
+        end
+      end
+    end
+
+    # Registry patterns loaded from JSON configuration
+    REGISTRY_PATTERNS = load_registry_patterns.freeze
+
+    def self.generate(purl)
+      new(purl).generate
+    end
+
+    def self.supported_types
+      REGISTRY_PATTERNS.keys.sort
+    end
+
+    def self.supports?(type)
+      REGISTRY_PATTERNS.key?(type.to_s.downcase)
+    end
+
+    def self.from_url(registry_url)
+      # Try to parse the registry URL back into a PURL
+      REGISTRY_PATTERNS.each do |type, config|
+        next unless config[:reverse_regex] && config[:reverse_parser]
+        
+        match = registry_url.match(config[:reverse_regex])
+        if match
+          parsed_data = config[:reverse_parser].call(match)
+          return PackageURL.new(
+            type: parsed_data[:type],
+            namespace: parsed_data[:namespace],
+            name: parsed_data[:name],
+            version: parsed_data[:version]
+          )
+        end
+      end
+      
+      raise UnsupportedTypeError.new(
+        "Unable to parse registry URL: #{registry_url}. No matching pattern found.",
+        supported_types: REGISTRY_PATTERNS.keys.select { |k| REGISTRY_PATTERNS[k][:reverse_regex] }
+      )
+    end
+
+    def self.supported_reverse_types
+      REGISTRY_PATTERNS.select { |_, config| config[:reverse_regex] }.keys.sort
+    end
+
+    def self.route_patterns_for(type)
+      pattern_config = REGISTRY_PATTERNS[type.to_s.downcase]
+      return [] unless pattern_config
+      
+      pattern_config[:route_patterns] || []
+    end
+
+    def self.all_route_patterns
+      result = {}
+      REGISTRY_PATTERNS.each do |type, config|
+        if config[:route_patterns]
+          result[type] = config[:route_patterns]
+        end
+      end
+      result
+    end
+
+    def initialize(purl)
+      @purl = purl
+    end
+
+    def generate
+      pattern_config = REGISTRY_PATTERNS[@purl.type.downcase]
+      
+      unless pattern_config
+        raise UnsupportedTypeError.new(
+          "No registry URL pattern defined for type '#{@purl.type}'. Supported types: #{self.class.supported_types.join(", ")}",
+          type: @purl.type,
+          supported_types: self.class.supported_types
+        )
+      end
+
+      begin
+        pattern_config[:pattern].call(@purl)
+      rescue MissingRegistryInfoError
+        raise
+      rescue => e
+        raise RegistryError, "Failed to generate registry URL for #{@purl.type}: #{e.message}"
+      end
+    end
+
+    def generate_with_version
+      base_url = generate
+      
+      case @purl.type.downcase
+      when "npm"
+        @purl.version ? "#{base_url}/v/#{@purl.version}" : base_url
+      when "pypi"
+        @purl.version ? "#{base_url}#{@purl.version}/" : base_url
+      when "gem"
+        @purl.version ? "#{base_url}/versions/#{@purl.version}" : base_url
+      when "maven"
+        @purl.version ? "#{base_url}/#{@purl.version}" : base_url
+      when "nuget"
+        @purl.version ? "#{base_url}/#{@purl.version}" : base_url
+      else
+        # For other types, just return the base URL since version-specific URLs vary
+        base_url
+      end
+    end
+
+    private
+
+    attr_reader :purl
+  end
+
+  # Add registry URL generation methods to PackageURL
+  class PackageURL
+    def registry_url
+      RegistryURL.generate(self)
+    end
+
+    def registry_url_with_version
+      RegistryURL.new(self).generate_with_version
+    end
+
+    def supports_registry_url?
+      RegistryURL.supports?(type)
+    end
+  end
+end

data/lib/purl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Purl
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/purl.rb

@@ -1,8 +1,118 @@
 # frozen_string_literal: true
 
 require_relative "purl/version"
+require_relative "purl/errors"
+require_relative "purl/package_url"
+require_relative "purl/registry_url"
 
 module Purl
   class Error < StandardError; end
-  # Your code goes here...
+  
+  # Load PURL types configuration from JSON file
+  def self.load_types_config
+    @types_config ||= begin
+      config_path = File.join(__dir__, "..", "purl-types.json")
+      require "json"
+      JSON.parse(File.read(config_path))
+    end
+  end
+
+  # Known PURL types loaded from JSON configuration
+  KNOWN_TYPES = load_types_config["types"].keys.sort.freeze
+  
+  # Convenience method for parsing PURL strings
+  def self.parse(purl_string)
+    PackageURL.parse(purl_string)
+  end
+
+  # Convenience method for parsing registry URLs back to PURLs
+  def self.from_registry_url(registry_url)
+    RegistryURL.from_url(registry_url)
+  end
+
+  # Returns all known PURL types
+  def self.known_types
+    KNOWN_TYPES.dup
+  end
+
+  # Returns types that have registry URL support
+  def self.registry_supported_types
+    RegistryURL.supported_types
+  end
+
+  # Returns types that support reverse parsing from registry URLs
+  def self.reverse_parsing_supported_types
+    RegistryURL.supported_reverse_types
+  end
+
+  # Check if a type is known/valid
+  def self.known_type?(type)
+    KNOWN_TYPES.include?(type.to_s.downcase)
+  end
+
+  # Get type information including registry support
+  def self.type_info(type)
+    normalized_type = type.to_s.downcase
+    {
+      type: normalized_type,
+      known: known_type?(normalized_type),
+      registry_url_generation: RegistryURL.supports?(normalized_type),
+      reverse_parsing: RegistryURL.supported_reverse_types.include?(normalized_type),
+      route_patterns: RegistryURL.route_patterns_for(normalized_type)
+    }
+  end
+
+  # Get comprehensive information about all types
+  def self.all_type_info
+    result = {}
+    
+    # Start with known types
+    KNOWN_TYPES.each do |type|
+      result[type] = type_info(type)
+    end
+    
+    # Add any registry-supported types not in known list
+    RegistryURL.supported_types.each do |type|
+      unless result.key?(type)
+        result[type] = type_info(type)
+      end
+    end
+    
+    result
+  end
+
+  # Get type configuration from JSON
+  def self.type_config(type)
+    config = load_types_config["types"][type.to_s.downcase]
+    return nil unless config
+    
+    config.dup # Return a copy to prevent modification
+  end
+
+  # Get description for a type
+  def self.type_description(type)
+    config = type_config(type)
+    config ? config["description"] : nil
+  end
+
+  # Get registry configuration for a type
+  def self.registry_config(type)
+    config = type_config(type)
+    return nil unless config
+    
+    config["registry_config"]
+  end
+
+  # Get metadata about the types configuration
+  def self.types_config_metadata
+    config = load_types_config
+    {
+      version: config["version"],
+      description: config["description"],
+      source: config["source"],
+      last_updated: config["last_updated"],
+      total_types: config["types"].keys.length,
+      registry_supported_types: config["types"].select { |_, v| v["registry_config"] }.keys.length
+    }
+  end
 end