lexm 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d4d7c862b94b78fad36be7529b9a2ae2b7fc0ddcb7071703146ebbdb504576b
+  data.tar.gz: 7e5e2750d5b226fd6e6782c6e3337826d1d94a2771d4cada0ea2bf74c69dc2cd
+SHA512:
+  metadata.gz: d91386b44fb2ad409d236a13e7685b3df4ebe6bc442de2826d488bbc927d2c28af1b6f6d3c52aabb64493f3a0b3b7e4d77951e43b022750041c5c7933a8d04fa
+  data.tar.gz: ae7d3b47fa6a7ff65e5fb1a125d257ad4aaf83fdf03c2d7cc803f98a0f5b0dbf76e1ce5df9de885e552e5d346e27e7c5a96dc8cbd0d3446f9a3de90668560c50

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yanis Zafirópulos
+
+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/README.md

@@ -0,0 +1,132 @@
+<div align="center">
+
+<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)
+</div>
+
+---
+
+LexM is a concise, human-readable format for representing dictionary-ready, lexical entries with their various forms, relationships, and redirections.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lexm'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install lexm
+```
+
+## Basic Format
+
+A LexM entry consists of a lemma (headword) and optional elements:
+
+```
+lemma[annotations]|sublemma1,sublemma2,>(relation)target
+```
+
+## Examples
+
+```ruby
+require 'lexm'
+include LexM
+
+# Create a lemma with annotations
+lemma = Lemma.new("rise[sp:rose,pp:risen]")
+puts lemma
+# => rise[sp:rose,pp:risen]
+
+# Create a lemma with sublemmas
+lemma = Lemma.new("abandon|abandoned,abandonment")
+puts lemma
+# => abandon|abandoned,abandonment
+
+# Create a redirection entry
+lemma = Lemma.new("better>>(cmp)good")
+puts lemma
+# => better>>(cmp)good
+
+# Create a lemma with a redirection sublemma
+lemma = Lemma.new("rose|>(sp)rise")
+puts lemma
+# => rose|>(sp)rise
+
+# Build a lemma programmatically
+lemma = Lemma.new
+lemma.text = "run"
+lemma.setAnnotations({"sp" => "ran", "pp" => "run"})
+lemma.addSublemmas(["run away", "run up"])
+puts lemma
+# => run[sp:ran,pp:run]|run away,run up
+
+# Work with a collection of lemmas
+list = LemmaList.new
+list.addLemma(Lemma.new("go[sp:went,pp:gone]|go about,go ahead"))
+list.addLemma(Lemma.new("better>>(cmp)good"))
+
+# Find lemmas that redirect to "good"
+good_redirects = list.findRedirectionsTo("good")
+
+# Iterate through all words
+list.eachWord do |word|
+    puts "Word: #{word}"
+end
+```
+
+## Entry Types
+
+### Standard Lemma
+
+A standard dictionary entry with a headword and optional annotations:
+
+```
+run[sp:ran,pp:run]
+```
+
+### Lemma with Sublemmas
+
+A headword with related forms or expressions:
+
+```
+abandon|abandoned,abandonment
+```
+
+### Redirection Entry
+
+A pure redirection that points to another lemma:
+
+```
+better>>(cmp)good
+```
+
+### Mixed Format
+
+A lemma that has sublemmas including a redirection:
+
+```
+left|left-handed,>(sp,pp)leave
+```
+
+## Attribution
+LexM was created and developed by Yanis Zafirópulos (a.k.a. Dr.Kameleon). If you use this software, please maintain this attribution.
+
+### How to Cite
+If you use LexM in your research or applications, please cite it as:
+
+> Yanis Zafirópulos (2025). "LexM: Lemma Markup Format." GitHub repository: https://github.com/drkameleon/lexm
+
+## License
+
+This library is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/lexm

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: bin/lexm
+# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+#############################################################
+
+require "lexm"
+require "optparse"
+
+# Parse command line options
+options = {}
+OptionParser.new do |opts|
+    opts.banner = "Usage: lexm [options] [file]"
+
+    opts.on("-v", "--version", "Show version") do |v|
+        puts "LexM version #{LexM::VERSION}"
+        exit
+    end
+
+    opts.on("-h", "--help", "Show help") do
+        puts opts
+        exit
+    end
+    
+    opts.on("-c", "--count", "Count lemmas in file") do 
+        options[:count] = true
+    end
+    
+    opts.on("-l", "--list-words", "List all words (lemmas and sublemmas)") do
+        options[:list_words] = true
+    end
+    
+    opts.on("-r", "--redirects", "List all redirection lemmas") do
+        options[:redirects] = true
+    end
+    
+    opts.on("-t", "--to TARGET", "Find all lemmas redirecting to TARGET") do |target|
+        options[:target] = target
+    end
+end.parse!
+
+# Process the file if provided
+if ARGV.empty?
+    puts "No file specified. Use --help for more information."
+    exit
+end
+
+filename = ARGV[0]
+unless File.exist?(filename)
+    puts "File not found: #{filename}"
+    exit
+end
+
+begin
+    lemmas = LemmaList.new(filename)
+    
+    if options[:count]
+        puts "Total lemmas: #{lemmas.size}"
+        puts "Normal lemmas: #{lemmas.normalLemmas.size}"
+        puts "Redirection lemmas: #{lemmas.redirectedLemmas.size}"
+    elsif options[:list_words]
+        puts "All words in file:"
+        lemmas.allWords.sort.each do |word|
+            puts "  #{word}"
+        end
+    elsif options[:target]
+        target = options[:target]
+        puts "Lemmas redirecting to '#{target}':"
+        redirects = lemmas.findRedirectionsTo(target)
+        if redirects.empty?
+            puts "  None found"
+        else
+            redirects.each do |lemma|
+                if lemma.redirect&.target == target
+                    puts "  #{lemma.text} -> #{target} (#{lemma.redirect.types.join(', ')})"
+                else
+                    lemma.sublemmas.each do |sublemma|
+                        if sublemma.redirect&.target == target
+                            puts "  #{lemma.text} -> #{target} [via sublemma #{sublemma.text || '(direct)'}] (#{sublemma.redirect.types.join(', ')})"
+                        end
+                    end
+                end
+            end
+        end
+    else
+        # Default behavior: print a summary
+        puts "Loaded #{lemmas.size} lemmas from #{filename}"
+        puts "Use --help for more options"
+    end
+rescue => e
+    puts "Error processing file: #{e.message}"
+    puts e.backtrace.join("\n") if options[:debug]
+    exit 1
+end

data/lib/lexm/lemma.rb

@@ -0,0 +1,377 @@
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: lib/lexm/lemma.rb
+# Author: 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
+
+        # Initialize from either a string or direct components
+        # @param input [String, nil] input string in LexM format to parse
+        def initialize(input = nil)
+            @text = nil
+            @annotations = {}
+            @sublemmas = []
+            @redirect = nil
+            
+            parse(input) if input.is_a?(String)
+        end
+        
+        # Parse a lemma string
+        # @param input [String] lemma string in LexM format
+        # @return [Lemma] self
+        def parse(input)
+            # Check for empty input
+            raise "Empty lemma input!" if input.nil? || input.strip.empty?
+            
+            # Check for basic syntax issues
+            if input.count('[') != input.count(']')
+                raise "Malformed input: mismatched brackets in '#{input}'"
+            end
+            
+            # Check for balanced pipes
+            if input.include?("|") && input.start_with?("|")
+                raise "Malformed input: lemma starts with pipe character in '#{input}'"
+            end
+          
+            if input.include?(">>")
+                parseRedirectionLemma(input)
+                return self
+            end
+          
+            lemmaPart, sublemmasPart = input.split('|', 2)
+          
+            parseLemma(lemmaPart)
+            parseSublemmas(sublemmasPart) if sublemmasPart
+          
+            self
+        end
+
+        # Parse a redirection lemma (with >> syntax)
+        # @param input [String] redirection lemma string
+        # @return [void]
+        def parseRedirectionLemma(input)
+            # Check for valid redirection syntax (needs a target after >>)
+            if input.match(/>>[\s]*$/)
+                raise "Malformed redirection syntax in '#{input}'. Should be 'word>>target' or 'word>>(relation)target'"
+            end
+            
+            if input =~ /(.+?)>>\((.+?)\)(.+)/
+                @text = $1.strip
+                @redirect = LemmaRedirect.new($3.strip, $2.split(',').map(&:strip))
+            elsif input =~ /(.+?)>>(.+)/
+                @text = $1.strip
+                target = $2.strip
+                if target.empty?
+                    raise "Malformed redirection syntax in '#{input}'. Missing target after '>>'"
+                end
+                @redirect = LemmaRedirect.new(target)
+            else
+                raise "Malformed redirection syntax in '#{input}'. Should be 'word>>target' or 'word>>(relation)target'"
+            end
+        end
+        
+        # Parse just the lemma part (before any pipe)
+        # @param lemmaPart [String] lemma part string
+        # @return [void]
+        def parseLemma(lemmaPart)
+            if lemmaPart.include?('[')
+                baseLemma, annotationsPart = lemmaPart.split('[', 2)
+              
+                # Check for malformed annotation syntax
+                raise "Malformed annotation: missing closing ']' in '#{lemmaPart}'" unless annotationsPart.end_with?(']')
+              
+                # Ensure there's actual lemma text before annotations
+                if baseLemma.strip.empty?
+                    raise "Missing lemma text before annotations in '#{lemmaPart}'"
+                end
+              
+                @text = baseLemma.strip
+          
+                annotationsPart.sub!(/\]$/, '')
+                parseAnnotations(annotationsPart)
+            else
+                # Simple lemma
+                # Ensure there's actual text
+                if lemmaPart.strip.empty?
+                    raise "Empty lemma text in '#{lemmaPart}'"
+                end
+                @text = lemmaPart.strip
+            end
+        end
+        
+        # Parse sublemmas part (after the pipe)
+        # @param sublemmasPart [String] sublemmas part string
+        # @return [void]
+        def parseSublemmas(sublemmasPart)
+            # Check if the sublemma part starts with a redirection marker
+            if sublemmasPart.start_with?('>')
+                # This is a case where the lemma has a pure redirection sublemma
+                # Format: word|>(relation)target
+                if sublemmasPart =~ />\((.+?)\)(.+)/
+                    redirect = LemmaRedirect.new($2.strip, $1.split(',').map(&:strip))
+                    @sublemmas << Sublemma.new(nil, redirect)
+                elsif sublemmasPart =~ />(.+)/
+                    redirect = LemmaRedirect.new($1.strip)
+                    @sublemmas << Sublemma.new(nil, redirect)
+                end
+            else
+                # Split the sublemmas and process each one
+                sublemmas = sublemmasPart.split(',')
+                
+                # Process normal sublemmas
+                sublemmas.each do |sublemma|
+                    sublemma = sublemma.strip
+                    
+                    # Handle pure redirection sublemma
+                    if sublemma.start_with?('>')
+                        if sublemma =~ />\((.+?)\)(.+)/
+                            redirect = LemmaRedirect.new($2.strip, $1.split(',').map(&:strip))
+                            @sublemmas << Sublemma.new(nil, redirect)
+                        elsif sublemma =~ />(.+)/
+                            redirect = LemmaRedirect.new($1.strip)
+                            @sublemmas << Sublemma.new(nil, redirect)
+                        end
+                    # Handle normal sublemma with possible redirection
+                    elsif sublemma.include?('>')
+                        if sublemma =~ /(.+?)>\((.+?)\)(.+)/
+                            # Format: word>(relation)target
+                            text = $1.strip
+                            redirect = LemmaRedirect.new($3.strip, $2.split(',').map(&:strip))
+                            @sublemmas << Sublemma.new(text, redirect)
+                        elsif sublemma =~ /(.+?)>(.+)/
+                            # Simple redirection without relation type
+                            text = $1.strip
+                            redirect = LemmaRedirect.new($2.strip)
+                            @sublemmas << Sublemma.new(text, redirect)
+                        else
+                            @sublemmas << Sublemma.new(sublemma)
+                        end
+                    else
+                        # Simple sublemma
+                        @sublemmas << Sublemma.new(sublemma)
+                    end
+                end
+            end
+        end
+        
+        # Parse annotations like sp:past,pp:participle or pl:oxen
+        # @param annotationsText [String] annotations string
+        # @return [void]
+        def parseAnnotations(annotationsText)
+            if annotationsText.strip.empty?
+                raise "Empty annotations block"
+            end
+            
+            annotationsText.split(',').each do |annotation|
+                if annotation.strip.empty?
+                    raise "Empty annotation in comma-separated list"
+                end
+              
+                if annotation.include?(':')
+                    type, value = annotation.split(':', 2)
+                
+                    # Validate annotation type
+                    if type.strip.empty?
+                        raise "Empty annotation type in '#{annotation}'"
+                    end
+                
+                    # Validate annotation value
+                    if value.strip.empty?
+                        raise "Empty annotation value for type '#{type.strip}'"
+                    end
+                
+                    @annotations[type.strip] = value.strip
+                else
+                    # Handle simple annotations without values
+                    if annotation.strip.empty?
+                        raise "Empty annotation name"
+                    end
+                
+                    @annotations[annotation.strip] = true
+                end
+            end
+        end
+        
+        # Add a standard sublemma
+        # @param text [String] text of the sublemma
+        # @return [Lemma] self
+        def addSublemma(text)
+            if redirected?
+                raise "Cannot add sublemmas to a redirection lemma"
+            end
+            @sublemmas << Sublemma.new(text)
+            self
+        end
+        
+        # Add multiple sublemmas at once
+        # @param texts [Array<String>] array of sublemma texts
+        # @return [Lemma] self
+        def addSublemmas(texts)
+            if redirected?
+                raise "Cannot add sublemmas to a redirection lemma"
+            end
+            texts.each do |text|
+                @sublemmas << Sublemma.new(text)
+            end
+            self
+        end
+        
+        # Add a pure redirect sublemma
+        # @param target [String] target to redirect to
+        # @param types [Array<String>] relation types
+        # @return [Lemma] self
+        def addRedirect(target, types = [])
+            if redirected?
+                raise "Cannot add sublemmas to a redirection lemma"
+            end
+            redirect = LemmaRedirect.new(target, types)
+            @sublemmas << Sublemma.new(nil, redirect)
+            self
+        end
+        
+        # Set the lemma's redirection
+        # @param target [String] target to redirect to
+        # @param types [Array<String>] relation types
+        # @return [Lemma] self
+        def setRedirect(target, types = [])
+            if !@sublemmas.empty?
+                raise "Cannot set redirect on a lemma with sublemmas"
+            end
+            @redirect = LemmaRedirect.new(target, types)
+            self
+        end
+
+        # Validate annotation key and value format
+        # Ensures keys and values follow the expected format
+        # @param key [String] annotation key to validate
+        # @param value [String, Boolean] annotation value to validate
+        # @return [Boolean] true if validation passes
+        # @raise [StandardError] with detailed message if validation fails
+        def validateAnnotation(key, value)
+            # Check that key matches a valid pattern (alphanumeric and limited symbols)
+            unless key =~ /^[a-zA-Z0-9_]+$/
+                raise "Invalid annotation key: '#{key}' (must contain only letters, numbers, and underscores)"
+            end
+            
+            # Additional validation for values
+            if value.is_a?(String)
+                # Check for invalid characters in value if needed
+                if value.include?(']') || value.include?('[')
+                    raise "Invalid annotation value for '#{key}': cannot contain square brackets"
+                end
+            end
+        end
+        
+        # Set an annotation
+        # @param type [String] annotation type
+        # @param value [Object] annotation value
+        # @return [Lemma] self
+        def setAnnotation(type, value = true)
+            if redirected?
+                raise "Cannot add annotations to a redirection lemma"
+            end
+            validateAnnotation(type, value)
+            @annotations[type] = value
+            self
+        end
+        
+        # Add multiple annotations at once
+        # @param annotations [Hash] hash of annotation type => value pairs
+        # @return [Lemma] self
+        def setAnnotations(annotations)
+            if redirected?
+                raise "Cannot add annotations to a redirection lemma"
+            end
+            annotations.each do |key, value|
+                @annotations[key] = value
+            end
+            self
+        end
+        
+        # Clear all annotations
+        # @return [Lemma] self
+        def clearAnnotations
+            @annotations = {}
+            self
+        end
+        
+        # Clear all sublemmas
+        # @return [Lemma] self
+        def clearSublemmas
+            @sublemmas = []
+            self
+        end
+        
+        # Clear redirect
+        # @return [Lemma] self
+        def clearRedirect
+            @redirect = nil
+            self
+        end
+        
+        # Clear all annotations and sublemmas but keep the main lemma
+        # @return [Lemma] self
+        def clear
+            @annotations = {}
+            @sublemmas = []
+            @redirect = nil
+            self
+        end
+        
+        # Clear everything including the main lemma
+        # @return [Lemma] self
+        def clearAll
+            @text = nil
+            @annotations = {}
+            @sublemmas = []
+            @redirect = nil
+            self
+        end
+        
+        # Is this a redirection lemma (no sublemmas, just a redirect)?
+        # @return [Boolean] true if this is a redirection lemma
+        def redirected?
+            !@redirect.nil? && @sublemmas.empty?
+        end
+        
+        # Convert to string format
+        # @return [String] the string representation of this lemma
+        def to_s
+            # Redirection lemma format (with double >>)
+            if redirected?
+                return "#{@text}>>#{@redirect.to_s.sub('>', '')}"
+            end
+            
+            # Normal lemma format
+            result = ""
+            
+            # Format the lemma part with any annotations
+            if @text.nil?
+                return ""
+            elsif @annotations.empty?
+                result << @text
+            else
+                annotationsStr = @annotations.map do |type, value| 
+                    value == true ? type : "#{type}:#{value}"
+                end.join(',')
+                result << "#{@text}[#{annotationsStr}]"
+            end
+            
+            # Add sublemmas if present
+            if !@sublemmas.empty?
+                result << "|"
+                result << @sublemmas.map(&:to_s).join(',')
+            end
+            
+            result
+        end
+    end
+end

data/lib/lexm/lemma_list.rb

@@ -0,0 +1,263 @@
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: lib/lexm/lemma_list.rb
+# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+#############################################################
+
+module LexM
+    # Represents a collection of lemmas
+    class LemmaList
+        # The array of lemmas
+        attr_reader :lemmas
+        
+        # Initialize a new lemma list, optionally from a string or file
+        # @param input [String, nil] input string or filename
+        def initialize(input = nil)
+            @lemmas = []
+            
+            if input.is_a?(String)
+                # Assume it's a filename if it doesn't contain newlines
+                if input.include?("\n")
+                    parseString(input)
+                else
+                    parseFile(input)
+                end
+            end
+        end
+        
+        # Iterate through all lemma lemmas
+        # @yield [Lemma] each lemma in the list
+        def each
+            @lemmas.each do |lemma|
+                yield lemma
+            end
+        end
+        
+        # Iterate through all words (both lemmas and sublemmas)
+        # @yield [String] each word (lemma text or sublemma text)
+        def eachWord
+            @lemmas.each do |lemma|
+                # Yield the main lemma text
+                yield lemma.text if lemma.text
+                
+                # Yield all sublemma texts
+                lemma.sublemmas.each do |sublemma|
+                    yield sublemma.text if sublemma.text
+                end
+            end
+        end
+        
+        # Get an array of all words (both lemmas and sublemmas)
+        # @return [Array<String>] array of all words
+        def allWords
+            words = []
+            eachWord { |word| words << word }
+            words
+        end
+        
+        # Parse a multi-line string
+        # @param text [String] text to parse
+        # @return [LemmaList] self
+        def parseString(text)
+            text.each_line do |line|
+                line = line.strip
+                next if line.empty? || line.start_with?('#')
+                @lemmas << Lemma.new(line)
+            end
+            self
+        end
+        
+        # Parse from a file
+        # @param filename [String] file to parse
+        # @return [LemmaList] self
+        def parseFile(filename)
+            begin
+                line_number = 0
+                File.open(filename, 'r') do |file|
+                    file.each_line do |line|
+                        line_number += 1
+                        line = line.strip
+                        next if line.empty? || line.start_with?('#')
+                  
+                        begin
+                            @lemmas << Lemma.new(line)
+                        rescue StandardError => e
+                            raise "Error on line #{line_number}: #{e.message} (#{line})"
+                        end
+                    end
+                end
+            rescue Errno::ENOENT
+                raise "File not found: #{filename}"
+            rescue Errno::EACCES
+                raise "Permission denied: #{filename}"
+            rescue StandardError => e
+                raise "Error reading file: #{e.message}"
+            end
+            self
+        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
+            redirection_map = {}
+            
+            @lemmas.each do |lemma|
+                if lemma.redirected?
+                    redirection_map[lemma.text] = lemma.redirect.target
+                end
+            end
+            
+            # Check for cycles
+            redirection_map.each_key do |start|
+                visited = []
+                current = start
+              
+                while redirection_map.key?(current) && !visited.include?(current)
+                    visited << current
+                    current = redirection_map[current]
+                end
+              
+                if redirection_map.key?(current) && current == start
+                    cycle_path = visited.join(" -> ") + " -> " + current
+                    raise "Circular redirection detected: #{cycle_path}"
+                end
+            end
+            
+            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
+        end
+        
+        # Find lemmas by lemma text
+        # @param text [String] lemma text to search for
+        # @return [Array<Lemma>] matching lemmas
+        def findByText(text)
+            @lemmas.select { |lemma| lemma.text == text }
+        end
+        
+        # Find normal lemmas (not redirection lemmas)
+        # @return [Array<Lemma>] normal lemmas
+        def normalLemmas
+            @lemmas.select { |lemma| not lemma.redirected? }
+        end
+        
+        # Find redirection lemmas
+        # @return [Array<Lemma>] redirection lemmas
+        def redirectedLemmas
+            @lemmas.select { |lemma| lemma.redirected? }
+        end
+        
+        # Find lemmas that redirect to a given target, optionally filtered by type
+        # @param target [String] target to search for
+        # @param type [String, nil] optional relation type filter
+        # @return [Array<Lemma>] matching lemmas
+        def findRedirectionsTo(target, type = nil)
+            @lemmas.select do |lemma|
+                if lemma.redirected? && lemma.redirect.target == target
+                    type.nil? || lemma.redirect.types.include?(type)
+                else
+                    lemma.sublemmas.any? do |sublemma|
+                        sublemma.redirected? && 
+                        sublemma.redirect.target == target && 
+                        (type.nil? || sublemma.redirect.types.include?(type))
+                    end
+                end
+            end
+        end
+        
+        # Find lemmas by annotation
+        # @param type [String] annotation type
+        # @param value [Object, nil] optional value to match
+        # @return [Array<Lemma>] matching lemmas
+        def findByAnnotation(type, value = nil)
+            @lemmas.select do |lemma|
+                if value.nil?
+                    lemma.annotations.key?(type)
+                else
+                    lemma.annotations[type] == value
+                end
+            end
+        end
+        
+        # Add a new lemma
+        # @param lemma [Lemma] lemma to add
+        # @return [LemmaList] self
+        def addLemma(lemma)
+            @lemmas << lemma
+            self
+        end
+        
+        # Add multiple lemmas at once
+        # @param lemmas [Array<Lemma>] lemmas to add
+        # @return [LemmaList] self
+        def addLemmas(lemmas)
+            @lemmas.concat(lemmas)
+            self
+        end
+        
+        # Remove a lemma
+        # @param lemma [Lemma] lemma to remove
+        # @return [LemmaList] self
+        def removeLemma(lemma)
+            @lemmas.delete(lemma)
+            self
+        end
+        
+        # Clear all lemmas
+        # @return [LemmaList] self
+        def clear
+            @lemmas = []
+            self
+        end
+        
+        # Get number of lemmas
+        # @return [Integer] number of lemmas
+        def size
+            @lemmas.size
+        end
+        
+        # Get lemma by index
+        # @param index [Integer] index
+        # @return [Lemma] lemma at index
+        def [](index)
+            @lemmas[index]
+        end
+        
+        # Save to a file
+        # @param filename [String] file to save to
+        # @return [void]
+        def save(filename)
+            begin
+                File.open(filename, 'w') do |file|
+                    @lemmas.each do |lemma|
+                        file.puts(lemma.to_s)
+                    end
+                end
+            rescue Errno::EACCES
+                raise "Permission denied: Cannot write to #{filename}"
+            rescue StandardError => e
+                raise "Error writing to file: #{e.message}"
+            end
+        end
+        
+        # Convert to string
+        # @return [String] string representation
+        def to_s
+            @lemmas.map(&:to_s).join("\n")
+        end
+    end
+end

data/lib/lexm/lemma_redirect.rb

@@ -0,0 +1,36 @@
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: lib/lexm/lemma_redirect.rb
+# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+#############################################################
+
+module LexM
+    # Represents a redirection to another lemma, with optional relation types
+    class LemmaRedirect
+        attr_accessor :target, :types
+        
+        # Initialize a new redirection
+        # @param target [String] the target lemma to redirect to
+        # @param types [Array<String>] relation types (e.g., ["pl"], ["sp", "pp"])
+        def initialize(target, types = [])
+            @target = target
+            @types = types || []
+        end
+        
+        # Convert to string representation
+        # @return [String] the string representation of this redirection
+        def to_s
+            if @types.empty?
+                ">#{@target}"
+            elsif @types.length == 1
+                ">(#{@types.first})#{@target}"
+            else
+                ">(#{@types.join(',')})#{@target}"
+            end
+        end
+    end
+end

data/lib/lexm/sublemma.rb

@@ -0,0 +1,40 @@
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: lib/lexm/sublemma.rb
+# Author: 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
+        
+        # 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)
+            @text = text
+            @redirect = redirect
+        end
+        
+        # Is this a pure redirection sublemma?
+        # @return [Boolean] true if this is a pure redirection with no text
+        def redirected?
+            @text.nil? && !@redirect.nil?
+        end
+        
+        # Convert to string representation
+        # @return [String] the string representation of this sublemma
+        def to_s
+            if redirected?
+                @redirect.to_s
+            else
+                @text
+            end
+        end
+    end
+end

data/lib/lexm/version.rb

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

data/lib/lexm.rb

@@ -0,0 +1,19 @@
+#############################################################
+# LexM - Lemma Markup Format
+#
+# A specification for representing, dictionary-ready
+# lexical entries and their relationships
+#
+# File: lib/lexm.rb
+# Author: Yanis Zafirópulos (aka Dr.Kameleon)
+#############################################################
+
+require 'lexm/version'
+require 'lexm/lemma_redirect'
+require 'lexm/sublemma'
+require 'lexm/lemma'
+require 'lexm/lemma_list'
+
+module LexM
+    
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: lexm
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Yanis Zafirópulos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A specification for representing, dictionary-ready lexical entries and
+  their relationships
+email:
+- drkameleon@gmail.com
+executables:
+- lexm
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/lexm
+- lib/lexm.rb
+- lib/lexm/lemma.rb
+- lib/lexm/lemma_list.rb
+- lib/lexm/lemma_redirect.rb
+- lib/lexm/sublemma.rb
+- lib/lexm/version.rb
+homepage: https://github.com/drkameleon/lexm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/drkameleon/lexm
+  source_code_uri: https://github.com/drkameleon/lexm
+  changelog_uri: https://github.com/drkameleon/lexm/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: LexM - Lemma Markup Format
+test_files: []