pattern-ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f811da9c8851dd1ac42ed24ab7db8b93a05bcefd61d9c76a66676e3c97cbdf15
-  data.tar.gz: 3b282051dfbd99a38a5960d6ce46e7637b5ba63a1c2d9bbcae908ba58af7e558
+  metadata.gz: 3cf30e8485bb83eb27f583e82c6e54c6556ded68150104ee2a35f95032af655d
+  data.tar.gz: 27e26d1dd70b4f89457281e7234b95c766a883f71ce76bbbef4fe6d0c5838a1b
 SHA512:
-  metadata.gz: 13de001ca6e9657cf5faa5ec36bf5ffc5522d957fd54b92c7b13a7d72e0748582f566208dc8b93307d78aa44aa5607ec0234a73443a36bb8ec75a8eb763544dc
-  data.tar.gz: db8cd6c927e091c6bbdacc9a50e75e454041342fb2cfd9378ffc9687715435aafa9e01544d2be9b20a09f617c7522283e028dd3b6f4b5e90dde189b7cb865c11
+  metadata.gz: 26f94c3c765863235125bbedf9a1c6f460a2691744665001b2e91245f324f1976fd6c8a20bd0e2342651c2d8c7122d8ebdc2f4a46ca2d2e35a2ac07a9005f526
+  data.tar.gz: fb5b161865d3c210c3e5b8692bb7472fc0995e26f45553c20b039d5db8cbbfbe5cba45be99508b3eaf86db64a8474cbf1dc531b299fb32cd98741611d2f52c33

data/lib/pattern_ruby/conversation.rb

@@ -75,12 +75,24 @@ module PatternRuby
       return false unless intent
 
       # Find entity definitions that don't have a slot value yet
-      unfilled = intent.entity_definitions.select { |name, _| !@slots.key?(name) || @slots[name].nil? }
+      unfilled = intent.entity_definitions.select { |k, _| !@slots.key?(k) || @slots[k].nil? }
       return false if unfilled.empty?
 
       # Try the input as a value for the first unfilled slot
-      name, _defn = unfilled.first
-      @slots[name] = input.strip
+      slot_name, defn = unfilled.first
+      value = input.strip
+
+      # Validate against entity type constraints if defined
+      if defn
+        if defn[:values] && !defn[:values].include?(value)
+          return false
+        end
+        if defn[:pattern] && !value.match?(defn[:pattern])
+          return false
+        end
+      end
+
+      @slots[slot_name] = value
       true
     end
   end

data/lib/pattern_ruby/pattern_compiler.rb

@@ -24,49 +24,88 @@ module PatternRuby
       @entity_registry = entity_registry
     end
 
-    def compile(pattern_string)
+    def self.validate!(pattern_string)
+      new.validate!(pattern_string)
+    end
+
+    def validate!(pattern_string)
       raise ArgumentError, "pattern must be a String, got #{pattern_string.class}" unless pattern_string.is_a?(String)
       raise ArgumentError, "pattern cannot be nil or empty" if pattern_string.nil? || pattern_string.strip.empty?
       if pattern_string.length > MAX_PATTERN_LENGTH
         raise ArgumentError, "pattern exceeds maximum length of #{MAX_PATTERN_LENGTH} characters"
       end
 
+      # Check for unbalanced brackets
+      check_balanced(pattern_string, "[", "]", "square brackets")
+      check_balanced(pattern_string, "(", ")", "parentheses")
+      check_balanced(pattern_string, "{", "}", "curly braces")
+
+      # Check for empty entity names
+      if pattern_string.match?(/\{\s*\}/)
+        raise ArgumentError, "empty entity name {} in pattern"
+      end
+      if pattern_string.match?(/\{\s*:/)
+        raise ArgumentError, "entity name cannot start with ':' in pattern"
+      end
+
+      true
+    end
+
+    def compile(pattern_string)
+      validate!(pattern_string)
+
       tokens = tokenize(pattern_string)
       entity_names = []
       literal_count = 0
       regex_parts = []
+      optional_flags = []
 
       tokens.each do |token|
         case token
         when EntityToken
           entity_names << token.name.to_sym
           regex_parts << build_entity_regex(token)
+          optional_flags << false
         when OptionalToken
           inner = compile_inner(token.content)
           entity_names.concat(inner[:entity_names])
-          regex_parts << "(?:\\s+#{inner[:regex]})?"
+          regex_parts << inner[:regex]
+          optional_flags << true
         when AlternationToken
           alts = token.alternatives.map { |a| Regexp.escape(a) }
           regex_parts << "(?:#{alts.join('|')})"
           literal_count += 1
+          optional_flags << false
         when WildcardToken
           regex_parts << "(.+)"
+          optional_flags << false
         when LiteralToken
           regex_parts << Regexp.escape(token.text)
           literal_count += 1
+          optional_flags << false
         end
       end
 
       token_count = tokens.size
       entity_count = entity_names.size
 
-      # Join with \s+ but make whitespace before optional groups flexible
+      # Join parts with \s+ separators, wrapping optional parts in (?:...)?
       regex_str = +""
+      need_sep = false
       regex_parts.each_with_index do |part, i|
-        if i > 0 && !part.start_with?("(?:\\s+") # optional groups already include leading \s+
-          regex_str << "\\s+"
+        if optional_flags[i]
+          if i == 0
+            regex_str << "(?:#{part}\\s+)?"
+            need_sep = false
+          else
+            regex_str << "(?:\\s+#{part})?"
+            need_sep = true
+          end
+        else
+          regex_str << "\\s+" if need_sep
+          regex_str << part
+          need_sep = true
         end
-        regex_str << part
       end
 
       regex = Regexp.new("\\A\\s*#{regex_str}\\s*\\z", Regexp::IGNORECASE)
@@ -97,11 +136,14 @@ module PatternRuby
         scanner.skip(/\s+/)
         break if scanner.eos?
 
-        if scanner.scan(/\{([^}]+)\}/)
+        if scanner.scan(/\{([^}]*)\}/)
           # Entity: {name} or {name:constraint}
           content = scanner[1]
+          raise ArgumentError, "empty entity name {} in pattern" if content.strip.empty?
           name, constraint = content.split(":", 2)
-          tokens << EntityToken.new(name.strip, constraint&.strip)
+          name = name.strip
+          raise ArgumentError, "empty entity name in pattern" if name.empty?
+          tokens << EntityToken.new(name, constraint&.strip)
         elsif scanner.scan(/\[/)
           # Optional: [content]
           depth = 1
@@ -159,6 +201,16 @@ module PatternRuby
       end
     end
 
+    def check_balanced(str, open_char, close_char, name)
+      depth = 0
+      str.each_char do |c|
+        depth += 1 if c == open_char
+        depth -= 1 if c == close_char
+        raise ArgumentError, "unbalanced #{name} in pattern: #{str.inspect}" if depth < 0
+      end
+      raise ArgumentError, "unbalanced #{name} in pattern: #{str.inspect}" if depth != 0
+    end
+
     def compile_inner(content)
       inner_tokens = tokenize(content)
       entity_names = []

data/lib/pattern_ruby/pipeline.rb

@@ -2,6 +2,7 @@ module PatternRuby
   class Pipeline
     def initialize(&block)
       @steps = []
+      @error_handler = nil
       instance_eval(&block) if block
     end
 
@@ -9,10 +10,21 @@ module PatternRuby
       @steps << { name: name, handler: block }
     end
 
+    def on_error(&block)
+      @error_handler = block
+    end
+
     def process(input)
       result = input
       @steps.each do |s|
         result = s[:handler].call(result)
+      rescue => e
+        if @error_handler
+          result = @error_handler.call(e, s[:name], result)
+          break if result.nil?
+        else
+          raise
+        end
       end
       result
     end

data/lib/pattern_ruby/version.rb

@@ -1,3 +1,3 @@
 module PatternRuby
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Johannes Dwi Cahyo