lexm 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 147eccae18795425b54c13045269798e8c438523c5453279c5274fc44a95fc65
-  data.tar.gz: b5055ec1bb29595732129402875e58f79c9d2440053624a88dec447f8e82752f
+  metadata.gz: c74656fda529cd304f92c513c537445e2e492cab160fb2397905e3e00f9fe059
+  data.tar.gz: fdc730362c3dd42a991ba11fdd96ef5d3ce60cb5332e1d85d4c342409cadc364
 SHA512:
-  metadata.gz: 6144cfd7f2eb44f7ef4a4f134925a39ff2c9a675f5176de4c09f17d02f8805aac7ba71ed5a6c81fbf48435cf99e11b4e0b912c263e3759c880a8c655983b902b
-  data.tar.gz: '0479a14b133a3437314bce00e2d12ae9fedd45c5c69170ff76ee0b35338aaf43d2b5efa22462b240fa2c7c1c0a06d0b6255ec7d8ea53c0156674bdf9f46c59ce'
+  metadata.gz: 6404296f5a2d1ea6791550e6a87dd8a95e009bdb1bef2fb7aaabb7f6204330243ff1ce0275b004b07a3f2a53e4b07cb680b35c074a3a82cebcff1507581a2328
+  data.tar.gz: a7c7125edb88bfeba32d952a6eabbde18c167755b2f074e562bdd33fc30a9cd073cd4848bfc3ba232515e7791aed4f0c60692fe31442fdd3f9c299ba65e8c3fb

data/lib/lexm/lemma.rb

@@ -119,57 +119,75 @@ module LexM
         # @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(',')
+            # We need a smarter way to split sublemmas that respects parentheses
+            # This helps us correctly handle cases like ">(sp,pp)wring,abc"
+            sublemmas = smart_split_sublemmas(sublemmasPart)
+            
+            # Process each sublemma
+            sublemmas.each do |sublemma|
+                sublemma = sublemma.strip
                 
-                # 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
+                # Handle pure redirection sublemma (starts with >)
+                if sublemma.start_with?('>')
+                    if sublemma =~ />\((.+?)\)(.+)/
+                        redirect = LemmaRedirect.new($2.strip, $1.split(',').map(&:strip))
+                        @sublemmas << Sublemma.new(nil, redirect, self)
+                    elsif sublemma =~ />(.+)/
+                        redirect = LemmaRedirect.new($1.strip)
+                        @sublemmas << Sublemma.new(nil, redirect, self)
+                    end
+                # Handle normal sublemma with possible redirection
+                elsif sublemma.include?('>')
+                    # Check for a redirection with relation types
+                    if sublemma =~ /(.+?)>\((.+?)\)(.+)/
+                        # Format: word>(relation)target
+                        text = $1.strip
+                        redirect = LemmaRedirect.new($3.strip, $2.split(',').map(&:strip))
+                        @sublemmas << Sublemma.new(text, redirect, self)
+                    elsif sublemma =~ /(.+?)>(.+)/
+                        # Simple redirection without relation type
+                        text = $1.strip
+                        redirect = LemmaRedirect.new($2.strip)
+                        @sublemmas << Sublemma.new(text, redirect, self)
                     else
-                        # Simple sublemma
-                        @sublemmas << Sublemma.new(sublemma)
+                        @sublemmas << Sublemma.new(sublemma, nil, self)
                     end
+                else
+                    # Simple sublemma
+                    @sublemmas << Sublemma.new(sublemma, nil, self)
                 end
             end
         end
         
+        # Helper method to split sublemmas while respecting parentheses
+        # This ensures we don't split inside relation type lists like (sp,pp)
+        # @param text [String] text to split at commas outside of parentheses
+        # @return [Array<String>] resulting substrings
+        def smart_split_sublemmas(text)
+            result = []
+            current = ""
+            paren_level = 0
+            
+            text.each_char do |c|
+                if c == ',' && paren_level == 0
+                    # Only split on commas outside of parentheses
+                    result << current unless current.empty?
+                    current = ""
+                else
+                    current << c
+                    # Track parenthesis nesting level
+                    if c == '('
+                        paren_level += 1
+                    elsif c == ')'
+                        paren_level -= 1 if paren_level > 0
+                    end
+                end
+            end
+            
+            result << current unless current.empty?
+            result
+        end
+        
         # Parse annotations like sp:past,pp:participle or pl:oxen
         # @param annotationsText [String] annotations string
         # @return [void]
@@ -215,7 +233,7 @@ module LexM
             if redirected?
                 raise "Cannot add sublemmas to a redirection lemma"
             end
-            @sublemmas << Sublemma.new(text)
+            @sublemmas << Sublemma.new(text, nil, self)
             self
         end
         
@@ -227,7 +245,7 @@ module LexM
                 raise "Cannot add sublemmas to a redirection lemma"
             end
             texts.each do |text|
-                @sublemmas << Sublemma.new(text)
+                @sublemmas << Sublemma.new(text, nil, self)
             end
             self
         end
@@ -241,7 +259,7 @@ module LexM
                 raise "Cannot add sublemmas to a redirection lemma"
             end
             redirect = LemmaRedirect.new(target, types)
-            @sublemmas << Sublemma.new(nil, redirect)
+            @sublemmas << Sublemma.new(nil, redirect, self)
             self
         end
         
@@ -257,6 +275,21 @@ module LexM
             self
         end
 
+        # Returns a hash mapping each sublemma to its shortcut
+        # @param placeholder [String] optional placeholder to use instead of "~" (default: "~")
+        # @return [Hash<String, String>] hash mapping full sublemma text to shortcut
+        def shortcuts(placeholder = "~")
+            return {} if @text.nil? || redirected? || @sublemmas.empty?
+            
+            result = {}
+            @sublemmas.each do |sublemma|
+                # Skip redirections and get the shortcut for text sublemmas
+                next if sublemma.redirected? || sublemma.text.nil?
+                result[sublemma.text] = sublemma.shortcut(placeholder)
+            end
+            result
+        end
+
         # Validate annotation key and value format
         # Ensures keys and values follow the expected format
         # @param key [String] annotation key to validate

data/lib/lexm/lemma_list.rb

@@ -609,6 +609,52 @@ module LexM
         def [](index)
             @lemmas[index]
         end
+
+        # Sort the lemmas based on their headwords (non-destructive)
+        # @param block [Proc] optional custom sort proc
+        # @return [LemmaList] a new sorted lemma list
+        def sort(&block)
+            if block_given?
+                sorted_list = LemmaList.new
+                sorted_list.instance_variable_set(:@lemmas, @lemmas.sort(&block))
+                sorted_list
+            else
+                # Default sort by headword text
+                sorted_list = LemmaList.new
+                sorted_list.instance_variable_set(:@lemmas, @lemmas.sort_by { |lemma| lemma.text.to_s.downcase })
+                sorted_list
+            end
+        end
+
+        # Sort the lemmas based on their headwords (destructive)
+        # @param block [Proc] optional custom sort proc
+        # @return [LemmaList] self
+        def sort!(&block)
+            if block_given?
+                @lemmas.sort!(&block)
+            else
+                # Default sort by headword text
+                @lemmas.sort_by! { |lemma| lemma.text.to_s.downcase }
+            end
+            self
+        end
+
+        # Sort the lemmas using a custom key function (non-destructive)
+        # @param block [Proc] key function to extract sort keys from lemmas
+        # @return [LemmaList] a new sorted lemma list
+        def sort_by(&block)
+            sorted_list = LemmaList.new
+            sorted_list.instance_variable_set(:@lemmas, @lemmas.sort_by(&block))
+            sorted_list
+        end
+
+        # Sort the lemmas using a custom key function (destructive)
+        # @param block [Proc] key function to extract sort keys from lemmas
+        # @return [LemmaList] self
+        def sort_by!(&block)
+            @lemmas.sort_by!(&block)
+            self
+        end
         
         # Save to a file
         # @param filename [String] file to save to

data/lib/lexm/sublemma.rb

@@ -14,16 +14,20 @@ module LexM
         attr_accessor :text, :redirect
         # Source location information
         attr_accessor :source_file, :source_line, :source_column
+        # Reference to parent lemma
+        attr_accessor :parent
         
         # 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)
+        # @param parent [Lemma, nil] parent lemma (optional)
         # @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)
+        def initialize(text = nil, redirect = nil, parent = nil, source_file = nil, source_line = nil, source_column = nil)
             @text = text
             @redirect = redirect
+            @parent = parent
             @source_file = source_file
             @source_line = source_line
             @source_column = source_column
@@ -35,6 +39,37 @@ module LexM
             @text.nil? && !@redirect.nil?
         end
         
+        # Returns a shortened version of the sublemma text, replacing the lemma part with a placeholder
+        # For example, if the lemma is "work" and sublemma is "work out", this returns "~ out"
+        # @param placeholder [String] optional placeholder to use instead of "~" (default: "~")
+        # @return [String, nil] the shortened sublemma text or nil if this is a redirection sublemma or has no parent
+        def shortcut(placeholder = "~")
+            return nil if redirected? || @text.nil? || @parent.nil? || @parent.text.nil?
+            
+            parent_text = @parent.text
+            
+            # Check if the sublemma starts with the parent lemma
+            if @text.start_with?(parent_text)
+                # Replace the parent lemma with the placeholder
+                remainder = @text[parent_text.length..-1]
+                
+                # If the remainder starts with a space, keep it
+                if remainder.start_with?(" ")
+                    return "#{placeholder}#{remainder}"
+                elsif remainder.empty?
+                    # For exact matches, just return the placeholder
+                    return placeholder
+                else
+                    # For cases where the lemma is a prefix but not a whole word
+                    # (e.g., lemma "over", sublemma "overdo") - don't create a shortcut
+                    return @text
+                end
+            else
+                # If the sublemma doesn't start with the parent lemma, return the full text
+                return @text
+            end
+        end
+        
         # Convert to string representation
         # @return [String] the string representation of this sublemma
         def to_s

data/lib/lexm/version.rb

@@ -9,5 +9,5 @@
 #############################################################
 
 module LexM
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
 end

metadata

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