lexm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d4d7c862b94b78fad36be7529b9a2ae2b7fc0ddcb7071703146ebbdb504576b
-  data.tar.gz: 7e5e2750d5b226fd6e6782c6e3337826d1d94a2771d4cada0ea2bf74c69dc2cd
+  metadata.gz: 147eccae18795425b54c13045269798e8c438523c5453279c5274fc44a95fc65
+  data.tar.gz: b5055ec1bb29595732129402875e58f79c9d2440053624a88dec447f8e82752f
 SHA512:
-  metadata.gz: d91386b44fb2ad409d236a13e7685b3df4ebe6bc442de2826d488bbc927d2c28af1b6f6d3c52aabb64493f3a0b3b7e4d77951e43b022750041c5c7933a8d04fa
-  data.tar.gz: ae7d3b47fa6a7ff65e5fb1a125d257ad4aaf83fdf03c2d7cc803f98a0f5b0dbf76e1ce5df9de885e552e5d346e27e7c5a96dc8cbd0d3446f9a3de90668560c50
+  metadata.gz: 6144cfd7f2eb44f7ef4a4f134925a39ff2c9a675f5176de4c09f17d02f8805aac7ba71ed5a6c81fbf48435cf99e11b4e0b912c263e3759c880a8c655983b902b
+  data.tar.gz: '0479a14b133a3437314bce00e2d12ae9fedd45c5c69170ff76ee0b35338aaf43d2b5efa22462b240fa2c7c1c0a06d0b6255ec7d8ea53c0156674bdf9f46c59ce'

data/README.md

@@ -2,12 +2,37 @@
 
 <img align="center" width="400" src="icon.png"/>
 
-### Lemma Markup Format<br><br>![License](https://img.shields.io/github/license/drkameleon/lexm?style=for-the-badge)
+### Lemma Markup Format
+
+![License](https://img.shields.io/github/license/drkameleon/lexm?style=for-the-badge)
+![Version](https://img.shields.io/badge/version-0.3.0-blue.svg?style=for-the-badge)
+
 </div>
 
 ---
 
-LexM is a concise, human-readable format for representing dictionary-ready, lexical entries with their various forms, relationships, and redirections.
+<!--ts-->
+* [Lemma Markup Format](#lemma-markup-format)
+  * [Installation](#installation)
+  * [Basic Format](#basic-format)
+  * [Examples](#examples)
+  * [Entry Types](#entry-types)
+    * [Standard Lemma](#standard-lemma)
+    * [Lemma with Sublemmas](#lemma-with-sublemmas)
+    * [Redirection Entry](#redirection-entry)
+    * [Mixed Format](#mixed-format)
+  * [Advanced Features](#advanced-features)
+    * [Validation](#validation)
+    * [File Operations](#file-operations)
+  * [LexM Format Specification](#lexm-format-specification)
+  * [Attribution](#-attribution)
+    * [How to Cite](#how-to-cite)
+  * [License](#license)
+<!--te-->
+
+---
+
+LexM is a concise, human-readable format for representing dictionary-ready lexical entries with their various forms, relationships, and redirections. It's designed to be both easy to write by hand and simple to parse programmatically.
 
 ## Installation
 
@@ -37,6 +62,9 @@ A LexM entry consists of a lemma (headword) and optional elements:
 lemma[annotations]|sublemma1,sublemma2,>(relation)target
 ```
 
+> [!NOTE]
+> The format is designed to be human-readable while still being structured enough for programmatic processing. This makes it ideal for dictionary development, computational linguistics, and language learning applications.
+
 ## Examples
 
 ```ruby
@@ -85,6 +113,9 @@ list.eachWord do |word|
 end
 ```
 
+> [!TIP]
+> When using `addLemma`, the method will automatically merge lemmas with the same headword by default, combining their annotations and adding new sublemmas. Use `addLemma(lemma, false)` to add a lemma without merging.
+
 ## Entry Types
 
 ### Standard Lemma
@@ -119,6 +150,62 @@ A lemma that has sublemmas including a redirection:
 left|left-handed,>(sp,pp)leave
 ```
 
+## Advanced Features
+
+### Validation
+
+LexM includes comprehensive validation to ensure your dictionary data is consistent and free of conflicts:
+
+```ruby
+list = LemmaList.new
+# Add lemmas...
+
+# Option 1: Validates and returns true/false
+if list.validate
+  puts "Dictionary is valid!"
+else
+  puts "Dictionary contains errors"
+end
+
+# Option 2: Get a list of all validation errors
+errors = list.validateAll
+if errors.empty?
+  puts "Dictionary is valid!"
+else
+  puts "Validation errors:"
+  errors.each { |error| puts "- #{error}" }
+end
+```
+
+> [!IMPORTANT]
+> The `validateAll` method checks for all validation issues at once, including:
+> - Duplicate headwords
+> - Words that appear as both headwords and sublemmas
+> - Words that appear as both normal headwords and redirection headwords
+> - Circular dependencies and redirections
+
+### File Operations
+
+Load from and save to LexM files:
+
+```ruby
+# Load from file
+lemmas = LemmaList.new("dictionary.lexm")
+
+# Save to file
+lemmas.save("updated_dictionary.lexm")
+```
+
+## LexM Format Specification
+
+| Element | Syntax | Example |
+|---------|--------|---------|
+| Lemma | `word` | `run` |
+| Annotations | `[key:value,key2:value2]` | `[sp:ran,pp:run]` |
+| Sublemmas | `\|sublemma1,sublemma2` | `\|run away,run up` |
+| Redirection | `>>(type)target` | `>>(pl)child` |
+| Sublemma Redirection | `>(type)target` | `>(sp)rise` |
+
 ## Attribution
 LexM was created and developed by Yanis Zafirópulos (a.k.a. Dr.Kameleon). If you use this software, please maintain this attribution.
 
@@ -129,4 +216,24 @@ If you use LexM in your research or applications, please cite it as:
 
 ## License
 
-This library is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT License
+
+Copyright (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/bin/lexm

@@ -2,11 +2,11 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: bin/lexm
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 require "lexm"

data/lib/lexm/lemma.rb

@@ -1,25 +1,33 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm/lemma.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 module LexM
     # Represents a lemma, the main entry in a lexicon
     class Lemma
         attr_accessor :text, :annotations, :sublemmas, :redirect
+        # Source location information
+        attr_accessor :source_file, :source_line, :source_column
 
         # Initialize from either a string or direct components
         # @param input [String, nil] input string in LexM format to parse
-        def initialize(input = nil)
+        # @param source_file [String, nil] source file path
+        # @param source_line [Integer, nil] source line number
+        # @param source_column [Integer, nil] source column number
+        def initialize(input = nil, source_file = nil, source_line = nil, source_column = nil)
             @text = nil
             @annotations = {}
             @sublemmas = []
             @redirect = nil
+            @source_file = source_file
+            @source_line = source_line
+            @source_column = source_column
             
             parse(input) if input.is_a?(String)
         end

data/lib/lexm/lemma_list.rb

@@ -1,11 +1,11 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm/lemma_list.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 module LexM
@@ -63,10 +63,13 @@ module LexM
         # @param text [String] text to parse
         # @return [LemmaList] self
         def parseString(text)
+            line_number = 0
             text.each_line do |line|
+                line_number += 1
                 line = line.strip
                 next if line.empty? || line.start_with?('#')
-                @lemmas << Lemma.new(line)
+                lemma = Lemma.new(line, "string input", line_number, 1)
+                @lemmas << lemma
             end
             self
         end
@@ -84,7 +87,12 @@ module LexM
                         next if line.empty? || line.start_with?('#')
                   
                         begin
-                            @lemmas << Lemma.new(line)
+                            # Create lemma with source location info
+                            lemma = Lemma.new(line, filename, line_number, 1)
+                            @lemmas << lemma
+                            
+                            # Track sublemma positions
+                            track_sublemma_positions(lemma, line, filename, line_number)
                         rescue StandardError => e
                             raise "Error on line #{line_number}: #{e.message} (#{line})"
                         end
@@ -100,17 +108,61 @@ module LexM
             self
         end
 
+        # Track source positions for sublemmas
+        # @param lemma [Lemma] The lemma containing sublemmas
+        # @param line [String] The original line from the file
+        # @param filename [String] Source filename
+        # @param line_number [Integer] Source line number
+        # @return [void]
+        def track_sublemma_positions(lemma, line, filename, line_number)
+            return if line.nil? || lemma.redirected? || !line.include?("|")
+            
+            # Find where sublemmas begin
+            sublemmas_start = line.index("|") + 1
+            
+            # For each sublemma, try to find its position in the line
+            lemma.sublemmas.each do |sublemma|
+                sublemma.source_file = filename
+                sublemma.source_line = line_number
+                
+                # Determine column position
+                if sublemma.text
+                    # Find position of this sublemma text in the line
+                    text_pos = line.index(sublemma.text, sublemmas_start)
+                    sublemma.source_column = text_pos ? text_pos + 1 : sublemmas_start
+                elsif sublemma.redirect
+                    # Find position of redirection marker
+                    redirect_pos = line.index('>', sublemmas_start)
+                    sublemma.source_column = redirect_pos ? redirect_pos + 1 : sublemmas_start
+                end
+            end
+        end
+
+        # Helper method to format source location
+        # @param item [Object] Object with source location attributes
+        # @return [String] Formatted source location
+        def source_location_str(item)
+            if item.source_file && item.source_line
+                col_info = item.source_column ? ", col: #{item.source_column}" : ""
+                "#{item.source_file}:#{item.source_line}#{col_info}"
+            else
+                "unknown location"
+            end
+        end
+
         # Check for circular redirection chains
         # For example, if A redirects to B, which redirects back to A
         # @return [Boolean] true if no circular redirections are found
         # @raise [StandardError] with cycle path if circular redirections are detected
         def validateRedirections
-            # Build a redirection graph
+            # Build a redirection graph with locations
             redirection_map = {}
+            location_map = {}
             
             @lemmas.each do |lemma|
                 if lemma.redirected?
                     redirection_map[lemma.text] = lemma.redirect.target
+                    location_map[lemma.text] = source_location_str(lemma)
                 end
             end
             
@@ -125,21 +177,310 @@ module LexM
                 end
               
                 if redirection_map.key?(current) && current == start
-                    cycle_path = visited.join(" -> ") + " -> " + current
-                    raise "Circular redirection detected: #{cycle_path}"
+                    # Format the cycle with locations
+                    cycle_path = visited.map do |word|
+                        loc = location_map[word] || "unknown location"
+                        "#{word} (#{loc})"
+                    end
+                    
+                    cycle_path << "#{current} (#{location_map[current]})"
+                    raise "Circular redirection detected: #{cycle_path.join(' -> ')}"
+                end
+            end
+            
+            true
+        end
+
+        # Ensures no headword appears more than once in the list
+        # This prevents ambiguity and conflicts in the dictionary
+        # @return [Boolean] true if no duplicate headwords are found
+        # @raise [StandardError] if duplicate headwords are detected
+        def validateHeadwords
+            # Check for duplicate headwords
+            headwords = {}
+            
+            @lemmas.each do |lemma|
+                if headwords.key?(lemma.text)
+                    location1 = source_location_str(headwords[lemma.text])
+                    location2 = source_location_str(lemma)
+                    raise "Duplicate headword detected: '#{lemma.text}' at #{location1} and #{location2}"
+                end
+                headwords[lemma.text] = lemma
+            end
+            
+            true
+        end
+
+        # Ensures that words don't appear as both headwords and sublemmas,
+        # and that the same sublemma doesn't appear under multiple headwords
+        # @return [Boolean] true if no conflicts are found
+        # @raise [StandardError] if conflicts are detected
+        def validateSublemmaRelationships
+            # Build word maps with source tracking
+            normal_headwords = {}
+            redirection_headwords = {}
+            sublemmas_map = {}
+            
+            # First, capture all headwords and their sublemmas
+            @lemmas.each do |lemma|
+                if lemma.redirected?
+                    redirection_headwords[lemma.text] = lemma
+                else
+                    normal_headwords[lemma.text] = lemma
+                    
+                    # Process sublemmas for non-redirecting lemmas
+                    lemma.sublemmas.each do |sublemma|
+                        # Skip redirecting sublemmas, we only care about actual sublemmas with text
+                        next if sublemma.redirected?
+                        
+                        # Record which headword this sublemma belongs to
+                        if sublemmas_map.key?(sublemma.text)
+                            sublemmas_map[sublemma.text] << [lemma, sublemma]
+                        else
+                            sublemmas_map[sublemma.text] = [[lemma, sublemma]]
+                        end
+                    end
+                end
+            end
+            
+            # Check for words that are both normal headwords and redirection headwords
+            normal_headwords.each do |word, lemma|
+                if redirection_headwords.key?(word)
+                    location1 = source_location_str(lemma)
+                    location2 = source_location_str(redirection_headwords[word])
+                    raise "Word '#{word}' is both a normal headword (#{location1}) and a redirection headword (#{location2})"
+                end
+            end
+            
+            # Check for words that are both headwords and sublemmas
+            normal_headwords.each do |word, lemma|
+                if sublemmas_map.key?(word)
+                    location1 = source_location_str(lemma)
+                    sublemma_info = sublemmas_map[word].map do |l, s|
+                        "#{l.text} (#{source_location_str(s)})"
+                    end.join(', ')
+                    raise "Word '#{word}' is both a headword (#{location1}) and a sublemma of #{sublemma_info}"
+                end
+            end
+            
+            # Check for words that are both redirection headwords and sublemmas
+            redirection_headwords.each do |word, lemma|
+                if sublemmas_map.key?(word)
+                    location1 = source_location_str(lemma)
+                    sublemma_info = sublemmas_map[word].map do |l, s|
+                        "#{l.text} (#{source_location_str(s)})"
+                    end.join(', ')
+                    raise "Word '#{word}' is both a redirection headword (#{location1}) and a sublemma of #{sublemma_info}"
+                end
+            end
+            
+            # Check for sublemmas that appear in multiple entries
+            sublemmas_map.each do |sublemma, entries|
+                if entries.size > 1
+                    headword_info = entries.map do |l, s|
+                        "#{l.text} (#{source_location_str(s)})"
+                    end.join(', ')
+                    raise "Sublemma '#{sublemma}' appears in multiple entries: #{headword_info}"
+                end
+            end
+            
+            true
+        end
+
+        # Detects circular dependencies between lemmas and sublemmas
+        # A circular dependency would result in infinite recursion when
+        # expanding or processing the lemma structure
+        # @return [Boolean] true if no circular dependencies are found
+        # @raise [StandardError] if circular dependencies are detected
+        def validateCircularDependencies
+            # Build a graph of dependencies (headword -> sublemmas) with locations
+            dependency_graph = {}
+            location_map = {}
+            
+            @lemmas.each do |lemma|
+                next if lemma.redirected?
+                
+                # Track lemma location
+                location_map[lemma.text] = source_location_str(lemma)
+                
+                # Initialize headword in the graph if not present
+                dependency_graph[lemma.text] ||= []
+                
+                # Add all non-redirecting sublemmas as dependencies
+                lemma.sublemmas.each do |sublemma|
+                    next if sublemma.redirected?
+                    dependency_graph[lemma.text] << sublemma.text
+                    location_map[sublemma.text] ||= source_location_str(sublemma)
+                end
+            end
+            
+            # For each headword, check for circular dependencies
+            dependency_graph.each_key do |start|
+                detectCycles(dependency_graph, start, [], [], location_map)
+            end
+            
+            true
+        end
+        
+        # Helper method for validateCircularDependencies
+        # Recursively traverses the dependency graph to find cycles using DFS
+        # @param graph [Hash] The dependency graph mapping lemmas to their sublemmas
+        # @param start [String] The starting node for cycle detection
+        # @param visited [Array] Nodes already visited in any path
+        # @param path [Array] Nodes visited in the current path
+        # @param location_map [Hash] Map of words to their source locations
+        # @return [Boolean] True if no cycles are detected
+        # @raise [StandardError] if a cycle is detected
+        def detectCycles(graph, start, visited = [], path = [], location_map = {})
+            # Mark the current node as visited and add to path
+            visited << start
+            path << start
+            
+            # Visit all neighbors
+            if graph.key?(start)
+                graph[start].each do |neighbor|
+                    # Skip if neighbor is not a headword (not in graph)
+                    next unless graph.key?(neighbor)
+                    
+                    if !visited.include?(neighbor)
+                        detectCycles(graph, neighbor, visited, path, location_map)
+                    elsif path.include?(neighbor)
+                        # Cycle detected
+                        cycle_start_index = path.index(neighbor)
+                        cycle = path[cycle_start_index..-1] << neighbor
+                        
+                        # Format the cycle with source locations
+                        cycle_with_locations = cycle.map do |word|
+                            loc = location_map[word] || "unknown location"
+                            "#{word} (#{loc})"
+                        end
+                        
+                        raise "Circular dependency detected: #{cycle_with_locations.join(' -> ')}"
+                    end
                 end
             end
             
+            # Remove the current node from path
+            path.pop
             true
         end
 
         # Validate the entire lemma list for consistency
         # Runs all validation checks
         # @return [Boolean] true if validation passes
-        # @raise [StandardError] with detailed message if validation fails
         def validate
-            validateRedirections
-            true
+            begin
+                validateHeadwords
+                validateSublemmaRelationships
+                validateCircularDependencies
+                validateRedirections
+                return true
+            rescue StandardError => e
+                puts "Validation error: #{e.message}"
+                return false
+            end
+        end
+        
+        # Performs all validation checks and returns an array of all errors
+        # instead of raising on the first error encountered
+        # @return [Array<String>] List of validation errors or empty array if valid
+        def validateAll
+            errors = []
+            
+            # Create maps for tracking word usage with source locations
+            normal_headwords = {}
+            redirection_headwords = {}
+            sublemmas_map = {}
+            
+            # First, map out all words and their locations
+            @lemmas.each do |lemma|
+                location = source_location_str(lemma)
+                
+                if lemma.redirected?
+                    redirection_headwords[lemma.text] = location
+                else
+                    normal_headwords[lemma.text] = location
+                    
+                    # Process sublemmas for non-redirecting lemmas
+                    lemma.sublemmas.each do |sublemma|
+                        next if sublemma.redirected?
+                        
+                        sub_location = source_location_str(sublemma)
+                        
+                        # Record which headword this sublemma belongs to with location
+                        if sublemmas_map.key?(sublemma.text)
+                            sublemmas_map[sublemma.text] << [lemma.text, sub_location]
+                        else
+                            sublemmas_map[sublemma.text] = [[lemma.text, sub_location]]
+                        end
+                    end
+                end
+            end
+            
+            # Check for duplicate headwords with locations
+            headword_locations = {}
+            @lemmas.each do |lemma|
+                location = source_location_str(lemma)
+                if headword_locations.key?(lemma.text)
+                    headword_locations[lemma.text] << location
+                else
+                    headword_locations[lemma.text] = [location]
+                end
+            end
+            
+            headword_locations.each do |word, locations|
+                if locations.size > 1
+                    errors << "Duplicate headword detected: '#{word}' at #{locations.join(' and ')}"
+                end
+            end
+            
+            # Check for words that are both normal headwords and redirection headwords
+            normal_headwords.each do |word, location|
+                if redirection_headwords.key?(word)
+                    errors << "Word '#{word}' is both a normal headword (#{location}) and a redirection headword (#{redirection_headwords[word]})"
+                end
+            end
+            
+            # Check for words that are both headwords and sublemmas
+            normal_headwords.each do |word, location|
+                if sublemmas_map.key?(word)
+                    sublemma_info = sublemmas_map[word].map { |h, l| "#{h} (#{l})" }.join(', ')
+                    errors << "Word '#{word}' is both a headword (#{location}) and a sublemma of #{sublemma_info}"
+                end
+            end
+            
+            # Check for words that are both redirection headwords and sublemmas
+            redirection_headwords.each do |word, location|
+                if sublemmas_map.key?(word)
+                    sublemma_info = sublemmas_map[word].map { |h, l| "#{h} (#{l})" }.join(', ')
+                    errors << "Word '#{word}' is both a redirection headword (#{location}) and a sublemma of #{sublemma_info}"
+                end
+            end
+            
+            # Check for sublemmas that appear in multiple entries
+            sublemmas_map.each do |sublemma, headword_list|
+                if headword_list.size > 1
+                    headword_info = headword_list.map { |h, l| "#{h} (#{l})" }.join(', ')
+                    errors << "Sublemma '#{sublemma}' appears in multiple entries: #{headword_info}"
+                end
+            end
+            
+            # Check for circular dependencies and redirections if no errors so far
+            if errors.empty?
+                begin
+                    validateCircularDependencies
+                rescue StandardError => e
+                    errors << e.message
+                end
+                
+                begin
+                    validateRedirections
+                rescue StandardError => e
+                    errors << e.message
+                end
+            end
+            
+            errors
         end
         
         # Find lemmas by lemma text
@@ -193,19 +534,51 @@ module LexM
             end
         end
         
-        # Add a new lemma
-        # @param lemma [Lemma] lemma to add
-        # @return [LemmaList] self
-        def addLemma(lemma)
-            @lemmas << lemma
+        # Adds a lemma to the list
+        # If a lemma with the same headword already exists, it will merge the
+        # annotations and sublemmas from the new lemma into the existing one
+        # @param lemma [Lemma] The lemma to add
+        # @param merge [Boolean] Whether to merge with existing lemmas (default: true)
+        # @return [LemmaList] self for method chaining
+        def addLemma(lemma, merge = true)
+            # Find existing lemma with the same headword
+            existing = findByText(lemma.text).first
+            
+            if existing && merge
+                # Merge annotations
+                lemma.annotations.each do |key, value|
+                    existing.setAnnotation(key, value)
+                end
+                
+                # Merge sublemmas
+                lemma.sublemmas.each do |sublemma|
+                    # Check if this sublemma already exists
+                    sublemma_exists = existing.sublemmas.any? do |existing_sublemma|
+                        existing_sublemma.text == sublemma.text &&
+                        (!existing_sublemma.redirected? && !sublemma.redirected?)
+                    end
+                    
+                    # Add the sublemma if it doesn't exist
+                    unless sublemma_exists
+                        existing.sublemmas << sublemma
+                    end
+                end
+            else
+                # Add as new lemma
+                @lemmas << lemma
+            end
+            
             self
         end
         
         # Add multiple lemmas at once
         # @param lemmas [Array<Lemma>] lemmas to add
+        # @param merge [Boolean] Whether to merge with existing lemmas (default: true)
         # @return [LemmaList] self
-        def addLemmas(lemmas)
-            @lemmas.concat(lemmas)
+        def addLemmas(lemmas, merge = true)
+            lemmas.each do |lemma|
+                addLemma(lemma, merge)
+            end
             self
         end
         

data/lib/lexm/lemma_redirect.rb

@@ -1,11 +1,11 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm/lemma_redirect.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 module LexM

data/lib/lexm/sublemma.rb

@@ -1,24 +1,32 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm/sublemma.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 module LexM
     # Represents a sublemma, which can be either a textual sublemma or a redirection
     class Sublemma
         attr_accessor :text, :redirect
+        # Source location information
+        attr_accessor :source_file, :source_line, :source_column
         
         # Initialize a new sublemma
         # @param text [String, nil] the text of the sublemma (nil for pure redirections)
         # @param redirect [LemmaRedirect, nil] redirection information (nil for normal sublemmas)
-        def initialize(text = nil, redirect = nil)
+        # @param source_file [String, nil] source file path
+        # @param source_line [Integer, nil] source line number
+        # @param source_column [Integer, nil] source column number
+        def initialize(text = nil, redirect = nil, source_file = nil, source_line = nil, source_column = nil)
             @text = text
             @redirect = redirect
+            @source_file = source_file
+            @source_line = source_line
+            @source_column = source_column
         end
         
         # Is this a pure redirection sublemma?

data/lib/lexm/version.rb

@@ -1,13 +1,13 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm/version.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 module LexM
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
 end

data/lib/lexm.rb

@@ -1,11 +1,11 @@
 #############################################################
 # LexM - Lemma Markup Format
 #
-# A specification for representing, dictionary-ready
+# A specification for representing dictionary-ready,
 # lexical entries and their relationships
 #
 # File: lib/lexm.rb
-# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+# (c) 2025 Yanis Zafirópulos (aka Dr.Kameleon)
 #############################################################
 
 require 'lexm/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lexm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yanis Zafirópulos
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec