galaxy 0.0.2

data/lib/galaxy/models/race.rb

@@ -0,0 +1,112 @@
+require 'galaxy/models/models'
+
+class Race < ActiveRecord::Base
+  #:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean. 
+  virtual
+  tableless :columns => [
+  [ :name, :string ], 
+  [ :drive, :float ], 
+  [ :weapons, :float ], 
+  [ :shields, :float ], 
+  [ :cargo, :float ], 
+  [ :pop, :float ], 
+  [ :ind, :float ], 
+  [ :num_planets, :integer ], 
+  [ :relation, :string ], 
+  [ :vote, :float ]
+  ]  
+  has_many_linked :products 
+  has_many_linked :planets
+  has_many_linked :fleets 
+  has_many_linked :routes 
+  has_many_linked :groups 
+  has_many_linked :bombings
+  has_many_linked :incoming_bombings, :class_name => 'Bombing', :foreign_key => 'victim_id'
+  
+  attr_accessor :order
+  
+  def kill
+    products.each {|m| m.kill}    
+    planets.each {|m| m.kill}    
+    fleets.each {|m| m.kill}    
+    routes.each {|m| m.kill}    
+    groups.each {|m| m.kill}    
+    bombings.each {|m| m.kill}    
+    incoming_bombings.each {|m| m.kill}  
+    super #puts "Warning: kill attempt failed for #{self}" unless 
+  end
+  
+  def initialize match, state
+    case match.size
+      when 10 then
+      super({:name=>match[0], :drive=>match[1].to_f, :weapons=>match[2].to_f, :shields=>match[3].to_f, :cargo=>match[4].to_f, 
+        :pop=>match[5], :ind=>match[6].to_f, :num_planets=>match[7].to_i, :relation=>match[8], :vote=>match[9].to_f})
+      when 0 then # All init data must be given in a state hash
+      super state 
+    end
+    add if self.class.dataset # Add instantiated model to dataset if it is defined
+    @order = Order.new self, 'zelikaka', state[:game], state[:turn] if your?
+  end
+  
+  def key; name end
+  
+  # Special collection accessors
+  def sciences; products.find_all {|p| p and p.science?} || [] end # TODO redefine find_all in HashArray? 
+  def ships; products.find_all {|p| p and p.ship?} || [] end 
+  alias designs ships
+  alias ship_types ships
+  
+  
+  def battle_groups ; groups.find_all {|g| g and g.from_battle?} || [] end
+  
+  # Boolean tests on Races
+  def rip? ; name.split("_")[-1] == 'RIP' end
+  
+  def enemy? ; relation == 'War' end
+  alias war? enemy?  
+  
+  def friend? ; not enemy? end
+  alias ally? friend?  
+  alias peace? friend?  
+  
+  def your? ; relation == '-' end # Redefining TODO or test if this is your other controlled Race (aka 3ombies)
+  
+  def <=>(other)
+    case other
+      when nil then 1
+      when Race then num_planets == other.num_planets ? key <=> other.key : num_planets <=> other.num_planets
+      when Product, Planet, Group, Bombing, Route, Fleet then - other <=> self 
+      when Integer then num_planets <=> other
+      when String then self <=> other.downcase.to_sym
+      when Symbol then 
+      return rip? ? 0 : 1 if other == :rip or other == :dead
+      return !rip? ? 0 : 1if other == :alive or other == :active
+      return enemy? ? 0 :1 if other == :enemy or other == :war 
+      return friend? ? 0 : 1 if other == :friend or other == :ally or other == :peace
+      return your? ? 0 : 1 if other == :your or other == :yours or other == :controlled or other == :my or other == :mine
+      return 0 if name.downcase.include? other.to_s
+      key <=> other.to_s
+    else raise ArgumentError, 'Comparison with a wrong type'
+    end
+  end
+end
+
+class Order
+  attr_accessor :race, :text
+  
+  def initialize( race, password, game, turn )
+    @race = race
+    @password = password
+    @game = game
+    @turn = turn
+    @text = "#order #@game #{@race.name}_#@password turn #@turn\n#end\n"
+  end
+  
+  def add_line line
+    @text[-6] = "\n" + line + "\n"
+  end
+  
+  def recalc_order
+    puts "Unable to recalculate: method under construction!"
+  end
+end

data/lib/galaxy/models/route.rb

@@ -0,0 +1,60 @@
+require 'galaxy/models/models'
+
+class Route < ActiveRecord::Base
+  virtual
+  tableless :columns => [
+  [ :cargo, :string ]
+  ]  
+  belongs_to :race 
+  belongs_to :planet
+  belongs_to :target, :class_name => "Planet"
+  
+  def initialize match, state # match is not really used, remains for consistency with other models
+    
+    return if match.join == 'N$MCE' # Skip header
+    match[1..4].each_with_index do |m,i|
+      if m != '-'
+        super :cargo => ['cap', 'mat', 'col', 'empty'][i]
+        self.target = Planet.new_or_update [m], state.merge({:race=>nil,:product=>nil,:created_by=>self}) unless self.target = Planet.lookup(m)
+      end
+    end
+    planet = Planet.new_or_update [match[0]], state.merge({:race=>nil,:product=>nil,:created_by=>self}) unless planet = Planet.lookup(match[0])
+    race = Race.lookup(state[:owner])
+    
+    race.routes << self
+    planet.routes << self
+    target.incoming_routes << self
+    add if self.class.dataset # Add instantiated model to dataset if it is defined
+  end
+  
+  def kill
+    if result = super
+      race.routes.delete self if race
+      planet.routes.delete self if planet and planet == self
+      target.incoming_routes.delete self if target and target == self
+      self.planet = nil
+      self.target = nil
+    end
+    result
+  end
+  
+  def key ; [planet.num, target.num, cargo].join('.') end
+  
+  def <=>(other)
+    case other
+      when nil then 1
+      when Route then key <=> other.key
+      when Race then race <=> other
+      when Planet then planet == other ? 0 : target <=> other
+      when Integer, Float then planet.distance(target) <=> other
+      when String then self <=> other.downcase.to_sym
+      when Symbol then 
+      return 0 if race == other
+      return 0 if planet == other
+      return 0 if target == other
+      return 0 if cargo.downcase.include? other.to_s
+      key.downcase <=> other.to_s
+    else raise ArgumentError, 'Comparison with a wrong type'
+    end
+  end
+end #Route

data/lib/galaxy/order.rb

@@ -0,0 +1,24 @@
+#	A <race> - declare peace
+#	B <Num> [amount] - break group, also for fleets
+#	D <Name><drive><ammo><weap><defence><crg> - design a ship
+#	D <Name> - delete a ship
+#	G <Num><Race>[amount] - gift a group
+#	H <Name><D><W><S><C> - design a science
+#	H <Name> - delete a science
+#	J <Num><Fleet>[amount] - join group Num to Fleet
+#	J <Fleet1><Fleet2> - join F1 to F2
+#	K <Num><amount> - take group to pieces
+#	L <Num><CargoType>[ShipAmount,[CargoAmount]] - load group
+#	N <Planet><NewName> - rename a planet
+#	O - options
+#	P <Planet><Prod> - set production type
+#	Q <GameName><Race><Pass> - quit after 3 turns
+#	R <Src><CargoType>[Dst] - route
+#	S <Num><Dst>[Amount] - send a group
+#	S <Fleet><Dst> - send a fleet
+#	T <TypeName><NewName> - rename type
+#	U <Num>[ShipAmount[CargoAmount]] - unload group
+#	V <Race> - vote
+#	W <Race> - declare war
+#	X <Num><Tech>[ShipAmount[MaxTech]] - upgrade group
+#	Z [parameters] - order a report

data/lib/galaxy/report.rb

@@ -0,0 +1,176 @@
+#TAG report.rb tasks are on
+require 'galaxy/section.rb'
+
+# Module Gamedata provides G+ game-related data elements and collections 
+# and defines basic accessors to them for any Class including this module
+module Gamedata
+  require 'galaxy/utils.rb'
+  require 'galaxy/models/models.rb'
+  
+  attr_accessor :order  # Order (Object?) associated with this report
+  attr_accessor :owner  # Report owner race
+  attr_accessor :game   # Report game name
+  attr_accessor :turn   # Report turn number
+  attr_accessor :time   # Report time (from server)
+  attr_accessor :server # Report server version (string)
+  
+  # Establish Data Collections 
+  attr_accessor :races # Races in Report
+  attr_accessor :products # Sciences in Report
+  attr_accessor :bombings # Bombings in Report
+  attr_accessor :planets # Planets in Report
+  attr_accessor :routes # Routes in Report
+  attr_accessor :fleets # Fleets in Report
+  attr_accessor :groups # Groups in Report
+  attr_accessor :battles #FIXME Add Battles (based on Battle Protocols) later
+  
+  def initialize *args
+    # When object of any including Class is instantiated (and calling super),
+    # modify ActiveRecord:Base and point @@dataset attribute to this object
+    ActiveRecord::Base.establish_dataset(self)
+    
+    # Initialize G+ collections
+    @races = HashArray.new
+    @bombings = HashArray.new 
+    @planets = HashArray.new 
+    @routes = HashArray.new 
+    @fleets = HashArray.new 
+    @groups = HashArray.new 
+    @products = HashArray.new
+    
+    # Generate Products that are present in each G+ report by default
+    @products['Drive_Research'] = Product.new [], {:name=>'Drive', :prod_type=>'research'}
+    @products['Weapons_Research'] = Product.new [], {:name=>'Weapons', :prod_type=>'research'}
+    @products['Shields_Research'] = Product.new [], {:name=>'Shields', :prod_type=>'research'}
+    @products['Cargo_Research'] = Product.new [], {:name=>'Cargo', :prod_type=>'research'}
+    @products['Capital'] = Product.new [], {:name=>'Capital', :prod_type=>'cap'}
+    @products['Materials'] = Product.new [], {:name=>'Materials', :prod_type=>'mat'}
+    
+    super *args
+  end
+  
+  def sciences 
+    @products.find_all {|p| p and p.race and p.science?} || [] #redefine find_all in HashArray?
+  end
+  
+  def ships 
+    @products.find_all {|p| p and p.race and p.ship?} || [] #redefine find_all in HashArray?
+  end
+  alias designs ships
+  
+  def battle_groups
+    @groups.find_all {|g| g and g.from_battle?} || []
+  end
+  
+  def incoming_groups
+    @groups.find_all {|g| g and g.incoming?} || []
+  end
+  
+  def your_groups
+    @groups.find_all {|g| g and g.your?} || []
+  end
+  
+  def your_active_groups
+    @groups.find_all {|g| g and g.your_active?} || []
+  end
+  
+  def unidentified_groups
+    @groups.find_all {|g| g and g.unidentified?} || []
+  end
+  alias unknown_groups unidentified_groups 
+  
+  def your_planets
+    @planets.find_all {|p| p and p.your?} || []
+  end
+  
+  def uninhabited_planets
+    @planets.find_all {|p| p and p.uninhabited? } || []
+  end
+  
+  def unidentified_planets
+    @planets.find_all {|p| p and p.unidentified? } || []
+  end
+  alias unknown_planets unidentified_planets 
+end
+
+# Describes Galaxy Plus Report (as received from server) data structures and provides
+# 'parse' method for extracting data it.
+# Initially, Report "contains" extracted data (through included module Gamedata), 
+# but later on these data containers should be moved to new Game class
+class Report < Section
+  include Gamedata
+  
+  # Describes G+ Report data structure, opens report file if given a valid file name
+  def initialize (*args)
+    
+    # Define Proc for Report Header processing TODO 
+    report_proc = lambda do |match, state|
+      @owner = state[:owner] = match[1]
+      @game = state[:game] = match[2]
+      @turn = state[:turn] = match[3].to_i
+      @time = state[:time] = match[4]
+      @server = state[:server] = match[5]
+    end
+    
+    # Define G+ Report Sections
+    @sections = [ 
+    :races,
+    {:name=>:science_products, :mult=>true}, 
+    {:name=>:ship_products, :mult=>true}, 
+    {:name=>:battle_planets, :footer => 'Battle Protocol', 
+      :sections => [Section.new(:name=>:battle_groups, :mult=>true)], :mult=>true },
+    :bombings, 
+    {:header => 'Maps_header', :skip=>true},
+    :incoming_groups,
+    :your_planets,
+    :production_planets, 
+    :routes,
+    {:name=>:planets, :mult=>true},
+    :uninhabited_planets,
+    :unidentified_planets,
+    :fleets,
+    :your_groups,
+    {:name=>:groups, :mult=>true},  
+    :unidentified_groups
+    ].map do |init| Section.new init end
+    
+    # Initialize main Section and data Collections (from module Gamedata)
+    super :name=>:reports, :header_proc=>report_proc, :sections => @sections
+    
+    # Checking arguments
+    case args.size 
+      when 0 then # Do nothing
+      when 1 then open *args
+    else  # Wrong number of arguments, initializer failed
+      puts "Usage: Report.new or Report.new(file_name)"
+      raise ArgumentError, "Wrong number of arguments in Report initialization"
+    end
+  end
+  
+  # Validates file name and reads everything from file into Report's @text property
+  def open file_name
+    if file_name =~ /\A[[:punct:]\w\d]+.rep\z/ and File.exists? file_name
+      # This is a valid and existing rep file name
+    elsif file_name += '.rep' and file_name =~ /\A[[:punct:]\w\d]+.rep\z/ and File.exists? file_name
+      # This is a valid and existing rep file (without rep suffix)
+    else
+      raise ArgumentError, "Can't open: Invalid Report file #{file_name}"
+    end
+    # puts "Initializing Report from rep file: " + file_name
+    # Open file and pass file stream into block to read from it into Report's @text property
+    # File closing is automatic upon execution of the block
+    File.open(file_name, "r") do |f| @text = f.read end 
+  end
+  
+  # Method returns status string of the Report
+  def status
+    return "
+Report: #@owner #@game #@turn #@time #@server 
+Races: #{@races.size} Sciences: #{sciences.size} Types: #{designs.size} BattleGroups: #{battle_groups.size} \
+Bombings: #{@bombings.size} Incomings: #{incoming_groups.size} Your Planets: #{your_planets.size} \
+Ships in Production: #{@productions} Routes: #{@routes.size}
+Planets: #{@planets.size} Uninhabited Planets: #{uninhabited_planets.size} Unidentified Planets: #{unidentified_planets.size} \
+Fleets: #{@fleets.size} Your Groups: #{your_groups.size} Groups: #{@groups.size} Unidentified Groups: #{unidentified_groups.size}"  
+  end
+  
+end #class Report

data/lib/galaxy/section.rb

@@ -0,0 +1,226 @@
+#TAG section.rb tasks are on 
+#require 'oniguruma'
+
+# Regexen module provides pattern Constants that are used by Sections to describe its data structure
+module Regexen
+  #Defining basic regex patterns...
+  Name = '([[:punct:]\w]+)'
+  Sname = ' +?' + Name
+  Fname = '^ *?' + Name        #first Name in line (may be preceded by spaces, or not)
+  Num = '(\d+(?:\.\d+)?)(?=\s)'
+  Snum = ' +?' + Num
+  Fnum = '^ *?' + Num
+  Int = '(\d+)'
+  Sint = ' +?' + Int
+  Fint = '^ *?' + Int          #first int in line (may be preceded by spaces, or not)
+  Line = '([[:punct:]\w ]+)'
+  Scargo = ' +?(COL|CAP|MAT|-)'
+  Sstatus = ' +?(War|Peace|-|In_Battle|Out_Battle|In_Space|In_Orbit|Upgrade|Launched|Transfer_Status|Damaged|Wiped)' #may need further refining for productivity
+  Group = Sname + Snum * 4 + Scargo + Snum #Different from actual Groups?! Have to check...
+  Header = '\n\n\s*?([PIRVNDAWSCM#TQLOXY$EGF]\s+?)' 
+  
+  #Defining section header/footer patterns
+  Reports_header = Name + ' Report for Galaxy PLUS' + Sname + ' Turn' + Sint + ' ' + Line + '$\s*' + Line 
+  #+    '$$\s*Size:' + Snum + '\s*Planets:' + Snum + '\s*Players:'+ Snum
+  Races_header =  '^\s*?Status of Players .+?' + Snum + ' votes\)' + Header
+  Science_products_header =  '^\s*?' + Name + ' Sciences' + Header
+  Ship_products_header =  '^\s*?' + Name + ' Ship Types' + Header
+  Battle_planets_header =  '^\s*?Battle at \(#' + Int + '\) ' + Name
+  Bombings_header =  '^\s*?Bombings' + Header
+  Maps_header = '^\s*Map around'
+  Incoming_groups_header =  '^\s*?(Incoming) Groups' + Header
+  Your_planets_header =  '^\s*?(Your) Planets' + Header
+  Planets_header =  '^\s*?' + Name + ' Planets' + Header
+  Production_planets_header = '^\s*?Ships In Production' + Header
+  Routes_header = '^\s*?(Your) Routes' + Header
+  Uninhabited_planets_header =  '^\s*?(Uninhabited) Planets' + Header
+  Unidentified_planets_header =  '^\s*?(Unidentified) Planets' + Header
+  Fleets_header = '^\s*?(Your) Fleets' + Header
+  Your_groups_header = '^\s*?(Your) Groups' + Header
+  Groups_header = '^\s*?' + Name + ' Groups(?<!Your Groups)(?<!Unidentified Groups)\s+?' #' Groups(?<!Your Groups)(?<!Unidentified Groups)\s+?' + Header
+  Battle_groups_header = Groups_header
+  Unidentified_groups_header = '^\s*(Unidentified) Groups' + Header
+  Default_footer ='(\n\n)|(\z)'
+  
+  #Defining data record patterns
+  Races_record =  Fname + Snum * 7 + Sstatus + Snum
+  Science_products_record =  Fname + Snum * 4
+  Ship_products_record =  Fname + Snum * 6
+  #Battles_line = '^' + Line + '(fires on)' + Line + '($)'
+  Battle_planets_record = Battle_planets_header
+  Battle_groups_record = Fint + Group + Sint + Sstatus
+  Bombings_record = Fname + Sname + Sint + Sname + Snum * 2 + Sname + Snum * 4 + Sstatus
+  Incoming_groups_record = Fname + Sname + Snum * 3
+  Unidentified_planets_record = Fint + Snum * 2
+  Uninhabited_planets_record = Unidentified_planets_record + Sname + Snum * 4 
+  Planets_record = Uninhabited_planets_record + Sname + Snum * 4
+  Your_planets_record = Planets_record
+  Production_planets_record = Fint + Sname * 2 + Snum * 3
+  Routes_record = Fname + Sname * 4         #Attention! routes_record captures column headers line
+  Fleets_record = Fint + Sname + Sint + Sname * 2 + Snum * 2 + Sstatus
+  Your_groups_record = Fint + Sint + Group + Sname * 2 + Snum * 3 + Sname + Sstatus 
+  Groups_record = Fint + Group + Sname + Snum * 2
+  Unidentified_groups_record = Fnum + Snum
+  # FIXME Broadcasts not defined
+  
+  #Defining data processing Procs
+  Default_header_proc = lambda do |match, state| 
+    state[:race] = match[1] == 'Your' ? Race.lookup(state[:owner]) : Race.lookup(match[1]) if match[1]
+  end
+end
+
+# Section is a piece of text that contains data structured in a certain way (possibly with sub-sections),
+# Section describes this data structure and provides methods for parsing the text and extracting data records
+# By default, Section calls new_or_update method on class defined by Section name
+# Example: Section(:name=>:battle_groups) calls Group.new_or_update(match, state) on each found /Battle_group_record/ match
+# by default, unless :record_proc is provided to Section
+# 'state' hash is used to provide context for multi-section parsing
+class Section
+  include Regexen
+  
+  attr_accessor :name       # Name of this Section (also used to auto-generate properties)
+  attr_accessor :text       # Source text of this Section (raw material for data extraction)
+  attr_accessor :header     # Regex identifying start of this Section (obligatory!)
+  attr_accessor :footer     # Regex identifying end of this Section (end of EACH Multisections)
+  attr_accessor :record     # Regex matching data Record (or an array of such regexen)
+  attr_accessor :header_proc # Proc object to be run on Header match
+  attr_accessor :footer_proc # Proc object to be run on Footer match
+  attr_accessor :record_proc # Proc object to be run on each Record match (or an array of Procs) 
+  attr_accessor :sections   # (Sub)sections (possibly) contained inside this Section 
+  attr_accessor :skip       # Flag indicating that this Sections contains no data (should be skipped) 
+  attr_accessor :mult       # Flag indicating that this is a "Multisection" (several Sections with similar headers one after another) 
+  
+  # New Section is created by using the following syntax:
+  #  Section.new {:header => header, :footer => footer, :record =>[rec1,rec2], :sections => [sec1,sec2,sec3]}
+  #  Section.new {:name => name}  -> extracted as {:header => Name_header, :footer => Name_footer, :record =>Name_record }
+  #  Section.new :symbol  -> extracted as {:header => Symbol_header, :footer => Symbol_footer, :record =>Symbol_record }
+  def initialize args
+    case args       # Parsing (named) arguments
+      when Symbol, String # Symbol represents Section name, appropriately named Constants MUST be defined in Regexen module
+      @name = args.to_s.downcase.capitalize
+      when Hash
+      @name = args[:name].to_s.downcase.capitalize if args[:name]
+      @text = args[:text]
+      @skip = args[:skip]
+      @mult = args[:mult]
+      @sections = args[:sections]
+      
+      # Header/footer/record patterns and appropriate processing Procs can be: 
+      # 1) given as a Constant name (should be defined in Regexen module), 
+      # 2) given as a direct value (escaped pattern string literal or Proc, respectively), or
+      # 3) not given at all, appropriate values should be inferred from :name argument 
+      @header = Regexen.const_get(args[:header]) rescue args[:header]
+      @footer = Regexen.const_get(args[:footer]) rescue args[:footer]
+      @record = Regexen.const_get(args[:record]) rescue args[:record]
+      @header_proc = Regexen.const_get(args[:header_proc]) rescue args[:header_proc]
+      @footer_proc = Regexen.const_get(args[:footer_proc]) rescue args[:footer_proc]
+      @record_proc = Regexen.const_get(args[:record_proc]) rescue args[:record_proc]
+    end #case  
+    
+    # Try to auto-generate Section's Patterns and Procs from @name (if they are not already given)
+    # First we try to find Regexen constants derived from name, if not found then we look for defaults
+    @header = @header || Regexen.const_get(@name + '_header') rescue 
+    if Regexen.const_defined?('Default_header') then Regexen.const_get('Default_header') end
+    @footer = @footer || Regexen.const_get(@name + '_footer') rescue 
+    if Regexen.const_defined?('Default_footer') then Regexen.const_get('Default_footer') end  
+    @record = @record || Regexen.const_get(@name + '_record') rescue 
+    if Regexen.const_defined?('Default_record') then Regexen.const_get('Default_record') end
+    @header_proc = @header_proc || Regexen.const_get(@name + '_header_proc') rescue 
+    if Regexen.const_defined?('Default_header_proc') then Regexen.const_get('Default_header_proc') end
+    @footer_proc = @footer_proc || Regexen.const_get(@name + '_footer_proc') rescue 
+    if Regexen.const_defined?('Default_footer_proc') then Regexen.const_get('Default_footer_proc') end  
+    @record_proc = @record_proc || Regexen.const_get(@name + '_record_proc') rescue 
+    if Regexen.const_defined?('Default_record_proc') then Regexen.const_get('Default_record_proc') end
+    
+    # This is a G+ specific piece of code overriding general Section functionality (Default_record_proc)
+    # Needed to speed up calculations and avoid class evaluations on each record
+    # Class name of the Object (described by Record), e.g "Group"
+    if @name and not @record_proc 
+      klass_name = @name.split("_")[-1][0..-2].capitalize
+      if Object.const_defined?(klass_name) 
+        klass = Object.const_get(klass_name) 
+        @record_proc ||= lambda do |match, state| 
+          klass.new_or_update match[1..-1], state
+        end 
+      end 
+    end
+  end #initialize
+  
+  # Returns (relatively) deep copy of self
+  def copy
+    secs = @sections ? @sections.map {|s| s.copy} : nil
+    Section.new :name=>@name, :header=>@header, :footer=>@footer, :record=>@record, :header_proc=>@header_proc, 
+    :footer_proc=>@footer_proc, :record_proc=>@record_proc, :sections=>secs, :skip=>@skip, :mult=>@mult, :text=>@text
+  end
+  
+  # Recursively parse Section, extract data records
+  def parse state={}
+    state[:section] = @name
+    if @mult
+      #puts "Mults: #{self.name} #{self.header}"
+      # Multisection: Find out if this Section is actually a collection of sections with similar headers
+      # If it is, clone an Array of multisections and call parse on each (data extraction happens downstream)
+      scan_text(@header) do |match|
+        start = match.begin
+        finish = -1 unless finish = find_text(@footer, match.end) # Find end of Section (after Header END)
+        s = self.copy # Create a copy of Section (to be used as child multisection template)
+        s.mult = false
+        s.text = @text[start..finish] # Set text property for found multisection
+        s.parse state # Recursively call parse on each found multisection
+      end
+    else
+      # Process Section Header, Records and Footer (if any)
+      find_text(@header) {|match| @header_proc.call match, state} if @header and @header_proc
+      scan_text(@record) {|match| @record_proc.call match, state} if @record and @record_proc
+      find_text(@footer) {|match| @footer_proc.call match, state} if @footer and @footer_proc
+      
+      if @sections
+        #puts "Sections: #{self.name} #{self.header}"
+        # Process Sections array against @text, skipping empty/skippable Sections, recursively 
+        # calling parse on found Sections and moving forward position cursor pos 
+        # TODO Generalize for UNORDERED Sections (position cursor should not work in this case)
+        finish = 0
+        @sections.each_with_index do |s, i|
+          next if s.skip #Skip non-data Section
+          if start = find_text(s.header, finish)  # Find Section Header
+            finish = nil # Needed for last Section (no next section to find)
+            @sections[i+1..-1].each do |sn| # Find finish by cycling through next Section Headers
+              break if finish = find_text(sn.header, start) # Find first of next Section Header 
+            end 
+            finish = -1 unless finish # If finish not found, set it to the end of @text
+            #Start and finish defined, assign text to this Section and recursively parse it
+            s.text = @text[start..finish]
+            s.parse state 
+          end 
+        end 
+      end 
+    end   
+  end #parse
+  
+  # Safely matches given regex to @text (starting at position pos),
+  # returns initial offset of match or nil if regex not found, yield match to given block (if any)
+  def find_text regex, pos=0
+    return nil if @text == nil
+    return nil if regex == nil
+    text = pos == 0 ? @text : @text[pos..-1]
+    match = Oniguruma::ORegexp.new(regex).match(text)
+    return nil unless match 
+    yield match if block_given?
+    pos + match.begin # Return initial match offset (corrected for position pos)
+  end #find_text
+  
+  # Scans @text for Data Records matching given regex pattern, returns array of matching Data Records 
+  # (as MatchData or String array), yields each found match object to given block (if any)
+  def scan_text regex, pos=0
+    text = pos == 0 ? @text : @text[pos..-1]
+    if block_given?
+      # Scan Section for regex matches, yield each match to given block, return array of MATCH objects
+      Oniguruma::ORegexp.new(regex).scan(text) {|match| yield match }
+    else
+      # Scan Section for regex matches, return array of matches converted into string arrays
+      results=[]
+      Oniguruma::ORegexp.new(regex).scan(text) {|match| results << match[1..-1].to_a }
+      results
+    end
+  end #scan_text
+end #class Section