parsanol 3.0.0

data/example/iso-6709/basic.rb

@@ -0,0 +1,231 @@
+# ISO 6709 Geographic Coordinate Parser - Ruby Implementation
+#
+# Parse ISO 6709 geographic point locations (latitude, longitude, altitude).
+#
+# Run with: ruby example/iso-6709/basic.rb
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parsanol/parslet'
+
+# ISO 6709 coordinate parser
+class Iso6709Parser < Parsanol::Parser
+  root :coordinate
+
+  # Sign: + for N/E, - for S/W
+  rule(:lat_sign) { (str('+') | str('-')).as(:lat_sign) }
+  rule(:lon_sign) { (str('+') | str('-')).as(:lon_sign) }
+
+  # Decimal degrees: DD.DDDD or DDD.DDDD
+  rule(:decimal_deg) {
+    match('[0-9]').repeat(1, 2).as(:degrees) >>
+    (str('.') >> match('[0-9]').repeat(1)).maybe.as(:fraction)
+  }
+
+  rule(:decimal_deg_3) {
+    match('[0-9]').repeat(1, 3).as(:degrees) >>
+    (str('.') >> match('[0-9]').repeat(1)).maybe.as(:fraction)
+  }
+
+  # Sexagesimal (DMS): DD MM SS.ss or DD MM
+  rule(:sexagesimal) {
+    match('[0-9]').repeat(1, 2).as(:degrees) >>
+    (
+      space >>
+      match('[0-9]').repeat(1, 2).as(:minutes) >>
+      (
+        space >>
+        match('[0-9]').repeat(1, 2).as(:seconds) >>
+        (str('.') >> match('[0-9]').repeat(1)).maybe.as(:sec_fraction)
+      ).maybe
+    ).maybe
+  }
+
+  rule(:sexagesimal_3) {
+    match('[0-9]').repeat(1, 3).as(:degrees) >>
+    (
+      space >>
+      match('[0-9]').repeat(1, 2).as(:minutes) >>
+      (
+        space >>
+        match('[0-9]').repeat(1, 2).as(:seconds) >>
+        (str('.') >> match('[0-9]').repeat(1)).maybe.as(:sec_fraction)
+      ).maybe
+    ).maybe
+  }
+
+  # Latitude: -90 to +90
+  rule(:latitude) {
+    lat_sign >> (decimal_deg | sexagesimal).as(:latitude)
+  }
+
+  # Longitude: -180 to +180
+  rule(:longitude) {
+    lon_sign >> (decimal_deg_3 | sexagesimal_3).as(:longitude)
+  }
+
+  # Altitude (optional): +AAA.A or -AAA.A
+  rule(:altitude) {
+    (str('+') | str('-')).as(:alt_sign) >>
+    match('[0-9]').repeat(1).as(:alt_value) >>
+    (str('.') >> match('[0-9]').repeat(1)).maybe.as(:alt_fraction)
+  }
+
+  # Coordinate Reference System (optional): CRScode/
+  rule(:crs) {
+    str('CRS') >>
+    match('[A-Z0-9_]').repeat(1).as(:crs) >>
+    str('/')
+  }
+
+  # Complete coordinate
+  rule(:coordinate) {
+    latitude >>
+    (space | str('')).maybe >>
+    longitude >>
+    altitude.maybe.as(:altitude) >>
+    (str('/') >> crs).maybe.as(:crs_info)
+  }
+
+  rule(:space) { match('\s') }
+end
+
+# Coordinate result class
+Coordinate = Struct.new(:lat_sign, :latitude, :lon_sign, :longitude, :altitude, :crs) do
+  def to_h
+    {
+      latitude: lat_value,
+      longitude: lon_value,
+      altitude: alt_value,
+      crs: crs
+    }.compact
+  end
+
+  def lat_value
+    return nil unless latitude
+    val = degrees_to_decimal(latitude)
+    lat_sign == '-' ? -val : val
+  end
+
+  def lon_value
+    return nil unless longitude
+    val = degrees_to_decimal(longitude)
+    lon_sign == '-' ? -val : val
+  end
+
+  def alt_value
+    return nil unless altitude
+    val = altitude[:alt_value].to_f
+    val += altitude[:alt_fraction].to_s.to_f if altitude[:alt_fraction]
+    altitude[:alt_sign] == '-' ? -val : val
+  end
+
+  private
+
+  def degrees_to_decimal(d)
+    return 0.0 unless d
+
+    deg = d[:degrees].to_i
+    min = d[:minutes].to_s.to_i
+    sec = d[:seconds].to_s.to_f
+    sec += d[:sec_fraction].to_s.to_f if d[:sec_fraction]
+    frac = d[:fraction].to_s.to_f
+
+    deg + (min / 60.0) + (sec / 3600.0) + frac
+  end
+end
+
+# Transform parse tree to Coordinate
+class Iso6709Transform < Parsanol::Transform
+  rule(
+    lat_sign: simple(:ls),
+    latitude: simple(:lat),
+    lon_sign: simple(:lons),
+    longitude: simple(:lon)
+  ) {
+    Coordinate.new(ls.to_s, lat, lons.to_s, lon, nil, nil)
+  }
+
+  rule(
+    lat_sign: simple(:ls),
+    latitude: simple(:lat),
+    lon_sign: simple(:lons),
+    longitude: simple(:lon),
+    altitude: simple(:alt)
+  ) {
+    Coordinate.new(ls.to_s, lat, lons.to_s, lon, alt, nil)
+  }
+
+  rule(
+    lat_sign: simple(:ls),
+    latitude: simple(:lat),
+    lon_sign: simple(:lons),
+    longitude: simple(:lon),
+    crs_info: simple(:crs)
+  ) {
+    Coordinate.new(ls.to_s, lat, lons.to_s, lon, nil, crs.to_s)
+  }
+
+  rule(
+    lat_sign: simple(:ls),
+    latitude: simple(:lat),
+    lon_sign: simple(:lons),
+    longitude: simple(:lon),
+    altitude: simple(:alt),
+    crs_info: simple(:crs)
+  ) {
+    Coordinate.new(ls.to_s, lat, lons.to_s, lon, alt, crs.to_s)
+  }
+end
+
+# Parse and return Coordinate
+def parse_coordinate(str)
+  parser = Iso6709Parser.new
+  transform = Iso6709Transform.new
+
+  tree = parser.parse(str)
+  transform.apply(tree)
+rescue Parsanol::ParseError => e
+  puts "Parse error: #{e.message}"
+  nil
+end
+
+# Main demo
+if __FILE__ == $0
+  puts "ISO 6709 Geographic Coordinate Parser"
+  puts "=" * 50
+  puts
+
+  coordinates = [
+    "+40.6894-074.0447",                    # Statue of Liberty
+    "+48.8584+002.2945",                    # Eiffel Tower
+    "-90+000",                              # South Pole
+    "+27.9881+086.9250",                    # Mount Everest
+    "+40 41 21.84-074 02 40.92",           # Sexagesimal format
+    "+48.8584+002.2945+330CRSWGS_84/",     # With altitude and CRS
+  ]
+
+  coordinates.each do |coord_str|
+    puts "Input: #{coord_str}"
+    result = parse_coordinate(coord_str)
+    if result
+      puts "  Latitude:  #{result.lat_value}"
+      puts "  Longitude: #{result.lon_value}"
+      puts "  Altitude:  #{result.alt_value}" if result.alt_value
+      puts "  CRS:       #{result.crs}" if result.crs
+    end
+    puts
+  end
+
+  # Validation examples
+  puts "-" * 50
+  puts "Validation examples:"
+  puts
+
+  ["+95-074", "+40.6894"].each do |invalid|
+    puts "Invalid: #{invalid}"
+    result = parse_coordinate(invalid)
+    puts "  Result: #{result.inspect}"
+    puts
+  end
+end

data/example/iso-6709/basic.rb.md

@@ -0,0 +1,143 @@
+# ISO 6709 Geographic Coordinate Parser - Ruby Implementation
+
+## How to Run
+
+```bash
+cd parsanol-ruby/example/iso-6709
+ruby basic.rb
+```
+
+## Code Walkthrough
+
+### Sign Convention
+
+Latitude and longitude use signed notation:
+
+```ruby
+rule(:lat_sign) { (str('+') | str('-')).as(:lat_sign) }
+rule(:lon_sign) { (str('+') | str('-')).as(:lon_sign) }
+```
+
+Positive (+) means North/East; negative (-) means South/West.
+
+### Decimal Degrees
+
+Simple decimal format captures degrees and optional fraction:
+
+```ruby
+rule(:decimal_deg) {
+  match('[0-9]').repeat(1, 2).as(:degrees) >>
+  (str('.') >> match('[0-9]').repeat(1)).maybe.as(:fraction)
+}
+```
+
+Latitude uses 1-2 digits (0-90); longitude uses 1-3 digits (0-180).
+
+### Sexagesimal (DMS) Format
+
+Degrees, minutes, and seconds with optional fractions:
+
+```ruby
+rule(:sexagesimal) {
+  match('[0-9]').repeat(1, 2).as(:degrees) >>
+  (
+    space >>
+    match('[0-9]').repeat(1, 2).as(:minutes) >>
+    (
+      space >>
+      match('[0-9]').repeat(1, 2).as(:seconds) >>
+      (str('.') >> match('[0-9]').repeat(1)).maybe.as(:sec_fraction)
+    ).maybe
+  ).maybe
+}
+```
+
+Each component is optional, supporting `DD`, `DD MM`, or `DD MM SS.ss`.
+
+### Latitude and Longitude Rules
+
+Latitude is limited to ±90°:
+
+```ruby
+rule(:latitude) {
+  lat_sign >> (decimal_deg | sexagesimal).as(:latitude)
+}
+```
+
+Longitude extends to ±180°:
+
+```ruby
+rule(:longitude) {
+  lon_sign >> (decimal_deg_3 | sexagesimal_3).as(:longitude)
+}
+```
+
+### Altitude (Optional)
+
+Altitude in meters with sign:
+
+```ruby
+rule(:altitude) {
+  (str('+') | str('-')).as(:alt_sign) >>
+  match('[0-9]').repeat(1).as(:alt_value) >>
+  (str('.') >> match('[0-9]').repeat(1)).maybe.as(:alt_fraction)
+}
+```
+
+Positive is above sea level; negative is below.
+
+### Coordinate Reference System
+
+CRS specifies the reference system:
+
+```ruby
+rule(:crs) {
+  str('CRS') >>
+  match('[A-Z0-9_]').repeat(1).as(:crs) >>
+  str('/')
+}
+```
+
+Common values: `WGS_84`, `NAD83`.
+
+### Complete Coordinate
+
+All components assembled:
+
+```ruby
+rule(:coordinate) {
+  latitude >>
+  (space | str('')).maybe >>
+  longitude >>
+  altitude.maybe.as(:altitude) >>
+  (str('/') >> crs).maybe.as(:crs_info)
+}
+```
+
+Altitude and CRS are optional.
+
+## Output Types
+
+```ruby
+# Decimal degrees
+Coordinate.new("+", {:degrees=>"40", :fraction=>".6894"}, "-", {:degrees=>"074", :fraction=>".0447"}, nil, nil)
+# to_h => {:latitude=>40.6894, :longitude=>-74.0447}
+
+# With altitude and CRS
+Coordinate.new("+", lat_hash, "+", lon_hash, {:alt_sign=>"+", :alt_value=>"330"}, "WGS_84")
+# to_h => {:latitude=>48.8584, :longitude=>2.2945, :altitude=>330.0, :crs=>"WGS_84"}
+```
+
+## Design Decisions
+
+### Why Separate Latitude/Longitude Rules?
+
+Different valid ranges (±90 vs ±180) require different digit constraints. Separate rules enforce format correctness.
+
+### Why Struct with to_h?
+
+Struct provides clean attribute access while `to_h` gives a simple hash representation for serialization.
+
+### Why Maybe for Optional Components?
+
+ISO 6709 allows coordinates without altitude or CRS. Using `.maybe` keeps the grammar flexible while still capturing data when present.

data/example/iso-8601/basic.rb

@@ -0,0 +1,275 @@
+# ISO 8601 Date/Time Parser - Ruby Implementation
+#
+# Parse ISO 8601 dates, times, datetimes, and durations.
+#
+# Run with: ruby example/iso-8601/basic.rb
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'parsanol/parslet'
+
+# ISO 8601 parser
+class Iso8601Parser < Parsanol::Parser
+  root :iso_value
+
+  # Date components
+  rule(:year) { match('[0-9]').repeat(4, 4).as(:year) }
+  rule(:month) { match('[0-9]').repeat(2, 2).as(:month) }
+  rule(:day) { match('[0-9]').repeat(2, 2).as(:day) }
+  rule(:date_separator) { str('-').maybe }
+
+  # Calendar date: YYYY-MM-DD or YYYYMMDD
+  rule(:calendar_date) {
+    year >> date_separator >> month >> date_separator >> day
+  }
+
+  # Week date: YYYY-Www-D
+  rule(:week_date) {
+    year >> str('-W') >>
+    match('[0-9]').repeat(2, 2).as(:week) >>
+    str('-') >>
+    match('[1-7]').as(:weekday)
+  }
+
+  # Ordinal date: YYYY-DDD
+  rule(:ordinal_date) {
+    year >> str('-') >>
+    match('[0-9]').repeat(3, 3).as(:ordinal_day)
+  }
+
+  # Time components
+  rule(:hour) { match('[0-9]').repeat(2, 2).as(:hour) }
+  rule(:minute) { match('[0-9]').repeat(2, 2).as(:minute) }
+  rule(:second) { match('[0-9]').repeat(2, 2).as(:second) }
+  rule(:fraction) { str('.') >> match('[0-9]').repeat(1).as(:fraction) }
+  rule(:time_separator) { str(':').maybe }
+
+  # Time: HH:MM:SS[.frac]
+  rule(:time_basic) {
+    hour >> time_separator >> minute >> time_separator >> second >> fraction.maybe
+  }
+
+  # Timezone
+  rule(:utc_designator) { str('Z').as(:utc) }
+  rule(:tz_sign) { (str('+') | str('-')).as(:tz_sign) }
+  rule(:tz_hour) { match('[0-9]').repeat(2, 2).as(:tz_hour) }
+  rule(:tz_minute) { (str(':') >> match('[0-9]').repeat(2, 2)).maybe.as(:tz_minute) }
+
+  rule(:tz_offset) {
+    tz_sign >> tz_hour >> tz_minute
+  }
+
+  rule(:timezone) { utc_designator | tz_offset | str('') }
+
+  rule(:time) { time_basic >> timezone }
+
+  # Combined date-time
+  rule(:datetime) {
+    (calendar_date | week_date | ordinal_date) >>
+    (str('T') | str(' ')) >>
+    time
+  }
+
+  # Duration: P[nY][nM][nD][T[nH][nM][nS]]
+  rule(:duration) {
+    str('P') >>
+    (
+      (match('[0-9]').repeat(1).as(:years) >> str('Y')).maybe >>
+      (match('[0-9]').repeat(1).as(:months) >> str('M')).maybe >>
+      (match('[0-9]').repeat(1).as(:days) >> str('D')).maybe >>
+      (
+        str('T') >>
+        (
+          (match('[0-9]').repeat(1).as(:hours) >> str('H')).maybe >>
+          (match('[0-9]').repeat(1).as(:minutes) >> str('M')).maybe >>
+          (match('[0-9]').repeat(1).as(:seconds) >> str('S')).maybe
+        )
+      ).maybe
+    )
+  }
+
+  # Top-level alternatives
+  rule(:iso_value) { datetime | calendar_date | time | duration }
+end
+
+# Date result class
+IsoDate = Struct.new(:year, :month, :day, :week, :weekday, :ordinal_day) do
+  def to_s
+    if week
+      "#{year}-W#{week}-#{weekday}"
+    elsif ordinal_day
+      "#{year}-#{ordinal_day}"
+    else
+      "#{year}-#{month}-#{day}"
+    end
+  end
+
+  def to_date
+    require 'date'
+    if week
+      Date.commercial(year.to_i, week.to_i, weekday.to_i)
+    elsif ordinal_day
+      Date.ordinal(year.to_i, ordinal_day.to_i)
+    else
+      Date.new(year.to_i, month.to_i, day.to_i)
+    end
+  end
+end
+
+# Time result class
+IsoTime = Struct.new(:hour, :minute, :second, :fraction, :utc, :tz_sign, :tz_hour, :tz_minute) do
+  def to_s
+    h = "#{hour}:#{minute}:#{second}"
+    h += ".#{fraction}" if fraction
+    h += "Z" if utc
+    h += "#{tz_sign}#{tz_hour}#{tz_minute}" if tz_hour
+    h
+  end
+end
+
+# DateTime result class
+IsoDateTime = Struct.new(:date, :time) do
+  def to_s
+    "#{date}T#{time}"
+  end
+end
+
+# Duration result class
+IsoDuration = Struct.new(:years, :months, :days, :hours, :minutes, :seconds) do
+  def to_s
+    parts = ["P"]
+    parts << "#{years}Y" if years
+    parts << "#{months}M" if months
+    parts << "#{days}D" if days
+
+    time_parts = []
+    time_parts << "#{hours}H" if hours
+    time_parts << "#{minutes}M" if minutes
+    time_parts << "#{seconds}S" if seconds
+
+    if time_parts.any?
+      parts << "T"
+      parts.concat(time_parts)
+    end
+
+    parts.join
+  end
+
+  def to_seconds
+    total = 0
+    total += years.to_i * 365.25 * 24 * 3600 if years
+    total += months.to_i * 30.44 * 24 * 3600 if months
+    total += days.to_i * 24 * 3600 if days
+    total += hours.to_i * 3600 if hours
+    total += minutes.to_i * 60 if minutes
+    total += seconds.to_i if seconds
+    total.to_i
+  end
+end
+
+# Transform parse tree to result objects
+class Iso8601Transform < Parsanol::Transform
+  # Calendar date
+  rule(year: simple(:y), month: simple(:m), day: simple(:d)) {
+    IsoDate.new(y.to_s, m.to_s, d.to_s, nil, nil, nil)
+  }
+
+  # Week date
+  rule(year: simple(:y), week: simple(:w), weekday: simple(:wd)) {
+    IsoDate.new(y.to_s, nil, nil, w.to_s, wd.to_s, nil)
+  }
+
+  # Ordinal date
+  rule(year: simple(:y), ordinal_day: simple(:od)) {
+    IsoDate.new(y.to_s, nil, nil, nil, nil, od.to_s)
+  }
+
+  # Time
+  rule(hour: simple(:h), minute: simple(:m), second: simple(:s)) {
+    IsoTime.new(h.to_s, m.to_s, s.to_s, nil, nil, nil, nil)
+  }
+
+  rule(hour: simple(:h), minute: simple(:m), second: simple(:s), fraction: simple(:f)) {
+    IsoTime.new(h.to_s, m.to_s, s.to_s, f.to_s, nil, nil, nil)
+  }
+
+  rule(hour: simple(:h), minute: simple(:m), second: simple(:s), utc: simple(:u)) {
+    IsoTime.new(h.to_s, m.to_s, s.to_s, nil, u.to_s, nil, nil)
+  }
+
+  rule(hour: simple(:h), minute: simple(:m), second: simple(:s), tz_sign: simple(:ts), tz_hour: simple(:th)) {
+    IsoTime.new(h.to_s, m.to_s, s.to_s, nil, nil, ts.to_s, th.to_s, nil)
+  }
+
+  # Duration
+  rule(
+    years: simple(:y), months: simple(:mo), days: simple(:d),
+    hours: simple(:h), minutes: simple(:mi), seconds: simple(:s)
+  ) {
+    IsoDuration.new(y.to_s, mo.to_s, d.to_s, h.to_s, mi.to_s, s.to_s)
+  }
+end
+
+# Parse ISO 8601 string
+def parse_iso8601(str)
+  parser = Iso8601Parser.new
+  transform = Iso8601Transform.new
+
+  tree = parser.parse(str)
+  transform.apply(tree)
+rescue Parsanol::ParseError => e
+  puts "Parse error: #{e.message}"
+  nil
+end
+
+# Main demo
+if __FILE__ == $0
+  puts "ISO 8601 Date/Time Parser"
+  puts "=" * 50
+  puts
+
+  examples = [
+    # Calendar dates
+    ["2024-01-15", "Calendar date"],
+    ["20240115", "Compact date"],
+    ["2024-12-25", "Christmas"],
+
+    # Week dates
+    ["2024-W02-1", "Week date (2nd week, Monday)"],
+
+    # Ordinal dates
+    ["2024-015", "Ordinal date (15th day)"],
+
+    # Times
+    ["10:30:00", "Time"],
+    ["10:30:00.123", "Time with fraction"],
+    ["10:30:00Z", "UTC time"],
+    ["10:30:00+09:00", "Time with timezone"],
+
+    # Date-times
+    ["2024-01-15T10:30:00Z", "DateTime UTC"],
+    ["2024-01-15T10:30:00+09:00", "DateTime with timezone"],
+
+    # Durations
+    ["P1Y2M3DT4H5M6S", "Full duration"],
+    ["PT30M", "30 minutes duration"],
+    ["P1D", "1 day duration"],
+  ]
+
+  examples.each do |input, description|
+    puts "#{description}:"
+    puts "  Input:  #{input}"
+    result = parse_iso8601(input)
+    if result
+      puts "  Result: #{result.inspect}"
+      puts "  String: #{result}"
+      if result.respond_to?(:to_date)
+        puts "  Date:   #{result.to_date rescue 'N/A'}"
+      end
+      if result.respond_to?(:to_seconds)
+        puts "  Seconds: #{result.to_seconds}"
+      end
+    end
+    puts
+  end
+end