feat: Add license and SPDX identifier

Fixes
- #12
- #6

Signed-off-by: Dominik Gedon <dominik.gedon@suse.com>

Author: nodeg

lib/template/package.spec

@@ -66,6 +66,9 @@ cp -a <%= output %> %{buildroot}%{_javadir}/<%= File.basename(output) %>
 
 %files
 %defattr(-,root,root)
+<% license_files.each do |file| %>
+%doc <%= file %>
+<% end %>
 %{_javadir}/*
 
 %changelog

lib/tetra.rb

@@ -20,6 +20,7 @@
 # third party libraries
 require "clamp"
 require "text"
+require "yaml"
 require "zip"
 
 # base components
@@ -48,6 +49,7 @@
 require "tetra/pom_getter"
 
 # package building
+require "tetra/license_mapper"
 require "tetra/packages/speccable"
 require "tetra/packages/scriptable"
 require "tetra/packages/kit_package"

lib/tetra/constants.rb

@@ -4,4 +4,5 @@
 module Tetra
   CCOLLECTIONS = "commons-collections4-4.5.0-M2-src".freeze
   CHUNK_SEPARATOR_VERSION_MATCHER = /[.\-_ ~,]/ # Constant regex for splitting version chunks
+  LICENSE_MAP_PATH = File.join(__dir__, "data", "license_map.yml").freeze
 end

lib/tetra/data/license_map.yml

@@ -0,0 +1,126 @@
+# Mappings of Raw Maven License Names -> SPDX Identifiers
+# Based on https://spdx.org/licenses/ and openSUSE/Fedora standards
+
+# --- Apache Licenses ---
+"The Apache Software License, Version 2.0": "Apache-2.0"
+"Apache License, Version 2.0": "Apache-2.0"
+"Apache License Version 2.0": "Apache-2.0"
+"Apache 2.0": "Apache-2.0"
+"Apache License 2.0": "Apache-2.0"
+"AL 2.0": "Apache-2.0"
+"Apache Software License - Version 2.0": "Apache-2.0"
+"The Apache License, Version 2.0": "Apache-2.0"
+"Apache-2.0": "Apache-2.0"
+
+"Apache License, Version 1.1": "Apache-1.1"
+"The Apache Software License, Version 1.1": "Apache-1.1"
+"Apache 1.1": "Apache-1.1"
+
+"Apache License, Version 1.0": "Apache-1.0"
+
+# --- MIT Licenses ---
+"The MIT License": "MIT"
+"MIT License": "MIT"
+"MIT": "MIT"
+"MIT license": "MIT"
+"The MIT License (MIT)": "MIT"
+"Common Development and Distribution License (CDDL) + GPLv2 with classpath exception": "MIT" # Often mislabeled in older POMs
+
+# --- Eclipse Public Licenses ---
+"Eclipse Public License 1.0": "EPL-1.0"
+"Eclipse Public License - v 1.0": "EPL-1.0"
+"Eclipse Public License, Version 1.0": "EPL-1.0"
+"EPL 1.0": "EPL-1.0"
+
+"Eclipse Public License 2.0": "EPL-2.0"
+"Eclipse Public License - v 2.0": "EPL-2.0"
+"EPL 2.0": "EPL-2.0"
+
+# --- GPL (General Public License) ---
+"GNU General Public License, version 2": "GPL-2.0-only"
+"GNU General Public License, Version 2": "GPL-2.0-only"
+"GPL 2.0": "GPL-2.0-only"
+"GPLv2": "GPL-2.0-only"
+"The GNU General Public License, Version 2": "GPL-2.0-only"
+
+"GNU General Public License, version 2 (GPLv2)": "GPL-2.0-only"
+"GNU General Public License, version 3": "GPL-3.0-only"
+"GPL 3.0": "GPL-3.0-only"
+"GPLv3": "GPL-3.0-only"
+
+# --- LGPL (Lesser General Public License) ---
+"GNU Lesser General Public License": "LGPL-2.1-only"
+"GNU Lesser General Public License, version 2.1": "LGPL-2.1-only"
+"LGPL 2.1": "LGPL-2.1-only"
+"LGPLv2.1": "LGPL-2.1-only"
+"The GNU Lesser General Public License, Version 2.1": "LGPL-2.1-only"
+
+"GNU Lesser General Public License, version 3": "LGPL-3.0-only"
+"LGPL 3.0": "LGPL-3.0-only"
+"LGPLv3": "LGPL-3.0-only"
+
+# --- BSD Licenses ---
+"The BSD License": "BSD-2-Clause" # Ambiguous, but often 2-clause in modern Java
+"BSD License": "BSD-2-Clause"
+"BSD-2-Clause": "BSD-2-Clause"
+"Two-clause BSD license": "BSD-2-Clause"
+"The BSD 2-Clause License": "BSD-2-Clause"
+
+"New BSD License": "BSD-3-Clause"
+"BSD 3-Clause": "BSD-3-Clause"
+"BSD 3-Clause License": "BSD-3-Clause"
+"The BSD 3-Clause License": "BSD-3-Clause"
+"Revised BSD License": "BSD-3-Clause"
+"Modified BSD License": "BSD-3-Clause"
+
+"BSD 0-Clause": "0BSD"
+"0BSD": "0BSD"
+
+# --- CDDL (Common Development and Distribution License) ---
+"Common Development and Distribution License": "CDDL-1.0"
+"CDDL 1.0": "CDDL-1.0"
+"CDDL-1.0": "CDDL-1.0"
+"COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0": "CDDL-1.0"
+
+"Common Development and Distribution License 1.1": "CDDL-1.1"
+"CDDL 1.1": "CDDL-1.1"
+
+# --- MPL (Mozilla Public License) ---
+"Mozilla Public License Version 1.1": "MPL-1.1"
+"MPL 1.1": "MPL-1.1"
+
+"Mozilla Public License Version 2.0": "MPL-2.0"
+"MPL 2.0": "MPL-2.0"
+"The Mozilla Public License, Version 2.0": "MPL-2.0"
+
+# --- ISC License ---
+"ISC License": "ISC"
+"The ISC License": "ISC"
+
+# --- Creative Commons ---
+"Creative Commons Zero v1.0 Universal": "CC0-1.0"
+"CC0 1.0 Universal": "CC0-1.0"
+"Public Domain": "CC0-1.0" # Approximation for Public Domain in SPDX
+
+"Creative Commons Attribution 3.0": "CC-BY-3.0"
+"CC BY 3.0": "CC-BY-3.0"
+
+"Creative Commons Attribution 4.0": "CC-BY-4.0"
+"CC BY 4.0": "CC-BY-4.0"
+
+# --- Other Common Java Licenses ---
+"The JSON License": "JSON"
+"JSON": "JSON"
+
+"Unlicense": "Unlicense"
+"The Unlicense": "Unlicense"
+
+"WTFPL": "WTFPL"
+"Do What The F*ck You Want To Public License": "WTFPL"
+
+"Bouncy Castle Licence": "MIT"
+"PostgreSQL License": "PostgreSQL"
+"The PostgreSQL License": "PostgreSQL"
+
+"Zlib License": "Zlib"
+"The zlib/libpng License": "Zlib"

lib/tetra/license_mapper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tetra
+  # Handles mapping raw license names to SPDX identifiers
+  class LicenseMapper
+    def self.map(raw_name)
+      return "unknown" if raw_name.nil?
+
+      @mapping ||= YAML.load_file(Tetra::LICENSE_MAP_PATH)
+
+      # Strip whitespace
+      key = raw_name.strip
+
+      # Return the mapped SPDX ID, or the original name if no match found
+      @mapping[key] || key
+    end
+  end
+end

lib/tetra/packages/package.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module Tetra
   # represents a Java project packaged in tetra
   class Package
@@ -15,7 +13,6 @@ class Package
     def_delegator :@project, :src_archive
     def_delegator :@kit, :name, :kit_name
     def_delegator :@kit, :version, :kit_version
-    def_delegator :@pom, :license_name, :license
     def_delegator :@pom, :url
     def_delegator :@pom, :group_id
     def_delegator :@pom, :version
@@ -29,6 +26,27 @@ def initialize(project, pom_path = nil, filter = nil, patches = [])
       @patches = patches.map { |f| File.basename(f) }
     end
 
+    def license
+      Tetra::LicenseMapper.map(@pom.license_name)
+    end
+
+    # Scans for license files in the src/ directory (Issue #12)
+    def license_files
+      @project.from_directory do
+        # Tetra unpacks sources into 'src/', so we search there.
+        # We perform a case-insensitive search for common license file names.
+        patterns = ["src/LICENSE*", "src/COPYING*", "src/COPYRIGHT*"]
+
+        files = Dir.glob(patterns, File::FNM_CASEFOLD).select do |file|
+          File.file?(file)
+        end
+
+        # Return just the filenames (e.g. "LICENSE") so the spec file
+        # (which runs inside src/ due to %setup -n src) can reference them directly.
+        files.map { |f| File.basename(f) }.uniq.sort
+      end
+    end
+
     def artifact_ids
       @pom.modules.any? ? @pom.modules : [@pom.artifact_id]
     end
@@ -51,18 +69,18 @@ def outputs
     end
 
     def cleanup_description(raw, max_length)
+      return "" if raw.nil?
+
       # Normalize spaces (collapse multiple spaces/newlines to single space)
       clean = raw.gsub(/\s+/, " ").strip
 
       # Truncate to max_length
       clean = clean[0, max_length]
 
       # Remove the last word if it looks cut off (ends in letters, not punctuation)
-      # Note: This assumes descriptions usually end with punctuation.
       clean = clean.sub(/\s\w+\z/, "")
 
-      # Remove ALL trailing dots efficiently (Security Fix for ReDoS)
-      # Replaces clean.sub(/\.+\z/, "")
+      # Remove ALL trailing dots efficiently
       clean = clean.chomp(".") while clean.end_with?(".")
 
       clean

spec/lib/coarse/license_detection_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "tetra generate-spec license handling", type: :aruba do
+  # Helper to generate a minimal, valid POM with DYNAMIC artifactId
+  def create_pom(group_id, artifact_id, version, license_name)
+    <<~XML
+      <project>
+        <modelVersion>4.0.0</modelVersion>
+        <groupId>#{group_id}</groupId>
+        <artifactId>#{artifact_id}</artifactId>
+        <version>#{version}</version>
+        <packaging>jar</packaging>
+        <licenses>
+          <license>
+            <name>#{license_name}</name>
+            <url>http://example.com/license</url>
+          </license>
+        </licenses>
+      </project>
+    XML
+  end
+
+  # Raw POM License Name => Expected SPDX Identifier
+  let(:test_cases) do
+    {
+      "The Apache Software License, Version 2.0" => "Apache-2.0",
+      "The MIT License" => "MIT",
+      "Eclipse Public License 1.0" => "EPL-1.0",
+      "GNU General Public License, version 2" => "GPL-2.0-only",
+      "GNU Lesser General Public License" => "LGPL-2.1-only",
+      "Unmapped Custom License" => "Unmapped Custom License"
+    }
+  end
+
+  it "detects license names and converts them to SPDX" do
+    test_cases.each do |raw_name, expected_spdx|
+      project_name = "proj-#{expected_spdx.downcase.gsub(/[^a-z0-9]/, "")}"
+      version      = "1.0"
+      group_id     = "com.example"
+
+      # Place files directly in the tarball root so they unpack to src/
+      write_file("pom.xml", create_pom(group_id, project_name, version, raw_name))
+      write_file("LICENSE", "License text")
+      write_file("COPYING", "Copying text")
+      write_file("README", "Readme text")
+
+      tarball_name = "#{project_name}.tar"
+      run_command_and_stop("tar -cvf #{tarball_name} pom.xml LICENSE COPYING README")
+
+      run_command_and_stop("tetra init #{project_name} #{tarball_name}")
+
+      cd(project_name) do
+        run_command_and_stop("git config user.email 'test@example.com'")
+        run_command_and_stop("git config user.name 'Test User'")
+
+        run_command("tetra dry-run")
+        sleep 2 # Wait for shell
+
+        # SIMULATE BUILD:
+        # Create a JAR that matches the POM's artifactId and version.
+        # This confirms to tetra that the build produced valid output.
+        jar_name = "#{project_name}-#{version}.jar"
+        type "echo 'dummy-content' > #{jar_name}"
+
+        type "exit"
+        last_command_started.wait
+        expect(last_command_started).to be_successfully_executed
+
+        # We explicitly point to src/pom.xml so tetra finds the metadata securely.
+        run_command_and_stop("tetra generate-spec src/pom.xml")
+
+        spec_path = "packages/#{project_name}/#{project_name}.spec"
+
+        expect(file?(spec_path)).to be(true), "Spec file missing for #{project_name}"
+
+        spec_content = read(spec_path).join("\n")
+
+        expect(spec_content).to include("Version:        #{version}"),
+                                "Metadata missing. Tetra failed to read POM for #{project_name}."
+
+        expect(spec_content).to match(/License:\s+#{Regexp.escape(expected_spdx)}/),
+                                "Failed to map '#{raw_name}' to '#{expected_spdx}'"
+
+        expect(spec_content).to include("%doc LICENSE")
+        expect(spec_content).to include("%doc COPYING")
+      end
+    end
+  end
+end

spec/lib/fine/license_mapper_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tetra/license_mapper"
+
+describe "Tetra::LicenseMapper" do
+  describe ".map" do
+    it "maps known Maven license names to SPDX identifiers" do
+      expect(Tetra::LicenseMapper.map("The Apache Software License, Version 2.0")).to eq("Apache-2.0")
+      expect(Tetra::LicenseMapper.map("Eclipse Public License 1.0")).to eq("EPL-1.0")
+      expect(Tetra::LicenseMapper.map("Mozilla Public License Version 2.0")).to eq("MPL-2.0")
+      expect(Tetra::LicenseMapper.map("Common Development and Distribution License")).to eq("CDDL-1.0")
+      expect(Tetra::LicenseMapper.map("The JSON License")).to eq("JSON")
+    end
+
+    it "handles whitespace around the license name" do
+      expect(Tetra::LicenseMapper.map("  Apache License, Version 2.0  ")).to eq("Apache-2.0")
+    end
+
+    it "returns the original name if no mapping is found" do
+      expect(Tetra::LicenseMapper.map("My Custom Proprietary License")).to eq("My Custom Proprietary License")
+    end
+
+    it "returns 'unknown' for nil input" do
+      expect(Tetra::LicenseMapper.map(nil)).to eq("unknown")
+    end
+
+    it "loads the mapping from the correct file path" do
+      expect(File).to exist(Tetra::LICENSE_MAP_PATH)
+    end
+  end
+end