From 5b401847a179d37ff81066687a087c3b5ed20008 Mon Sep 17 00:00:00 2001
From: dfhoughton <dfhoughton@gmail.com>
Date: Sat, 7 Mar 2020 14:05:20 -0500
Subject: script useful for debugging

---
 grammar.rb | 241 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 241 insertions(+)
 create mode 100755 grammar.rb

(limited to 'grammar.rb')

diff --git a/grammar.rb b/grammar.rb
new file mode 100755
index 0000000..eb4aa07
--- /dev/null
+++ b/grammar.rb
@@ -0,0 +1,241 @@
+#! env ruby
+
+# something to help examine the possible variations of a sub-pattern
+# run without arguments to see usage
+# mind the expontential complexity!
+
+raw = <<-END.gsub %r{//.*$}, ''
+        TOP -> r(r"\A") <time_expression> r(r"\z")
+
+        // non-terminal patterns
+        // these are roughly ordered by dependency
+
+        time_expression => <universal> | <particular>
+
+        particular => <one_time> | <two_times>
+
+        one_time => <moment_or_period>
+
+        two_times -> ("from")? <moment_or_period> <to> <moment_or_period>
+
+        to => <up_to> | <through>
+
+        moment_or_period => <moment> | <period>
+
+        period => <named_period> | <specific_period>
+
+        specific_period => <modified_period> | <month_and_year> | <year> | <relative_period>
+
+        modified_period -> <modifier>? <modifiable_period>
+
+        // replacing [["week", "month", "year", "pay period", "payperiod", "pp", "weekend"]] with <some_period>
+        // because this script doesn't have handling for the [...] pattern
+        modifiable_period => <some_period> | <a_month> | <a_day>
+
+        month_and_year -> <a_month> <year>
+
+        year => <short_year> | ("-")? <n_year>
+        year -> <suffix_year> <year_suffix>
+
+        year_suffix => <ce> | <bce>
+
+        relative_period -> <count> <displacement> <from_now_or_ago>
+
+        count => r(r"[1-9][0-9]*") | <a_count>
+
+        named_period => <a_day> | <a_month>
+
+        moment -> <adjustment>? <point_in_time>
+
+        adjustment -> <amount> <direction> // two minutes before
+
+        amount -> <count> <unit>
+
+        point_in_time -> <at_time_on>? <some_day> <at_time>? | <specific_time> | <time>
+
+        at_time_on -> ("at")? <time> ("on")?
+
+        some_day => <specific_day> | <relative_day>
+
+        specific_day => <adverb> | <date_with_year>
+
+        date_with_year => <n_date> | <a_date>
+
+        n_date -> <year>    r("[./-]") <n_month> r("[./-]") <n_day>
+        n_date -> <year>    r("[./-]") <n_day>   r("[./-]") <n_month>
+        n_date -> <n_month> r("[./-]") <n_day>   r("[./-]") <year>
+        n_date -> <n_day>   r("[./-]") <n_month> r("[./-]") <year>
+
+        a_date -> <day_prefix>? <a_month> <o_n_day> (",") <year>
+        a_date -> <day_prefix>? <n_day> <a_month> <year>
+        a_date -> <day_prefix>? ("the") <o_day> ("of") <a_month> <year>
+
+        day_prefix => <a_day> (",")?
+
+        relative_day => <a_day> | <a_day_in_month>
+
+        at_time -> ("at") <time>
+
+        specific_time => <first_time> | <last_time> | <precise_time>
+
+        precise_time -> <n_date> <hour_24>
+
+        time -> <hour_12> <am_pm>? | <hour_24> | <named_time>
+
+        hour_12 => <h12>
+        hour_12 => <h12> (":") <minute>
+        hour_12 => <h12> (":") <minute> (":") <second>
+
+        hour_24 => <h24>
+        hour_24 => <h24> (":") <minute>
+        hour_24 => <h24> (":") <minute> (":") <second>
+
+        a_day_in_month => <ordinal_day> | <day_and_month>
+
+        ordinal_day   -> <day_prefix>? ("the") <o_day>    // the first
+
+        o_day => <n_ordinal> | <a_ordinal> | <roman>
+
+        day_and_month -> <n_month> r("[./-]") <n_day>     // 5-6
+        day_and_month -> <a_month> ("the")? <o_n_day>              // June 5, June 5th, June fifth, June the fifth
+        day_and_month -> ("the") <o_day> ("of") <a_month> // the 5th of June, the fifth of June
+
+        o_n_day => <n_day> | <o_day>
+END
+
+# convert this into some partially parsed raw data for further examination
+RAW = {}.tap do |h|
+  raw.lines.each do |l|
+    l.strip!
+    next unless l.length > 0
+    key, value = l.split /\s*[=-]>\s*/
+    list = h[key] ||= []
+    value.split('|').each do |piece|
+      list << piece.strip
+    end
+  end
+end
+
+#####
+## monkey patching for convenience
+#####
+
+class String
+  def deep_dup
+    self
+  end
+  def show(depth=0)
+    puts "  " * depth + self
+  end
+end
+
+class Array
+  def deep_dup
+    map{ |o| o.deep_dup }
+  end
+  def show(depth=0)
+    each do |o|
+      o.show(depth)
+    end
+  end
+end
+
+class Hash
+  def deep_dup
+    Hash[
+      to_a.map do |k,v|
+        [ k.deep_dup, v.deep_dup ]
+      end
+    ]
+  end
+  def show(depth=0)
+    each do |k,v|
+      k.show(depth)
+      v.show(depth + 1)
+    end
+  end
+end
+
+#####
+## functions for extracting variants out of the grammar
+#####
+
+def augment(list, element)
+  if list.length == 0
+    [element.deep_dup]
+  else
+    list.map do |item|
+      if Array === item
+        item.deep_dup + [element.deep_dup]
+      else
+        [ item.deep_dup, element.deep_dup ]
+      end
+    end
+  end
+end
+
+def variants(key)
+  ( @variants ||= {} )[key] ||= begin
+    all_vs = []
+    ( RAW[key] || [] ).each do |line|
+      vs = []
+      line .scan(/(?:<\w+>|r?\([^)]+\))\??/).each do |element|
+        optional = element[-1] == '?'
+        if optional
+          element = element[0..-2]
+          without = vs.dup
+        end
+        case element[0]
+        when 'r', '('
+          vs = augment(vs, element)
+        when '<'
+          subkey = element[1..-2]
+          if RAW.include? subkey
+            new_vs = []
+            variants(subkey).each do |v|
+              new_vs += augment(vs, { subkey => v })
+            end
+            vs = new_vs
+          else
+            vs = augment(vs, subkey)
+          end
+        end
+        if optional
+          vs = without + vs
+        end
+      end
+      all_vs += vs
+    end
+    all_vs
+  end
+end
+
+# convert a variant tree into its leaves
+def leaves(obj)
+  case obj
+  when Array
+    obj.map{ |o| leaves o }.flatten
+  when Hash
+    obj.values.map{ |o| leaves o }.flatten
+  else
+    [obj]
+  end
+end
+
+#####
+## the main function
+#####
+
+key = ARGV.shift
+
+if key
+  variants(key).each do |v|
+    puts leaves(v).join(' ')
+    puts "-----"
+    v.show
+    puts
+  end
+else
+  puts "USAGE: provide one of the following keys to see all the variants in the grammar for that key\n\n"
+  RAW.keys.sort.each{ |k| puts k }
+end
\ No newline at end of file
-- 
cgit v1.2.3