System.Data.SQLite

  #       decimal.
  #
  return [format %.2f [expr {[file size $fileName] / 1048576.0}]]
}

proc getFileHash { fileName } {
  #
  # NOTE: Return the SHA1 hash of the file, making use of Fossil via [exec] to
  # NOTE: Return the SHA3 hash of the file, making use of Fossil via [exec] to
  #       actually calculate it.
  #
  return [string trim [lindex [regexp -inline -nocase -- {[0-9A-F]{40} } \
      [exec fossil sha1sum $fileName]] 0]]
  return [string trim [lindex [regexp -inline -nocase -- {[0-9A-F]{56} } \
      [exec fossil sha3sum $fileName]] 0]]
}

#
# NOTE: Grab the fully qualified directory name of the directory containing
#       this script file.
#
set path [file normalize [file dirname [info script]]]

    [string length $outputDirectory] == 0} then {
  set outputDirectory [file join $path Output]
}

#
# NOTE: Setup the regular expression patterns with the necessary captures.
#       These patterns are mostly non-greedy; however, at the end we need to
#       match exactly 40 hexadecimal characters.  In theory, in Tcl, this could
#       match exactly 56 hexadecimal characters.  In theory, in Tcl, this could
#       have an undefined result due to the mixing of greedy and non-greedy
#       quantifiers; however, in practice, this seems to work properly.  Also,
#       this pattern assumes a particular structure for the [HTML] file to be
#       updated.
#
set pattern1 {<a\
    href=".*?/(.*?\.(?:exe|zip|nupkg))">.*?\((\d+?\.\d+?) MiB\).*?sha1:\
    ([0-9A-F]{40})}
    href=".*?/(.*?\.(?:exe|zip|nupkg))">.*?\((\d+?\.\d+?) MiB\).*?sha3:\
    ([0-9A-F]{56})}

set pattern2 {<a\
    href=".*?/package/.*?/\d+\.\d+\.\d+\.\d+">(.*?)</a>.*?\((\d+?\.\d+?)\
    MiB\).*?sha1: ([0-9A-F]{40})}
    MiB\).*?sha3: ([0-9A-F]{56})}

set pattern3 {href="/downloads/(.*?)"}
set pattern4 {\(sha1: ([0-9A-F]{40})\)}
set pattern4 {\(sha3: ([0-9A-F]{56})\)}
set pattern5 {\((\d+?\.\d+?) MiB\)}

#
# NOTE: Grab all the data from the file to be updated.
#
set data [readFile $updateFileName]

      incr start [string length $fileHash]
    }
  }
}

#
# NOTE: Attempt to verify that each file name now has the correct SHA1 hash
# NOTE: Attempt to verify that each file name now has the correct SHA3 hash
#       associated with it on the page.
#
foreach {dummy3 fileName} [regexp -all -inline -nocase -- $pattern3 $data] \
        {dummy4 fileHash} [regexp -all -inline -nocase -- $pattern4 $data] \
        {dummy5 fileSize} [regexp -all -inline -nocase -- $pattern5 $data] {
  #
  # NOTE: Get the fully qualified file name based on the configured

  #
  # NOTE: Make sure the file hash from the [modified] data matches the
  #       calculated hash for the file.  If not, fail.
  #
  set fullFileHash [getFileHash $fullFileName]

  if {$fileHash ne $fullFileHash} then {
    puts stdout "ERROR: SHA1 hash mismatch for\
    puts stdout "ERROR: SHA3 hash mismatch for\
        file \"$fullFileName\", have \"$fileHash\" (from data),\
        need \"$fullFileHash\" (calculated)."
  }

  set fullFileSize [getFileSize $fullFileName]

  if {$fileSize ne $fullFileSize} then {

    if {[string range $line 0 1] eq "F "} then {
      set fields [split $line " "]

      if {[llength $fields] >= 3} then {
        set fileName [string map [list \\s " "] [lindex $fields 1]]
        set hash [lindex $fields 2]

        if {[regexp -- {[0-9a-f]{40}} $hash]} then {
        if {[regexp -- {[0-9a-f]{40}} $hash] || \
            [regexp -- {[0-9a-f]{56}} $hash]} then {
          set hashes($fileName) $hash; incr result
        }
      }
    }
  }

  return $result
}

proc getSha1Sum { fileName } {
  variable fossil

  set hash [string range [exec -success Success -nocarriagereturns \
      -trimall -- $fossil sha1sum [appendArgs \" $fileName \"]] 0 39]

  if {[regexp -- {[0-9a-f]{40}} $hash]} then {
  if {[regexp -- {[0-9a-f]{40}} $hash] || \
      [regexp -- {[0-9a-f]{56}} $hash]} then {
    return $hash
  }

  return ""
}

set argc [llength $argv]

  set result
} -cleanup {
  cleanupDb $fileName

  unset -nocomplain name rows result db fileName
} -constraints \
{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
-match regexp -result {^\{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40}\}\
-match regexp -result {^\{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40,56}\}\
\{1 \{\{x 1\} \{y foo\} \{z 1234\}\}\} \{count 1\} \{names \{x y z\}\}$}}

###############################################################################

runTest {test data-1.5 {GetSchema with ReservedWords} -setup {
  setupDb [set fileName data-1.5.db]
} -body {

  cleanupDb $fileName

  unset -nocomplain db fileName
} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
defineConstant.System.Data.SQLite.INTEROP_FTS5_EXTENSION\
System.Data.SQLite SQLiteInterop} -match regexp -result \
{^\{fts5: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40}\} \{\} \{\} \{\}\
{^\{fts5: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40,56}\} \{\} \{\} \{\}\
\{\} \{\} \{rowid 3 x horse rowid 4 x house\}$}}

###############################################################################

runTest {test data-1.72 {unbind function from a connection} -setup {
  set fileName data-1.72.db
} -body {

-result {^\d+\.\d+\.\d+(?:\.\d+)?$}}

###############################################################################

runTest {test version-1.16 {SQLiteSourceId} -body {
  object invoke System.Data.SQLite.SQLiteConnection SQLiteSourceId
} -constraints {eagle command.object SQLite System.Data.SQLite} -match regexp \
-result {^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40}$}}
-result {^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [0-9a-f]{40,56}$}}

###############################################################################

runTest {test version-1.17 {InteropVersion} -body {
  object invoke System.Data.SQLite.SQLiteConnection InteropVersion
} -constraints {eagle command.object SQLiteInterop System.Data.SQLite} -result \
$version(full)}

###############################################################################

runTest {test version-1.18 {InteropSourceId} -body {
  object invoke System.Data.SQLite.SQLiteConnection InteropSourceId
} -constraints {eagle command.object SQLiteInterop System.Data.SQLite} -match \
regexp -result {^[0-9a-f]{40} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$}}
regexp -result {^[0-9a-f]{40,56} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$}}

###############################################################################

runTest {test version-1.19 {ProviderVersion} -body {
  object invoke System.Data.SQLite.SQLiteConnection ProviderVersion
} -constraints {eagle command.object System.Data.SQLite} -result $version(full)}

###############################################################################

runTest {test version-1.20 {ProviderSourceId} -body {
  #
  # NOTE: The ProviderSourceId property value may be null, which
  #       would result in an empty string being returned here.
  #
  object invoke System.Data.SQLite.SQLiteConnection ProviderSourceId
} -constraints {eagle command.object System.Data.SQLite} -match regexp -result \
{^(?:|[0-9a-f]{40} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC)$}}
{^(?:|[0-9a-f]{40,56} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC)$}}

###############################################################################

unset -nocomplain patterns

###############################################################################
# readme.htm