law_doc 0.1.15

data/lib/law_doc/document.rb

@@ -0,0 +1,452 @@
+module LawDoc
+  # LawDoc class for representing a legal document, a pleading, motion, or
+  # other litigation-related document.
+  class Document
+    attr_reader :preamble, :postamble
+
+    include InitTypes
+
+    # TODO: since most of the setter-getter methods, like signers, etc, depend on there being a kase and
+    # on_behalf_of set, perhaps those arguments should be mandatory and set before anything else.
+
+    def initialize(title: nil, kase: nil,
+                   sig_date: nil,
+                   on_behalf_of: nil,
+                   signers: nil, signer: nil,
+                   server: nil,
+                   service_date: nil)
+      @kase = kase
+      @title = title
+      @on_behalf_of = []
+      self.on_behalf_of = on_behalf_of if on_behalf_of
+      @signers = []
+      @signers << signer if signer
+      @signers += signers if signers
+      @sig_date = init_date(sig_date) || Date.today
+      @service_date = service_date || @sig_date
+      @server = init_person(server)
+      @server = @signers.first if @server.nil?
+      @preamble = <<~'PRE'
+        \makeatletter
+        \usepackage{longtable}
+        % \blkwd is meant to be the width of one block, such as a lawyers block,
+        % such that two side-by-side in a table take up 95% of the  text width
+        \newlength{\blkwd}%
+        \setlength{\blkwd}{(\textwidth - \tabcolsep * 4) * \real{0.95} / 2}%
+      PRE
+      @postamble = <<~'POST'
+        \makeatother
+      POST
+      yield self if block_given?
+    end
+
+    def to_h
+      {
+        title: title, kase: kase, sig_date: sig_date,
+        signers: signers, service_date: service_date,
+        on_behalf_of: on_behalf_of
+      }
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_h <=> other.to_h
+    end
+
+    #######################################################################
+    # Attributes
+    #######################################################################
+
+    # Set or return title
+    def title(*title)
+      title.empty? ? @title : @title = title.first.to_s
+    end
+
+    # Set or return kase
+    def kase(*kase)
+      kase.empty? ? @kase : @kase = init_case(kase.first)
+    end
+
+    # Set or return sig_date
+    def sig_date(*sig_date)
+      if sig_date.empty?
+        @sig_date
+      else
+        @sig_date = init_date(sig_date.first, field: 'sig_date')
+      end
+    end
+
+    # Set or return service_date
+    def service_date(*service_date)
+      if service_date.empty?
+        @service_date
+      else
+        @service_date = init_date(service_date.first, field: 'service_date')
+      end
+    end
+
+    # Set or return signers
+    def signers(*signers)
+      if signers.empty?
+        @signers
+      else
+        signers.each do |sgnr|
+          signer(sgnr)
+        end
+      end
+    end
+
+    # Set a single signer
+    def signer(person = nil)
+      return @signers.first if person.nil?
+
+      person = init_person(person, field: 'signers')
+      raise ArgumentError, 'signer must be a Person' unless person.is_a?(Person)
+
+      # Confirm that signer is an attorney for the party submitting the document before adding to signers.
+      signer_parties = on_behalf_of
+      if signer_parties.empty?
+        raise ArgumentError, "must set 'on_behalf_of' before signer"
+      end
+
+      parties_lawyers = signer_parties.map(&:lawyers).flatten.uniq
+      unless parties_lawyers.include?(person)
+        raise ArgumentError, "signer #{person.name} must be a lawyer for on_behalf_of party "
+      end
+
+      @signers ||= []
+      @signers << person
+      @signers = @signers.compact.uniq
+    end
+
+    # Set or return server
+    def server(*server)
+      case server.size
+      when 0
+        @server
+      else
+        @server = init_person(server.first)
+      end
+    end
+
+    # Set party or parties on behalf of whom the document is being
+    # submitted.
+    def on_behalf_of=(role_or_parties)
+      if role_or_parties.is_a?(Enumerable) && role_or_parties.size == 1
+        role_or_parties = role_or_parties.first
+      end
+      @on_behalf_of =
+        case role_or_parties
+        when String, Party
+          rop_to_parties(role_or_parties)
+        when Array
+          parties = []
+          role_or_parties.each do |rop|
+            ptys = rop_to_parties(rop)
+            ptys.each do |pty|
+              unless kase.parties.include?(pty)
+                raise ArgumentError, "'#{pty}' is not a party to #{kase}"
+              end
+
+              parties << pty
+            end
+          end
+          parties
+        else
+          raise ArgumentError,
+                "cannot convert '#{role_or_parties}' of class #{role_or_parties.class} to Parties"
+        end
+    end
+
+    # Set party or parties on behalf of whom the document is being
+    # submitted.
+    def on_behalf_of(*role_or_parties)
+      if role_or_parties.empty?
+        @on_behalf_of
+      else
+        unless kase
+          raise UserError,
+                'must set kase /before/ setting on_behalf_of'
+        end
+        self.on_behalf_of = role_or_parties
+      end
+    end
+
+    # Parties other than those on whose behalf this document is being filed.
+    def not_on_behalf_of
+      kase.parties - on_behalf_of
+    end
+
+    # Return all parties with the given lawyer.
+    def parties_with_lawyer(lwy)
+      parties = Set.new
+      kase.parties.each do |pty|
+        parties << pty if pty.lawyers.include?(lwy)
+      end
+      parties
+    end
+
+    # Return all lawyers for the given party or parties.
+    def lawyers_for(parties)
+      parties = [parties] if parties.is_a?(Party)
+      lawyers = Set.new
+      parties.each do |pty|
+        pty.lawyers.each do |lwy|
+          lawyers << lwy
+        end
+      end
+      lawyers.to_a.compact
+    end
+
+    # Return all lawyers representing the party or parties on whose behalf this
+    # document is being filed.
+    def our_lawyers
+      lawyers_for(on_behalf_of)
+    end
+
+    # Return all lawyers /not/ representing the party or parties on whose behalf
+    # this document is being filed.
+    def their_lawyers
+      lawyers_for(not_on_behalf_of)
+    end
+
+    def tex_lawdoc_macros
+      result = preamble
+      result += kase.tex_lawdoc_macros
+      result += tex_lawdoc_document
+      result += tex_lawdoc_our_role
+      result += tex_lawdoc_their_role
+      result += tex_lawdoc_signers_block
+      result += tex_lawdoc_signatures
+      result += tex_lawdoc_our_lawyers_block
+      result += tex_lawdoc_their_lawyers_block
+      result += tex_lawdoc_service_list
+      result += postamble
+      result
+    end
+
+    # Macro to define lawyer information block for lawyers representing the
+    # party on whose behalf the document is being file.
+    # the pre-caption area.
+    def tex_lawdoc_our_lawyers_block
+      lwys = lawyers_for(on_behalf_of)
+      "\\OurLawyersBlock{%\n#{tex_lawdoc_lawyers_block(lwys)}}\n"
+    end
+
+    # Party role of party on whose behalf document is being filed, e.g.,
+    # "Plaintiff", "Defendant", etc.
+    def tex_lawdoc_our_role
+      ptys = on_behalf_of
+      "\\OurRole{#{kase.party_roles(ptys)}}\n"
+    end
+
+    # Macro to define lawyer information block for lawyers NOT representing
+    # the party on whose behalf the document is being file.  the pre-caption
+    # area.
+    def tex_lawdoc_their_lawyers_block
+      lwys = lawyers_for(not_on_behalf_of)
+      "\\TheirLawyersBlock{%\n#{tex_lawdoc_lawyers_block(lwys)}}\n"
+    end
+
+    # Party role of party of opposing counsel, e.g., "Plaintiff", "Defendant",
+    # etc.
+    def tex_lawdoc_their_role
+      ptys = not_on_behalf_of
+      "\\TheirRole{#{kase.party_roles(ptys)}}\n"
+    end
+
+    # Macro to define lawyer information block, not for the signatures, but
+    # where a list of the lawyers signing the document are needed, e.g., in
+    # the pre-caption area.
+    def tex_lawdoc_signers_block
+      "\\SignersBlock{%\n#{tex_lawdoc_lawyers_block(signers)}}\n"
+    end
+
+    # Macro to define lawyer information block for lawyer serving the document
+    # to opposing counsel.  Not much needed in the era of electronic filing.
+    def tex_lawdoc_service_list
+      lwys = lawyers_for(not_on_behalf_of)
+      "\\ServiceList{%\n#{tex_lawdoc_lawyers_block(lwys)}}\n"
+    end
+
+    # Longtable that places lawyer info block for the given array of lawyers
+    # in a table two across.
+    def tex_lawdoc_lawyers_block(the_lwys)
+      # Form the output string
+      result = <<~'LTPRE'
+        {\setlength{\LTpre}{0pt}
+        \setlength{\LTpost}{0pt}
+        \setlength{\extrarowheight}{12pt}%
+        \begin{small}
+          \singlespace
+          \begin{longtable}[l]{ll}%
+      LTPRE
+      the_lwys.groups_of(2).each do |_k, lwys|
+        l1, l2 = lwys
+        bar_state = kase.court.state
+        result += "\\parbox[t]{\\blkwd}{\n"
+        result += l1.tex_block(bar_state: bar_state, full: true).to_s
+        result += "}&\n"
+        next unless l2
+
+        result += "\\parbox[t]{\\blkwd}{\n"
+        result += l2.tex_block(bar_state: bar_state, full: true).to_s
+        result += "}\\\\\n"
+      end
+      result += <<~'LTPOST'
+          \end{longtable}
+        \end{small}}
+      LTPOST
+    end
+
+    private
+
+    # Return string for lawyer's capacity in kase associated with this
+    # document.
+    def capacity(lawyer, full: false)
+      return '' unless lawyer.is_a?(Lawyer)
+
+      pname = kase.lawyer_parties_names(lawyer)
+      prole = kase.lawyer_roles(lawyer)
+      if full
+        "Attorney for #{prole}, #{pname}"
+      else
+        "Attorney for #{prole}"
+      end
+    end
+
+    # Translate a string or Party to an array of Party's, using matching on the
+    # role for a string.
+    def rop_to_parties(rop)
+      case rop
+      when String
+        kase.parties_matching_role(rop)
+      when Party
+        unless kase.parties.include?(rop)
+          raise ArgumentError, "'#{rop}' is not a party to #{kase}"
+        end
+
+        [rop]
+      else
+        raise ArgumentError, "cannot convert '#{rop}' to a Party"
+      end
+    end
+
+    def tex_lawdoc_document
+      result = <<~MACS
+        \\DocTitle{#{title.tq}}
+        \\SignerName{#{signer.name.tq}}
+        \\SignerAddress{#{signer.address.tex_block}}
+        \\SignerBarState{#{kase.court.state.tq}}
+        \\SignerBarNumber{#{signer.bar_numbers[kase.court.state]}}
+        \\SignerPhone{#{signer.phone.to_s.tq}}
+        \\SignerFax{#{signer.fax.to_s.tq}}
+        \\SignerEmail{#{signer.email.to_s.tq}}
+        \\SignerSig{#{signer.sig}}
+        \\SignerESig{#{signer.esig.tq}}
+        \\SigDate{#{sig_date.eng}}
+      MACS
+      if server
+        result += <<~MACS
+          \\ServerName{#{server.name.tq}}
+          \\ServerSig{#{server.sig}}
+          \\ServerESig{#{server.esig.tq}}
+          \\ServiceDate{#{service_date.eng}}
+        MACS
+      end
+      result
+    end
+
+    # Longtable that places lawyer signature block for the given array of
+    # lawyers in a table two across.
+    def tex_lawdoc_signatures
+      state = kase.court.state
+      if signers.size == 1
+        l1 = signers.first
+        cap = capacity(l1, full: true)
+        full_signature = "#{l1.tex_sigblock(capacity: cap, sig: l1.sig, bar_state: state, full: true)}\n"
+        full_esignature = "#{l1.tex_sigblock(capacity: cap, sig: l1.esig, bar_state: state, full: true)}\n"
+        full_blank_signature = "#{l1.tex_sigblock(capacity: cap, sig: '', bar_state: state, full: true)}\n"
+        signature = "#{l1.tex_sigblock(capacity: cap, sig: l1.sig, bar_state: state)}\n"
+        esignature = "#{l1.tex_sigblock(capacity: cap, sig: l1.esig, bar_state: state)}\n"
+        blank_signature = "#{l1.tex_sigblock(capacity: cap, sig: '', bar_state: state)}\n"
+        return <<~MACS
+        \\Signature{%
+          \\ifthenelse{\\boolean{sign}}%
+            {#{signature}}
+            {\\ifthenelse{\\boolean{esign}}%
+              {#{esignature}}
+              {#{blank_signature}}}}
+        \\FullSignature{%
+          \\ifthenelse{\\boolean{sign}}%
+            {#{full_signature}}
+            {\\ifthenelse{\\boolean{esign}}%
+              {#{full_esignature}}
+              {#{full_blank_signature}}}}
+       MACS
+      end
+
+      # Form the output string
+      lt_pre = <<~'PRESIGS'
+        {
+        \setlength{\parindent}{0pt}%
+      PRESIGS
+      lt_post = <<~'POSTSIGS'
+        }
+      POSTSIGS
+      # Six different body for variations, (1) full or normal, and (2) sig,
+      # esig, or blank signatures.
+      full_sig_body = ''
+      full_esig_body = ''
+      full_blanksig_body = ''
+      sig_body = ''
+      esig_body = ''
+      blanksig_body = ''
+      signers.groups_of(2).each do |_k, lwys|
+        l1, l2 = lwys
+        cap = capacity(l1)
+        full_cap = capacity(l1, full: true)
+        f = '\hfill'
+        # f = '&'
+        full_sig_body += "#{l1.tex_plainsigblock(capacity: full_cap, sig: l1.sig, bar_state: state, full: true)}#{f}\n"
+        full_esig_body += "#{l1.tex_plainsigblock(capacity: full_cap, sig: l1.esig, bar_state: state, full: true)}#{f}\n"
+        full_blanksig_body += "#{l1.tex_plainsigblock(capacity: full_cap, sig: '', bar_state: state, full: true)}#{f}\n"
+        sig_body += "#{l1.tex_plainsigblock(capacity: cap, sig: l1.sig, bar_state: state)}#{f}\n"
+        esig_body += "#{l1.tex_plainsigblock(capacity: cap, sig: l1.esig, bar_state: state)}#{f}\n"
+        blanksig_body += "#{l1.tex_plainsigblock(capacity: cap, sig: '', bar_state: state)}#{f}\n"
+        next unless l2
+
+        cap = capacity(l2)
+        f = "\n\n\\vspace{14pt}\n"
+        full_cap = capacity(l2, full: true)
+        full_sig_body += "#{l2.tex_plainsigblock(capacity: full_cap, sig: l2.sig, bar_state: state, full: true)}#{f}"
+        full_esig_body += "#{l2.tex_plainsigblock(capacity: full_cap, sig: l2.esig, bar_state: state, full: true)}#{f}"
+        full_blanksig_body += "#{l2.tex_plainsigblock(capacity: full_cap, sig: '', bar_state: state, full: true)}#{f}"
+        sig_body += "#{l2.tex_plainsigblock(capacity: cap, sig: l2.sig, bar_state: state)}#{f}"
+        esig_body += "#{l2.tex_plainsigblock(capacity: cap, sig: l2.esig, bar_state: state)}#{f}"
+        blanksig_body += "#{l2.tex_plainsigblock(capacity: cap, sig: '', bar_state: state)}#{f}"
+      end
+      full_signature = lt_pre + full_sig_body + lt_post
+      full_esignature = lt_pre + full_esig_body + lt_post
+      full_blank_signature = lt_pre + full_blanksig_body + lt_post
+      signature = lt_pre + sig_body + lt_post
+      esignature = lt_pre + esig_body + lt_post
+      blank_signature = lt_pre + blanksig_body + lt_post
+      <<~MACS
+        \\Signature{%
+          \\ifthenelse{\\boolean{sign}}%
+            {#{signature}}
+            {\\ifthenelse{\\boolean{esign}}%
+              {#{esignature}}
+              {#{blank_signature}}}}
+        \\FullSignature{%
+          \\ifthenelse{\\boolean{sign}}%
+            {#{full_signature}}
+            {\\ifthenelse{\\boolean{esign}}%
+              {#{full_esignature}}
+              {#{full_blank_signature}}}}
+      MACS
+    end
+  end
+end

data/lib/law_doc/error.rb

@@ -0,0 +1,2 @@
+class UserError < RuntimeError; end
+class LogicError < RuntimeError; end

data/lib/law_doc/init_types.rb

@@ -0,0 +1,182 @@
+module LawDoc
+  module InitTypes
+    def init_date(dt, field: 'date')
+      case dt
+      when Date
+        dt
+      when String
+        Date.parse(dt)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{dt.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_address(addr, field: 'address')
+      case addr
+      when Address
+        addr
+      when Hash
+        if addr.empty?
+          nil
+        else
+          Address.new(**addr)
+        end
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{addr.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_phone(phn, field: 'phone')
+      case phn
+      when Phone
+        phn
+      when String
+        Phone.new(phn)
+      when Hash
+        if phn.empty?
+          nil
+        else
+          Phone.new(**phn)
+        end
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{phn.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_person(psn, field: 'person')
+      case psn
+      when Lawyer
+        psn
+      when Person
+        psn
+      when Hash
+        return nil if psn.empty?
+
+        if psn.symbolize_keys.keys.include?(:bar_numbers)
+          Lawyer.new(**psn)
+        else
+          Person.new(**psn)
+        end
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{psn.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_lawyer(lwy, field: 'lawyer')
+      case lwy
+      when Lawyer
+        lwy
+      when Hash
+        return nil if lwy.empty?
+
+        Lawyer.new(**lwy)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{lwy.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_lawyers(lwys)
+      case lwys
+      when Lawyer
+        [lwys]
+      when Array
+        lwys.map { |l| init_lawyer(l) }.compact
+      when NilClass
+        []
+      else
+        msg = "cannot initialize lawyers with #{lwys.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_judge(jdg, field: 'judge')
+      case jdg
+      when Judge
+        jdg
+      when Hash
+        return nil if jdg.empty?
+        Judge.new(**jdg)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{jdg.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_court(crt, field: 'court')
+      case crt
+      when Court
+        crt
+      when Hash
+        return nil if crt.empty?
+        Court.new(**crt)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{crt.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_party(pty, field: 'party')
+      case pty
+      when Party
+        pty
+      when Hash
+        return nil if pty.empty?
+
+        Party.new(**pty)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{pty.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_parties(ptys)
+      case ptys
+      when Party, Hash
+        ptys.map { |p| init_party(p) }.compact
+      when Array
+        ptys.map { |p| init_party(p) }.compact
+      when NilClass
+        []
+      else
+        msg = "cannot initialize parties with #{ptys.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+
+    def init_case(cs, field: 'case')
+      case cs
+      when Case
+        cs
+      when Hash
+        return nil if cs.empty?
+        Case.new(**cs)
+      when NilClass
+        nil
+      else
+        msg = "cannot initialize #{field} with #{cs.class.name}"
+        raise ArgumentError, msg
+      end
+    end
+  end
+end

data/lib/law_doc/judge.rb

@@ -0,0 +1,28 @@
+module LawDoc
+  class Judge < Person
+    attr_reader :title
+    attr_accessor :initials
+
+    def initialize(initials: nil,
+                   title: 'Judge',
+                   **other)
+      other[:hon] = 'Hon.' if other[:hon].blank?
+      super(**other)
+      @initials =
+        if initials
+          initials
+        else
+          self.initials = +''
+          self.initials += first[0] if first
+          self.initials += middle[0] if middle
+          self.initials += last[0] if last
+        end
+      @title = title
+    end
+
+    def to_h
+      hh = super
+      hh.merge(initials: initials, title: title)
+    end
+  end
+end