law_doc 0.1.15

data/lib/law_doc/case.rb

@@ -0,0 +1,318 @@
+module LawDoc
+  class Case
+    STYLES = %i[versus inre].freeze
+
+    attr_reader :number, :complaint_date, :style, :court,
+                :judge, :magistrate, :parties
+
+    include InitTypes
+
+    def initialize(number: nil,
+                   complaint_date: nil,
+                   style: :versus,
+                   court: nil,
+                   judge: nil,
+                   magistrate: nil,
+                   parties: [])
+      @number = number.to_s
+      @complaint_date = init_date(complaint_date, field: 'complaint_date')
+      @court = init_court(court)
+      @judge = init_judge(judge)
+      @magistrate = init_judge(magistrate, field: 'magistrate') if magistrate
+      if style
+        @style = style.to_s.to_sym
+        raise "invalid Case style: '#{@style}'" unless STYLES.include?(@style)
+      end
+      @parties = init_parties(parties)
+    end
+
+    def to_s
+      number
+    end
+
+    def to_h
+      { number: number, complaint_date: complaint_date,
+        style: style, court: court.to_h, judge: judge.to_h,
+        magistrate: magistrate.to_h,
+        parties: parties }
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_h <=> other.to_h
+    end
+
+    # Return an array of parties that are plaintiffs.  Any party whose role
+    # contains 'plaintiff' counts.
+    def plaintiffs
+      result = parties_of_role('plaintiff')
+      parties_matching_role(/plaintiff/i).each do |pty|
+        result << pty unless result.include?(pty)
+      end
+      result
+    end
+
+    # Return the first party that is a plaintiff.
+    def plaintiff
+      plaintiffs.first
+    end
+
+    # Return an array of parties that are defendants.  Any party whose role
+    # contains 'defendant' counts.
+    def defendants
+      result = parties_of_role('defendant')
+      parties_matching_role(/defendant/i).each do |pty|
+        result << pty unless result.include?(pty)
+      end
+      result
+    end
+
+    # Return the first party that is a defendant.
+    def defendant
+      defendants.first
+    end
+
+    # Return an array of parties that are neither plaintiffs nor defendants.
+    def other_parties
+      result = Set.new(parties)
+      result -= plaintiffs
+      result -= defendants
+      result.to_a
+    end
+
+    def parties_of_lawyer(lwy)
+      parties.select { |pty| pty.lawyers.include?(lwy) }
+    end
+
+    def lawyer_parties_names(lwy)
+      parties_of_lawyer(lwy).map(&:name).join_and
+    end
+
+    def lawyer_roles(lwy)
+      ptys = parties_of_lawyer(lwy)
+      role = ptys.first.role
+      if ptys.size == 1
+        role.singularize
+      else
+        role.pluralize
+      end
+    end
+
+    # Return an array of the parties for this case whose role attribute exactly
+    # equals the parameter role.
+    def parties_of_role(role)
+      role = role.to_s.singularize.downcase
+      parties.select { |p| p.role.downcase == role }
+    end
+
+    # Return an array of the parties for this case whose role attribute does
+    # /not/ equal the parameter role.
+    def parties_not_role(role)
+      role = role.to_s.singularize.downcase
+      parties.reject { |p| p.role.downcase == role }
+    end
+
+    # Return an array of the parties for this case whose role matches the regexp
+    # given by role, either as a literal Regexp or as a String converted to a
+    # Regexp.  In the latter case, unless the string starts and ends with '/'
+    # any Regexp meta-characters in the string are quoted.  Matches are done
+    # case insensitively against each party's 'role' attribute.  Since each
+    # party's role will be expressed in the singular form, we singularize before
+    # matching against individual parties.  Thus, 'plaintiffs' will match all
+    # parties with role 'Plaintiff'.
+    def parties_matching_role(role)
+      match_role =
+        case role
+        when Regexp
+          role
+        when String
+          if role =~ %r{\A/([^/]*)/\z}
+            Regexp.new($1.singularize)
+          else
+            Regexp.new(Regexp.quote(role.singularize), true)
+          end
+        else
+          raise ArgumentError, 'role parameter must be Regexp or String'
+        end
+      parties.select { |p| p.role.downcase =~ match_role }
+    end
+
+    # Return an array of the parties for this case whose role does /not/ match
+    # the regexp given by role, either as a literal Regexp or as a String
+    # converted to a Regexp. In the latter case, unless the string starts and
+    # ends with '/' any Regexp meta-characters in the string are quoted. Matches
+    # are done case insensitively against each party's 'role' attribute.
+    def parties_not_matching_role(role)
+      role =
+        case role
+        when Regexp
+          role
+        when String
+          role =
+            if role =~ %r{\A/([^/]*)/\z}
+              Regexp.new($1)
+            else
+              Regexp.new(Regexp.quote(role), true)
+            end
+        else
+          raise ArgumentError, 'role parameter must be Regexp or String'
+        end
+      parties.reject { |p| p.role.downcase =~ role }
+    end
+
+    # Return an array of all roles for parties in this case.
+    def roles
+      roles = Set.new
+      parties.each do |pty|
+        roles << pty.role
+      end
+      roles.to_a
+    end
+
+    # Return a string with the roles of all parties ptys in this kase joined
+    # with and.
+    def party_roles(ptys)
+      # Sort roles by number of parties in each role
+      roles = ptys.group_by(&:role).transform_values(&:count).sort
+      # Pluralize by count
+      role_names = []
+      roles.each do |role, count|
+        role_names << role.pluralize(count)
+      end
+      role_names.join_and
+    end
+
+    def tex_lawdoc_caption_inre
+      pps = parties_of_role(roles.first)
+      body = ''
+      unless pps.empty?
+        body = '\\textbf{In the Matter of:}\\\\[12pt]'
+        pps.each_with_flags do |pty, first, _last|
+          body += "\\versusand\n" unless first
+          body += "\\aparty{#{pty.name.tq},}\\\\\n"
+        end
+        body += "\\role{#{roles.first.tq + (pps.size > 1 ? 's' : '')}}"
+      end
+      # Same body for both styles
+      <<~CAPTION
+        \\LeftFullCaptionBlock{%\n
+           #{body}
+        }\n\n
+        \\LeftCaptionBlock}{%\n
+          #{body}
+        }\n\n
+      CAPTION
+    end
+
+    # Compute FullLeftCaptionBlock
+    def tex_lawdoc_full_caption_versus
+      result = "\\LeftFullCaptionBlock{%\n"
+      unless plaintiffs.empty?
+        pgroups = plaintiffs.group_by(&:role)
+        first_group = true
+        pgroups.each_value do |ps|
+          if first_group
+            first_group = false
+          else
+            result += "  \\versusand\n"
+          end
+          ps.each do |p|
+            result += "  \\aparty{#{p.name.tq}}\\\\\n"
+          end
+          role_str = ps.length > 1 ? ps.first.role.pluralize : ps.first.role
+          result += "  \\role{#{role_str.tq}}\n"
+        end
+        result += "  \\versus\n"
+      end
+      unless defendants.empty?
+        dgroups = defendants.group_by(&:role)
+        first_group = true
+        dgroups.each_value do |ds|
+          if first_group
+            first_group = false
+          else
+            result += "  \\versusand\n"
+          end
+          ds.each do |d|
+            result += "  \\aparty{#{d.name.tq}}\\\\\n"
+          end
+          role_str = ds.length > 1 ? ds.first.role.pluralize : ds.first.role
+          result += "  \\role{#{role_str.tq}}\n"
+        end
+      end
+      unless other_parties.empty?
+        ogroups = other_parties.group_by(&:role)
+        first_group = true
+        ogroups.each_value do |os|
+          if first_group
+            first_group = false
+          else
+            result += "  \\versusand\n"
+          end
+          os.each do |d|
+            result += "  \\aparty{#{d.name.tq}}\\\\\n"
+          end
+          role_str = os.length > 1 ? os.first.role.pluralize : os.first.role
+          result += "  \\role{#{role_str.tq}}\n"
+        end
+      end
+      result += "}\n"
+      result
+    end
+
+    # Compute LeftCaptionBlock
+    def tex_lawdoc_caption_versus
+      result = "\\LeftCaptionBlock{%\n"
+      unless plaintiffs.empty?
+        p = plaintiffs.first
+        et_al = plaintiffs.length > 1 ? ', \textit{et al.}' : ''
+        role_str = plaintiffs.length > 1 ? p.role.pluralize : p.role
+        result += "  \\party{#{p.name.tq}#{et_al}}{#{role_str.tq}}\\\\\n"
+        result += "  \\versus\n"
+      end
+      unless defendants.empty?
+        d = defendants.first
+        et_al = defendants.length > 1 ? ', \textit{et al.}' : ''
+        role_str = defendants.length > 1 ? d.role.pluralize : d.role
+        result += "  \\party{#{d.name.tq}#{et_al}}{#{role_str.tq}}\\\\\n"
+      end
+      result += "}\n"
+      result
+    end
+
+    def tex_lawdoc_caption
+      if style == :inre
+        tex_lawdoc_caption_inre
+      else
+        tex_lawdoc_caption_versus
+      end
+    end
+
+    def tex_lawdoc_full_caption
+      if style == :inre
+        tex_lawdoc_full_caption_inre
+      else
+        tex_lawdoc_full_caption_versus
+      end
+    end
+
+    def tex_lawdoc_macros
+      result = ''
+      result += "\\CaseNumber{#{number.tq}}\n"
+      if judge
+        result += "\\JudgeInitials{#{judge.initials.tq}}\n"
+        result += "\\JudgeLast{#{judge.last.tq}}\n"
+        result += "\\JudgeName{#{judge.name.tq}}\n"
+      end
+      if magistrate
+        result += "\\MagistrateInitials{#{magistrate.initials.tq}}\n"
+        result += "\\MagistrateLast{#{magistrate.last.tq}}\n"
+        result += "\\MagistrateName{#{magistrate.name.tq}}\n"
+      end
+      result += tex_lawdoc_caption
+      result += tex_lawdoc_full_caption
+      result
+    end
+  end
+end

data/lib/law_doc/core_ext/array.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/object/blank'
+
+class Array
+  def non_blank
+    select { |x| !x.blank? }
+  end
+
+  def join_nonblank(sep = ' ')
+    non_blank.join(sep)
+  end
+
+  def join_serial(sep = ', ', last_sep = ', ')
+    result = ''
+    non_blank.each_with_flags do |itm, first, last|
+      next if itm.blank?
+      result +=
+        if first
+          itm.to_s
+        elsif last
+          "#{last_sep}#{itm}"
+        else
+          "#{sep}#{itm}"
+        end
+    end
+    result
+  end
+
+  def join_and
+    items = non_blank
+    case items.size
+    when 1
+      items.first.to_s
+    when 2
+      items.join(' and ')
+    else
+      join_serial(', ', ', and ')
+    end
+  end
+
+  def join_or
+    items = non_blank
+    case items.size
+    when 1
+      items.first.to_s
+    when 2
+      items.join(' and ')
+    else
+      join_serial(', ', ', or ')
+    end
+  end
+end

data/lib/law_doc/core_ext/nil.rb

@@ -0,0 +1,9 @@
+class NilClass
+  def tex_block
+    ''
+  end
+
+  def tq
+    ''
+  end
+end

data/lib/law_doc/core_ext/numeric.rb

@@ -0,0 +1,34 @@
+class Numeric
+  def ordinal
+    if abs < 10
+      # Single digit
+      if abs == 1
+        "#{self}st"
+      elsif self.abs == 2
+        "#{self}nd"
+      elsif self.abs == 3
+        "#{self}rd"
+      else
+        "#{self}th"
+      end
+    elsif [0, 4, 5, 6, 7, 8, 9].include?(abs % 10) ||
+          [11, 12, 13].include?(abs % 100)
+      "#{self}th"
+    elsif abs % 10 == 1
+      "#{self}st"
+    elsif abs % 10 == 2
+      "#{self}nd"
+    elsif abs % 10 == 3
+      "#{self}rd"
+    else
+      raise "Numeric#ordinal unhandled case: #{self}"
+    end
+  end
+
+  def month_name
+    index = (abs % 12) - 1
+    months = %w[January February March April May June July August
+                September October November December ]
+    months[index]
+  end
+end

data/lib/law_doc/core_ext/string.rb

@@ -0,0 +1,3 @@
+class String
+  alias tq tex_quote
+end

data/lib/law_doc/core_ext.rb

@@ -0,0 +1,4 @@
+require 'law_doc/core_ext/array'
+require 'law_doc/core_ext/numeric'
+require 'law_doc/core_ext/string'
+require 'law_doc/core_ext/nil'

data/lib/law_doc/court.rb

@@ -0,0 +1,48 @@
+module LawDoc
+  class Court < Person
+    attr_reader :division, :district, :state
+
+    def initialize(division: nil,
+                   district: nil,
+                   state: nil,
+                   **other)
+      other[:sex] = 'entity'
+      super(**other)
+      @district = district
+      @division = division
+      @state = state
+    end
+
+    def to_h
+      super.merge({ division: division,
+                   district: district,
+                   state: state })
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_h <=> other.to_h
+    end
+
+    def tex_lawdoc_forum
+      components = []
+      components << '\\begin{center}'
+      components << "#{name.tq}\\\\"
+      components << "For the #{district.tq}\\\\" if district
+      components << "(#{division.tq} Division)\\\\" if division
+      components << '\\end{center}'
+      components.join_nonblank("\n")
+    end
+
+    def tex_lawdoc_macros
+      <<~ENDM
+        \\renewcommand{\\Forum}{#{tex_lawdoc_forum}}
+        \\renewcommand{\\CourtName}{#{name.tq}}
+        \\renewcommand{\\CourtDistrict}{#{district.tq}}
+        \\renewcommand{\\CourtDivision}{#{division.tq}}
+        \\renewcommand{\\CourtState}{#{state.tq}}
+      ENDM
+    end
+  end
+end