Replaced kebab-case with snake_case for naming convention.

1 files changed, 30 insertions, 30 deletions

diff --git a/stdlib/source/program/aedifex/metadata/artifact.lux b/stdlib/source/program/aedifex/metadata/artifact.lux
index aa7b9abce..cf9a34b58 100644
--- a/stdlib/source/program/aedifex/metadata/artifact.lux
+++ b/stdlib/source/program/aedifex/metadata/artifact.lux
@@ -29,7 +29,7 @@
   {#group Group
    #name Name
    #versions (List Version)
-   #last-updated Instant})
+   #last_updated Instant})
 
 (def: (pad value)
   (-> Nat Text)
@@ -37,23 +37,23 @@
     (format "0" (%.nat value))
     (%.nat value)))
 
-(def: (date-format value)
+(def: (date_format value)
   (%.Format Date)
   (format (|> value date.year year.value .nat %.nat)
           (|> value date.month month.number ..pad)
-          (|> value date.day-of-month ..pad)))
+          (|> value date.day_of_month ..pad)))
 
-(def: (time-format value)
+(def: (time_format value)
   (%.Format Time)
   (let [(^slots [#time.hour #time.minute #time.second]) (time.clock value)]
     (format (..pad hour)
             (..pad minute)
             (..pad second))))
 
-(def: (instant-format value)
+(def: (instant_format value)
   (%.Format Instant)
-  (format (..date-format (instant.date value))
-          (..time-format (instant.time value))))
+  (format (..date_format (instant.date value))
+          (..time_format (instant.time value))))
 
 (template [<definition> <tag>]
   [(def: <definition> xml.Tag ["" <tag>])]
@@ -63,7 +63,7 @@
   [<version> "version"]
   [<versioning> "versioning"]
   [<versions> "versions"]
-  [<last-updated> "lastUpdated"]
+  [<last_updated> "lastUpdated"]
   [<metadata> "metadata"]
   )
 
@@ -72,26 +72,26 @@
      (-> <type> XML)
      (|>> <pre> #xml.Text list (#xml.Node <tag> xml.attributes)))]
 
-  [write-group Group ..<group> (|>)]
-  [write-name Name ..<name> (|>)]
-  [write-version Version ..<version> (|>)]
-  [write-last-updated Instant ..<last-updated> ..instant-format]
+  [write_group Group ..<group> (|>)]
+  [write_name Name ..<name> (|>)]
+  [write_version Version ..<version> (|>)]
+  [write_last_updated Instant ..<last_updated> ..instant_format]
   )
 
-(def: write-versions
+(def: write_versions
   (-> (List Version) XML)
-  (|>> (list\map ..write-version) (#xml.Node ..<versions> xml.attributes)))
+  (|>> (list\map ..write_version) (#xml.Node ..<versions> xml.attributes)))
 
 (def: #export (write value)
   (-> Metadata XML)
   (#xml.Node ..<metadata>
              xml.attributes
-             (list (..write-group (get@ #group value))
-                   (..write-name (get@ #name value))
+             (list (..write_group (get@ #group value))
+                   (..write_name (get@ #name value))
                    (#xml.Node ..<versioning>
                               xml.attributes
-                              (list (..write-versions (get@ #versions value))
-                                    (..write-last-updated (get@ #last-updated value)))))))
+                              (list (..write_versions (get@ #versions value))
+                                    (..write_last_updated (get@ #last_updated value)))))))
 
 (def: (sub tag parser)
   (All [a] (-> xml.Tag (Parser a) (Parser a)))
@@ -103,17 +103,17 @@
   (-> xml.Tag (Parser Text))
   (..sub tag <xml>.text))
 
-(def: date-parser
+(def: date_parser
   (<text>.Parser Date)
   (do <>.monad
     [year (<>.codec n.decimal (<text>.exactly 4 <text>.decimal))
      year (<>.lift (year.year (.int year)))
      month (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))
-     month (<>.lift (month.by-number month))
-     day-of-month (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))]
-    (<>.lift (date.date year month day-of-month))))
+     month (<>.lift (month.by_number month))
+     day_of_month (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))]
+    (<>.lift (date.date year month day_of_month))))
 
-(def: time-parser
+(def: time_parser
   (<text>.Parser Time)
   (do <>.monad
     [hour (<>.codec n.decimal (<text>.exactly 2 <text>.decimal))
@@ -123,15 +123,15 @@
               {#time.hour hour
                #time.minute minute
                #time.second second
-               #time.milli-second 0}))))
+               #time.milli_second 0}))))
 
-(def: last-updated-parser
+(def: last_updated_parser
   (Parser Instant)
   (<text>.embed (do <>.monad
-                  [date ..date-parser
-                   time ..time-parser]
-                  (wrap (instant.from-date-time date time)))
-                (..text ..<last-updated>)))
+                  [date ..date_parser
+                   time ..time_parser]
+                  (wrap (instant.from_date_time date time)))
+                (..text ..<last_updated>)))
 
 (def: #export parser
   (Parser Metadata)
@@ -144,7 +144,7 @@
                   (<| <xml>.somewhere
                       (..sub ..<versions>)
                       (<>.many (..text ..<version>)))
-                  (<xml>.somewhere ..last-updated-parser)
+                  (<xml>.somewhere ..last_updated_parser)
                   ))
           )))