law_doc 0.1.15

data/lib/law_doc/lawyer.rb

@@ -0,0 +1,111 @@
+module LawDoc
+  class Lawyer < Person
+    attr_reader :firm, :bar_numbers
+
+    def initialize(bar_numbers: {},
+                   firm: nil,
+                   **other)
+      super(**other)
+      @firm = init_person(firm, field: 'firm')
+      @bar_numbers = {}
+      bar_numbers.each_pair do |st, num|
+        @bar_numbers[st.to_s.upcase] = num.to_s
+      end
+    end
+
+    def to_h
+      hh = super
+      hh.merge(firm: firm.to_h, bar_numbers: bar_numbers)
+    end
+
+    # Return a LaTeX information block for the lawyer, either abbreviated,
+    # when full is false, or comprehensive, when full is true.  This
+    # information is independent of the Lawyer's role in a given case, so
+    # things such a bar number and capacity are not part of the description.
+    # Compare to tex_block below.
+    def tex_info(sep = ' ', full: false)
+      components = []
+      components << name.tq.to_s unless name.blank?
+      if full
+        components << "\\textsc{#{firm.name.tq}}" unless firm&.name.blank?
+        if address
+          components << address.tex_info(sep)
+        elsif firm
+          components << firm.address.tex_info(sep) if firm.address
+        end
+        components << "\\textbf{Phone:} #{phone.tq}" unless phone.blank?
+        components << "\\textbf{Fax:} #{fax.tq}" unless fax.blank?
+        components << "\\textbf{Email:} \\texttt{#{email.tq}}" unless email.blank?
+      end
+      components.join_nonblank(sep)
+    end
+
+    # Return a LaTeX information block for the lawyer in the context of his
+    # role in a case, either abbreviated, when full is false, or
+    # comprehensive, when full is true.  Information about the lawyers role in
+    # a case is supplied by the parameters bar_state and capacity. Compare to
+    # tex_info above.
+    def tex_block(capacity: nil, bar_state: nil, full: false)
+      result = tex_info("\\\\\n", full: full)
+      unless bar_state.nil?
+        key = bar_state.to_s.upcase
+        if bar_numbers.key?(key)
+          # A bar number of "N/A", "NA", "n/a", etc., means the state has no bar numbers,
+          # and don't include it in the block.
+          unless bar_numbers[key] =~ %r{n/?a}i
+            result += "\\\\\n\\textbf{Bar:}~#{bar_numbers[key].tq}"
+          end
+        else
+          result += "\\\\\n\\textbf{Bar:}~Pro Hac Motion to be Filed"
+        end
+      end
+      result += "\\\\\n~~\\textit{#{capacity.tq}}" if capacity
+      result
+    end
+
+    # Return a \plainsigblock macro for a signature block for this person
+    # using the person's signature to sign if sig is either 'sign' (for a
+    # graphic signature) or 'esign' for a /s/-style signature.  Information
+    # about the Lawyer's role in a case, if any, is supplied by optional
+    # parameters: capacity (e.g., 'Attorney for Jones'), bar_state (e.g. 'NY')
+    # to act as a key for which bar_number to chose.  The signature block can
+    # contain all the Lawyer's contact information, or just name, bar number,
+    # and capacity, depending on whether the full parameter is true.
+    def tex_plainsigblock(sig: nil, bar_state: nil, capacity: nil, full: false)
+      # label_part = firm ? "\\textsc{#{firm.name.tq}}" : ''
+      # by_part = firm ? 'By:~' : ''
+      below_part = tex_block(capacity: capacity, bar_state: bar_state, full: full)
+      "\\plainsigblock{}{}{#{sig}}{#{below_part}}"
+    end
+
+    # Like tex_plainsigblock, but can also take a date and returns the
+    # \sigblock macro, which spans the entire width of the page, so is only
+    # suitable for a single signer or vertically stacked signatures.  Also
+    # adds a date and date_format parameters for placing a date to the left of
+    # the signature using the strftime format given in date_format.  We
+    # formerly used the firm name, if any, to place above the signature and an
+    # "By" designator, but have eliminated those since a lawyer in a case
+    # never signs for the firm, but for himself.
+    def tex_sigblock(sig: nil, bar_state: nil, capacity: nil,
+                     date: nil, date_format: nil,
+                     full: false)
+      date_part =
+        if date
+          date = init_date(date) if date
+          if date_format
+            "Date: #{date.strftime(date_format).tq}"
+          else
+            "Date: #{date.iso}"
+          end
+        end
+      # label_part = firm ? "\\textsc{#{firm.name.tq}}" : ''
+      # by_part = firm ? 'By:~' : ''
+      below_part = tex_block(capacity: capacity, bar_state: bar_state, full: full)
+      if date
+        "\\sigblock[#{date_part}]{}{}{#{sig}}{#{below_part}}"
+      else
+        "\\sigblock{}{}{#{sig}}{#{below_part}}"
+      end
+    end
+  end
+end

data/lib/law_doc/party.rb

@@ -0,0 +1,40 @@
+module LawDoc
+  class Party < Person
+    include InitTypes
+
+    attr_reader :role, :lawyers
+
+    def initialize(role: nil, lawyers: [], **other)
+      # Allow singular lawyer
+      if other.key?(:lawyer)
+        lawyers = other[:lawyer]
+        other.delete(:lawyer)
+      end
+      if other.key?(:person)
+        case other[:person]
+        when Person
+          person_params = other[:person].to_h
+          other.delete(:person)
+          super(**other.merge(person_params))
+        when Hash
+          person_params = other[:person]
+          other.delete(:person)
+          super(**other.merge(person_params))
+        end
+      else
+        super(**other)
+      end
+      @role = role
+      raise UserError, "party #{name} must be given a role" if role.blank?
+
+      @lawyers = init_lawyers(lawyers)
+    end
+
+    def to_h
+      result = super
+      result[:role] = role
+      result[:lawyers] = lawyers
+      result
+    end
+  end
+end

data/lib/law_doc/person.rb

@@ -0,0 +1,291 @@
+module LawDoc
+  class Person
+    attr_reader :sex, :hon, :first, :middle, :last,
+                :suffix, :title, :sig, :esig, :address,
+                :email, :dob
+
+    include InitTypes
+
+    def initialize(sex: 'entity', hon: nil, first: nil, last: nil,
+                   middle: nil, suffix: nil, title: nil, sig: nil,
+                   esig: nil, name: nil, dob: nil, address: nil,
+                   phone: nil, fax: nil, email: nil)
+      @sex = sex.to_s.clean.downcase
+      @sex =
+        case @sex
+        when /^m/i
+          'male'
+        when /^f/i
+          'female'
+        else
+          'entity'
+        end
+      msg = "invalid sex: '#{@sex}'"
+      raise ArgumentError, msg unless %w[entity male female].include?(@sex)
+
+      @hon = hon
+      @first = first
+      @middle = middle
+      @last = last
+      @suffix = suffix
+      @name = name
+      parse_name
+      @title = title
+      @sig = sig
+      @esig = esig || (@sex == 'entity' ? nil : "/s/ #{@name}")
+      @dob = init_date(dob, field: 'dob')
+      @address = init_address(address)
+      @phone = init_phone(phone)
+      @fax = init_phone(fax, field: 'fax')
+      @email = email
+    end
+
+    # This is here only to test alternative constructors in the ydl gem.
+    def self.from_hash(hsh)
+      new(**hsh)
+    end
+
+    def phone
+      @phone.to_s
+    end
+
+    def fax
+      @fax.to_s
+    end
+
+    def entity?
+      @sex == 'entity'
+    end
+
+    # Set name components from what the user has supplied.
+    def parse_name
+      if entity?
+        if @name
+          @hon = @first = @middle = @last = @suffix = nil
+        elsif @first || @middle || @last
+          @name = [@first, @middle, @last].compact.join(' ')
+          @hon = @first = @middle = @last = @suffix = nil
+        else
+          msg = 'entity must have name'
+          raise ArgumentError, msg
+        end
+      elsif @name && @last.nil?
+        names = @name.split
+        case names.size
+        when 5
+          @hon, @first, @middle, @last, @suffix = names
+        when 4
+          @first, @middle, @last, @suffix = names
+        when 3
+          @first, @middle, @last = names
+        when 2
+          @first, @last = names
+        else
+          @last = @name
+        end
+      elsif @first && @last
+        @name =
+          [@first, @middle, @last, @suffix].compact.join(' ')
+      else
+        msg = "cannot parse person's name"
+        raise ArgumentError, msg
+      end
+      @hon = 'Mr.' if @hon.nil? && @sex == 'male'
+      @hon = 'Ms.' if @hon.nil? && @sex == 'female'
+    end
+
+    def to_h
+      if entity?
+        {
+          sex: sex, name: name, address: address.to_h, phone: @phone.to_h,
+          fax: @fax.to_h, email: email
+        }
+      else
+        {
+          sex: sex, hon: hon, first: first, last: last, middle: middle,
+          address: address.to_h, phone: @phone.to_h,
+          fax: @fax.to_h, email: email
+        }
+      end
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_h <=> other.to_h
+    end
+
+    def name
+      if entity?
+        @name
+      else
+        [@first, @middle, @last, @suffix].join_nonblank(' ')
+      end
+    end
+
+    def age(on = Date.today)
+      on = init_date(on, field: 'on')
+      return nil if on < dob
+
+      birthday_this_year = Date.new(on.year, dob.month, dob.day)
+      if on - dob <= 365.25
+        # Only babies get a fractional age
+        ((on - dob) / 365.25).round(2)
+      elsif on >= birthday_this_year
+        on.year - dob.year
+      else
+        on.year - dob.year - 1
+      end
+    end
+
+    # Return a TeX string with components separated by sep.
+    def tex_info(sep = ' ')
+      if address
+        "\\textsc{#{name.tq}}" + sep + address.tex_info(sep)
+      else
+        "\\textsc{#{name.tq}}"
+      end
+    end
+
+    # Return a multi-line TeX string
+    def tex_block
+      tex_info("\\\\\n")
+    end
+
+    # Return an in-line TeX string
+    def tex_inline
+      if address
+        "\\textsc{#{name.tq}}, #{address.tex_inline}"
+      else
+        "\\textsc{#{name.tq}}"
+      end
+    end
+    alias to_s tex_inline
+
+    # Return a \plainsigblock macro for a signature block for this person
+    # using the person's signature to sign if sig is either 'sign' (for a
+    # graphic signature) or 'esign' for a /s/-style signature.  Have signature
+    # by another if agent: is set to a person.  If an agent is provided, set
+    # the capacity in which the agent signs with the agent_capacity:
+    # parameter.
+    def tex_sigblock(sig: nil, label: nil,
+                     date: nil, date_format: nil,
+                     below: nil,
+                     agent: nil, capacity: nil)
+      date = init_date(date) if date
+      agent = init_person(agent, field: 'agent')
+      label_part =
+        if label
+          label.tq.to_s
+        elsif entity?
+          "\\textsc{#{name.tq}}"
+        elsif agent
+          name.tq
+        else
+          ''
+        end
+      by_part = agent || entity? ? 'By:~' : ''
+      date_part =
+        if date
+          if date_format
+            "Date: #{date.strftime(date_format)}"
+          else
+            "Date: #{date.iso}"
+          end
+        end
+      below_part =
+        if below
+          below.to_s
+        elsif agent
+          agent.name.tq + (capacity ? ", #{capacity.tq}" : '')
+        elsif !entity?
+          name.tq + (capacity ? ", #{capacity.tq}" : '')
+        else
+          ''
+        end
+      if date
+        "\\sigblock[#{date_part}]{#{label_part}}{#{by_part}}{#{sig}}{#{below_part}}"
+      else
+        "\\sigblock{#{label_part}}{#{by_part}}{#{sig}}{#{below_part}}"
+      end
+    end
+
+    # Return a \plainsigblock macro for a signature block for this person
+    # using the person's signature to sign if sig is either 'sign' (for a
+    # graphic signature) or 'esign' for a /s/-style signature.  Have signature
+    # by another if agent: is set to a person.  If an agent is provided, set
+    # the capacity in which the agent signs with the agent_capacity:
+    # parameter.
+    def tex_plainsigblock(sig: nil, label: nil, below: nil,
+                          agent: nil, capacity: nil)
+      agent = init_person(agent, field: 'agent')
+      label_part =
+        if label
+          label.tq.to_s
+        elsif entity?
+          "\\textsc{#{name.tq}}"
+        elsif agent
+          name.tq
+        else
+          ''
+        end
+      by_part = agent || entity? ? 'By:~' : ''
+      below_part =
+        if below
+          below.to_s
+        elsif agent
+          agent.name.tq + (capacity ? ", #{capacity}" : '')
+        elsif !entity?
+          name.tq + (capacity ? ", #{capacity}" : '')
+        else
+          ''
+        end
+      "\\plainsigblock{#{label_part}}{#{by_part}}{#{sig}}{#{below_part}}"
+    end
+
+    # Sex-dependent pronouns
+    def he_she_it
+      case sex
+      when 'male'
+        'he'
+      when 'female'
+        'she'
+      else
+        'it'
+      end
+    end
+
+    def him_her_it
+      case sex
+      when 'male'
+        'him'
+      when 'female'
+        'her'
+      else
+        'it'
+      end
+    end
+
+    def his_her_its
+      case sex
+      when 'male'
+        'his'
+      when 'female'
+        'her'
+      else
+        'its'
+      end
+    end
+
+    def his_hers_its
+      case sex
+      when 'male'
+        'his'
+      when 'female'
+        'hers'
+      else
+        'its'
+      end
+    end
+  end
+end

data/lib/law_doc/phone.rb

@@ -0,0 +1,62 @@
+module LawDoc
+  class PhoneParseError < ArgumentError; end
+
+  class Phone
+    cattr_accessor :default_area
+    self.default_area = '913'
+
+    attr_reader :area, :exchange, :station
+
+    def initialize(phn)
+      case phn
+      when String
+        case phn.to_s.gsub(/\D/, '')
+        when /^1?(\d{3})(\d{3})(\d{4})/
+          @area = $1
+          @exchange = $2
+          @station = $3
+        when /^1?(\d{3})(\d{4})/
+          @area = Phone.default_area
+          @exchange = $1
+          @station = $2
+        else
+          raise PhoneParseError, "cannot parse '#{phn}' as a valid phone number"
+        end
+      when Hash
+        if phn.empty?
+          nil
+        else
+          @area = phn[:area]
+          @exchange = phn[:exchange]
+          @station = phn[:station]
+        end
+      else
+        raise PhoneParseError, "cannot initialize phone with '#{phn.class}'"
+      end
+    end
+
+    def to_s(sep = '-')
+      return '' unless @area && @exchange && @station
+
+      [@area, @exchange, @station].join(sep.to_s)
+    end
+
+    def to_h
+      { area: area, exchange: exchange, station: station }
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_h <=> other.to_h
+    end
+
+    def tex_block
+      "(#{area.tq}) #{exchange.tq}-#{station.tq}"
+    end
+
+    def tex_line
+      tex_block
+    end
+  end
+end

data/lib/law_doc/version.rb

@@ -0,0 +1,3 @@
+module LawDoc
+  VERSION = '0.1.15'.freeze
+end

data/lib/law_doc.rb

@@ -0,0 +1,73 @@
+require 'fat_core/all'
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+
+require 'law_doc/version'
+require 'blankable_date'
+
+module LawDoc
+  require 'law_doc/core_ext'
+  require 'law_doc/error'
+  require 'law_doc/init_types'
+  require 'law_doc/address'
+  require 'law_doc/phone'
+  require 'law_doc/person'
+  require 'law_doc/judge'
+  require 'law_doc/court'
+  require 'law_doc/lawyer'
+  require 'law_doc/party'
+  require 'law_doc/case'
+  require 'law_doc/document'
+
+  class << self
+    attr_accessor :doc
+    attr_accessor :kase
+  end
+
+  # This method returns all the LaTeX macros implied by the Ydl files found on
+  # the file system.  It also makes the LawDoc::Document object available
+  # through LawDoc.doc and its kase through LawDoc.kase.  Thus, an ErbTeX
+  # document often starts with code like the following:
+  #
+  # {:=
+  # require 'law_doc'
+  #
+  # LawDoc.document(ydl: true) do
+  #   title 'Complaint Under 15 U.S.C. 78p(b)'
+  #   kase Ydl[:cases][:coty]
+  #   signers Ydl[:lawyers][:jhunter], Ydl[:lawyers][:tauber], Ydl[:lawyers][:ded]
+  #   on_behalf_of 'plaintiffs'
+  #   sig_date '2020-08-11'
+  #   server signer
+  #   service_date sig_date
+  # end
+  # :}
+
+  # To make access to the document and other objects easier, you can then do
+  # something like this:
+  #
+  # {:
+  # doc = LawDoc.doc
+  # laubies = Ydl[:persons][:laubies]
+  # coty = Ydl[:persons][:coty]
+  # :}
+  def self.document(ydl: false, &block)
+    if ydl
+      begin
+        require 'ydl'
+        Ydl.load
+      rescue LoadError
+        msg = <<~MSG
+        In order to use the ydl option, you must install the ydl gem:
+          try `gem install ydl`
+        MSG
+        raise UserError, msg
+      end
+    end
+    doc = LawDoc::Document.new
+    doc.instance_eval(&block)
+    LawDoc.doc = doc
+    LawDoc.kase = doc.kase
+    doc.tex_lawdoc_macros
+  end
+end