Регулярное выражение для названий юридических дел

CASE_REGEXP = %r{
  (?<spaces>    \s+ ){0}
  (?<capword>   [[:upper:]] [[:alpha:]']+ ){0}
  (?<titleword> \g<capword> | & ){0}
  (?<title>     \g<capword> (?:\g<spaces> \g<titleword>)* ){0}
  (?<year>      \[ \d{4} \] | \( \d{4} \) ){0}
  (?<endbit>    [[:upper:]]+ \g<spaces> \d+ ){0}

  \g<title> \g<spaces> v \g<spaces> \g<title>
  \g<spaces> \g<year>
  \g<spaces> \g<endbit>
}x

Ruby Oniguruma очень мощный и дает вам возможность писать очень четкие регулярные выражения, даже если вам нужно что-то более сложное.

EDIT: забыл о году и все остальное в конце. Немного поправим.

EDIT2: добавлено.

Вот то, что я придумал, чтобы соответствовать обоим случаям.

(([A-Z]('[A-Z]|[a-z][A-Z])?[a-z]+[A-Z]?|&)\s)+(v\s)(([A-Z]('[A-Z]|[a-z][A-Z])?[a-z]+[A-Z]?|&)\s)+\[\d{4}\]\s[A-Z]+\s\d+

Здесь разбивка

(([A-Z]('[A-Z]|[a-z][A-Z])?[a-z]+[A-Z]?|&)\s)+

Это будет соответствовать &, и такие слова, как Adam, O'Neal, McCarthy, он учитывает различные возможности случая для имен.

(v\s)

Это будет соответствовать букве v за которой следует пробел

(([A-Z]('[A-Z]|[a-z][A-Z])?[a-z]+[A-Z]?|&)\s)+

То же, что и раньше.

\[\d{4}\]\s

Это будет соответствовать [, затем 4 номера, затем ]

[A-Z]+\s\d+

Эта последняя часть будет содержать 4 заглавных буквы, а затем цифры. Я не уверен, что буквы и числа ограничены в некотором роде, если заглавные буквы всегда 4 буквы, а цифры от 3 до 4 цифр, вы можете сделать это

[A-Z]{4}\s\d{3,4}

Я бы не попытался сопоставить строку с одним регулярным выражением. Рассмотрим следующее.

Код

R1 = /
     \s+v\s+ # match 'v' preceded by >= 1 spaces and followed by >= 1 spaces
     |       # or
     \s+\[   # match a left bracket preceded by >=1 spaces
     |       # or
     \]\s+   # match a right bracket followed by >=1 spaces
     /x      # free-spacing regex definition mode 

def legal_case_name?(str)
  party1, party2, year, id = str.split R1
  valid_party?(party1) && valid_party?(party2) && valid_year?(year) && valid_id?(id)
end

def valid_party?(party)
  return false if party.nil?       
  party.split.all? { |word| word == '&' || word =~ /\A[[:alpha:]]+\z/ }
end

def valid_year?(year)
  return false unless year =~ /\A\d{4}\z/
  (1950..2040).cover? year.to_i
end

R2 = /
     EWHC\s+\d{4}  # match 'EWHC' followed by >= 1 spaces and then 4 digits
     |             # or
     PNLR\s+\d{3}  # match 'PNLR' followed by >= 1 spaces and then 3 digits
     |             # or
     ABC\s+\d{5}   # match 'ABC' followed by >= 1 spaces and then 5 digits
     /x      # free-spacing regex definition mode 

def valid_id?(id)
  (id =~ R2) ? true : false
end

Некоторые из этих методов, вероятно, необходимо будет изменить для отражения требований.

Примеры

legal_case_name? "Seele GmbH & Co v Tokyo Insurance Ltd [2009] EWHC 2066"
  #=> true
legal_case_name? "Darlington Soc v Scourfield & McCarthy [1999] PNLR 365"
  #=> true
legal_case_name? "Darlington Soc vs Scourfield & McCarthy [1999] PNLR 365"
  #=> false
legal_case_name? "Darlington Soc v Scourfield & McCarthy [1921] PNLR 365"
  #=> false
legal_case_name? "Darlington Soc v Scourfield & McCarthy [1921] PNLR 3652"
  #=> false

объяснение

предполагать

str = "Seele GmbH & Co v Tokyo Insurance Ltd [2009] EWHC 2066"

затем

party1, party2, year, id = str.split R1
  #=> ["Seele GmbH & Co", "Tokyo Insurance Ltd", "2009", "EWHC 2066"]
party1
  #=> "Seele GmbH & Co" 
party2
  #=> "Tokyo Insurance Ltd" 
year
  #=> "2009" 
id
  #=> "EWHC 2066" 
valid_party?(party1)
  #=> true 
valid_party?(party2)
  #=> true 
valid_year?(year)
  #=> true 
valid_id?(id)
  #=> true 

Это регулярное выражение совпадает с примером:

([A-Z][A-Za-z\s]+|\s&\s).*(\sv\s)[^\[]*\[[0-9]{4}\]\s[A-Z]+\s[0-9]+

Но если это не работает для другого, просто передайте мне текст, который я попытаюсь приспособить к моему ответу.