brut 0.17.0 → 0.18.0

data/brut-js/src/index.js

@@ -1,133 +0,0 @@
-import BaseCustomElement           from "./BaseCustomElement"
-import AjaxSubmit                  from "./AjaxSubmit"
-import Autosubmit                  from "./Autosubmit"
-import ConfirmSubmit               from "./ConfirmSubmit"
-import ConfirmationDialog          from "./ConfirmationDialog"
-import ConstraintViolationMessage  from "./ConstraintViolationMessage"
-import ConstraintViolationMessages from "./ConstraintViolationMessages"
-import CopyToClipboard             from "./CopyToClipboard"
-import Form                        from "./Form"
-import I18nTranslation             from "./I18nTranslation"
-import LocaleDetection             from "./LocaleDetection"
-import Message                     from "./Message"
-import RichString                  from "./RichString"
-import Tabs                        from "./Tabs"
-import Toast                       from "./Toast"
-import Tracing                     from "./Tracing"
-
-/**
- * This is the code for a test case. It may return a {@link external:Promise} if there is async behavior that must
- * be waited-on to properly assert behavior.
- *
- * @callback testCodeCallback
- *
- * @param {Object} objects - objects passed into your test that you may need.
- * @param {Window} objects.window - Access to the top-level window object. Note that this provided by JSDOM and is not exactly like the `Window` you'd get in your browser.
- * @param {Document} objects.document - Access to the top-level document object. Note that this provided by JSDOM and is not exactly like the `Document` you'd get in your browser.
- * @param {Object} objects.assert - The NodeJS assert object that you should use to assert behavior.
- * @param {Object} objects.fetchRequests - An array of `Request` instances given to `fetch`.  This will be updated as `fetch` is
- * called and can be useful to assert the contents of what was requested via `fetch`.
- *
- * @example
- * test("some test", ({document,assert}) => {
- *   const element = document.querySelector("div")
- *   assert(div.getAttribute("data-foo") != null)
- * })
- *
- * @example
- * test("some other test", ({document,window,assert}) => {
- *   const element = document.querySelector("div")
- *   assert.equal(window.history.state["foo"], "bar")
- * })
- */
-
-/**
- * @external Performance
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance|Performance API}
- */
-
-/**
- * @external Promise
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise|Promise}
- */
-/**
- * @external fetch
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch|fetch}
- */
-
-/**
- * @external ValidityState
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ValidityState|ValidityState}
- */
-
-/**
- * The standard `CustomElementRegistry`
- *
- * @external CustomElementRegistry
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry|CustomElementRegistry}
- */
-
-/**
- * @external Window
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/|Window}
- */
-
-/** 
- * @method confirm
- * @memberof external:Window#
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm|confirm}
- */
-
-/**
- * Class that can be used to automatically define all of brut's custom
- * elements.
- */
-class BrutCustomElements {
-  static elementClasses = []
-  static define() {
-    this.elementClasses.forEach( (e) => {
-      e.define() 
-    })
-  }
-  static addElementClasses(...classes) {
-    this.elementClasses.push(...classes)
-  }
-}
-
-BrutCustomElements.addElementClasses(
-  // Ordering is important here - TBD how to make sure these are created in order
-  I18nTranslation,
-  CopyToClipboard,
-  Message,
-  ConfirmSubmit,
-  ConfirmationDialog,
-  ConstraintViolationMessages,
-  Form,
-  AjaxSubmit,
-  ConstraintViolationMessage,
-  Tabs,
-  Toast,
-  LocaleDetection,
-  Autosubmit,
-  Tracing,
-)
-
-export {
-  AjaxSubmit,
-  Autosubmit,
-  BaseCustomElement,
-  BrutCustomElements,
-  ConfirmSubmit,
-  ConfirmationDialog,
-  ConstraintViolationMessage,
-  ConstraintViolationMessages,
-  Form,
-  I18nTranslation,
-  LocaleDetection,
-  Message,
-  RichString,
-  Tabs,
-  Toast,
-  Tracing
-}
-

data/brut-js/src/testing/AssetMetadata.js

@@ -1,35 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-/**
- * Provides structured access to the asset metadata for a BrutRB app. This is used to allow custom elements
- * to be defined in JSDOM the same way they are in a real browser.
- *
- * @memberof testing
- */
-class AssetMetadata {
-  constructor(parsedJSON, publicRoot) {
-    this.assetMetadata = parsedJSON.asset_metadata
-    this.publicRoot    = publicRoot
-  }
-
-  scriptURLs() {
-    return Object.entries(this.assetMetadata[".js"]).map( (entry) => {
-      return entry[0] 
-    })
-  }
-
-  fileContainingScriptURL(scriptURL) {
-    const file = Object.entries(this.assetMetadata[".js"]).find( (entry) => {
-      return entry[0] == scriptURL
-    })
-    if (!file || !file[1]) {
-      return null
-    }
-    let relativePath = file[1]
-    if (relativePath[0] == "/") {
-      relativePath = relativePath.slice(1)
-    }
-    return fs.readFileSync(path.resolve(this.publicRoot,relativePath))
-  }
-}
-export default AssetMetadata

data/brut-js/src/testing/AssetMetadataLoader.js

@@ -1,25 +0,0 @@
-import { ResourceLoader } from "jsdom"
-
-/**
- * An JSDOM resource loader based on BrutRB asset metadata.
- *
- * @memberof testing
- */
-class AssetMetadataLoader extends ResourceLoader {
-  constructor(assetMetadata) {
-    super()
-    this.assetMetadata = assetMetadata
-  }
-
-  fetch(url,options) {
-    const parsedURL = new URL(url)
-    const jsContents = this.assetMetadata.fileContainingScriptURL(parsedURL.pathname)
-    if (jsContents) {
-      return Promise.resolve(jsContents)
-    }
-    else {
-      return super.fetch(url,options)
-    }
-  }
-}
-export default AssetMetadataLoader

data/brut-js/src/testing/CustomElementTest.js

@@ -1,235 +0,0 @@
-import DOMCreator from "./DOMCreator.js"
-import assert from "assert"
-/**
- * The class that implements a test case.  Typically, an instance of this is created for you and you call `test` on that to write your
- * test case.
- * @memberof testing
- */
-class CustomElementTest {
-  constructor(html, queryString, assetMetadata) {
-    this.html          = html
-    this.queryString   = queryString
-    this.fetchBehavior = {}
-    this.assetMetadata = assetMetadata
-  }
-
-  /**
-   * Configure a query string to be present when the custom elements are defined and connected.
-   */
-  andQueryString(queryString) {
-    this.queryString = queryString
-    return this
-  }
-
-  /**
-   * Configure behavior when #{link external:fetch} is called, since it's not implemented by JSDom or NodeJS.
-   *
-   * @param {String} url - the URL that is expected. This should be a relative URL, as that is all that is currently supported. This
-   * URL must match exactly to a `fetch` call.
-   * @param {Object} behavior - an object describing what you want to happen when `url` is fetched.  This currently supports only a
-   * few rudimentary behaviors:
-   * * `{then: { ok: { text: "some text" } } }` - This will return an "ok" response whose body is the given text, available only as
-   * text.
-   * * `{then: { status: XXX, text: "some text" }}` - This will return the given http status, with `ok` as true if it's 2xx or 3xx. If `text` is given, that will be available as text only.
-   */
-  onFetch(url,behavior) {
-    if (!this.fetchBehavior[url]) {
-      this.fetchBehavior[url] = {
-        numCalls: 0,
-        responses: [],
-      }
-    }
-    if (behavior instanceof Array) {
-      behavior.forEach( (b) =>  {
-        this.fetchBehavior[url].responses.push(b)
-      })
-    }
-    else {
-      this.fetchBehavior[url].responses.push(behavior)
-    }
-    return this
-  }
-
-  /** Comment out a test without using code comments */
-  xtest() {
-    return this
-  }
-
-
-  /** Declare a test to run with the previously-defined HTML, query string, and fetch behavior.
-   *
-   * @param {String} description - a description of the test.
-   * @param {testCodeCallback} testCode - a function containing the code for your test.
-   */
-  test(description,testCode) {
-    it(description, () => {
-      const domCreator = new DOMCreator(this.assetMetadata)
-      const dom = domCreator.create({
-        html: this.html,
-        queryString: this.queryString
-      })
-      const fetchRequests = []
-
-      dom.window.Request = Request
-      dom.window.fetch = (request) => {
-        const url = new URL(request.url)
-        const path = url.pathname + url.search
-        const behaviors = this.fetchBehavior[path]
-        if (!behaviors) {
-          throw `fetch() called with ${path}, which was not configured`
-        }
-        if (behaviors.numCalls > behaviors.responses.length) {
-          throw `fetch() called ${behaviors.numCalls} times, but we only have ${behaviors.response.length} responses configured`
-        }
-        const behavior = behaviors.responses[behaviors.numCalls]
-        behaviors.numCalls++
-
-        let promise = null
-
-        if (behavior.then) {
-          if (behavior.then.ok) {
-            if (behavior.then.ok.text) {
-              const response = {
-                ok: true,
-                text: () => {
-                  return Promise.resolve(behavior.then.ok.text)
-                }
-              }
-              promise = Promise.resolve(response)
-            }
-            else {
-              throw `unknown fetch behavior: expected then.ok.text: ${JSON.stringify(behavior)}`
-            }
-          }
-          else if (behavior.then.status) {
-            let ok = false
-            if ((behavior.then.status >= 200) && (behavior.then.status < 400) ){
-              ok = true
-            }
-            const response = {
-              ok: ok,
-              status: behavior.then.status,
-                text: () => {
-                  return Promise.resolve(behavior.then.text)
-                }
-            }
-            promise = Promise.resolve(response)
-          }
-          else {
-            throw `unknown fetch behavior: expected then.ok or then.status: ${JSON.stringify(behavior)}`
-          }
-        }
-        else {
-          throw `unknown fetch behavior: expected then: ${JSON.stringify(behavior)}`
-        }
-        request.promiseReturned = promise
-        fetchRequests.push(request)
-        return promise
-      }
-
-      const window = dom.window
-      const document = window.document
-      let returnValue = null
-      return new Promise( (resolve, reject) => {
-        dom.window.addEventListener("load", () => {
-          try {
-            const paramsGivenToTest = {
-              window,
-              document,
-              assert,
-              fetchRequests,
-              waitForSetTimeout: this.#waitForSetTimeout,
-              readRequestBodyIntoJSON: this.#readRequestBodyIntoJSON,
-              readRequestBodyIntoString: this.#readRequestBodyIntoString,
-            }
-            returnValue = testCode(paramsGivenToTest)
-            if (returnValue) {
-              resolve(returnValue)
-            }
-            else {
-              resolve()
-            }
-          } catch (e) {
-            reject(e)
-          }
-        })
-      })
-    })
-    return this
-  }
-
-  /** Used to wait for a few milliseconds before performing further assertions.
-   * This can be useful when a custom element has `setTimeout` calls
-   */
-  #waitForSetTimeout = (ms) => {
-    return new Promise( (resolve) => {
-      setTimeout(resolve,ms)
-    })
-  }
-
-  /**
-   * Given a fetch request (available via `fetchRequests` passed to your test), turn the body into JSON
-   * and return a promise with the JSON.  To use this in a test, you must include your assertions inside
-   * the `then` of the returned promise and you *must* return that from your test.
-   *
-   * @example
-   * withHTML(
-   *   "<div-makes-a-fetch>"
-   * ).onFetch("/foo", { then: { status: 200 }}
-   * ).test("a test",({assert,fetchRequests}) => {
-   *   assert.equal(fetchRequests.length,1)
-   *   return readRequestBodyIntoJSON(fetchRequests[0]).then( (json) => {
-   *     assert.equal(json["foo"],"bar")
-   *   })
-   * })
-   */
-  #readRequestBodyIntoJSON = (request) => {
-    return this.#readRequestBodyIntoString(request).then( (string) => {
-      try {
-        const json = JSON.parse(string)
-        return Promise.resolve(json)
-      }
-      catch (e) {
-        assert(false,`'${string}' could not be parsed as JSON`)
-      }
-      return Promise.resolve()
-    })
-  }
-
-  /**
-   * Given a fetch request (available via `fetchRequests` passed to your test), turn the body into a string
-   * and return a promise with the string.  To use this in a test, you must include your assertions inside
-   * the `then` of the returned promise and you *must* return that from your test.
-   *
-   * @example
-   * withHTML(
-   *   "<div-makes-a-fetch>"
-   * ).onFetch("/foo", { then: { status: 200 }}
-   * ).test("a test",({assert,fetchRequests}) => {
-   *   assert.equal(fetchRequests.length,1)
-   *   return readRequestBodyIntoString(fetchRequests[0]).then( (string) => {
-   *     assert.equal(string,"foo")
-   *   })
-   * })
-   */
-  #readRequestBodyIntoString = (request) => {
-    const reader = request.body.getReader()
-    const utf8Decoder = new TextDecoder("utf-8");
-    let string = ""
-    const parse = ({value,done}) => {
-      if (done) {
-        return Promise.resolve(string)
-      }
-      else {
-        if (value) {
-          string = string + utf8Decoder.decode(value, { stream: true })
-        }
-        return reader.read().then(parse)
-      }
-    }
-    return reader.read().then(parse)
-  }
-
-
-}
-export default CustomElementTest

data/brut-js/src/testing/DOMCreator.js

@@ -1,45 +0,0 @@
-import { JSDOM, VirtualConsole } from "jsdom"
-
-import AssetMetadataLoader from "./AssetMetadataLoader.js"
-
-/**
- * Creates a JSDOM based on the the given HTML and query string.
- *
- * @memberof testing
- */
-class DOMCreator {
-  constructor(assetMetadata) {
-    this.assetMetadata = assetMetadata
-  }
-
-  create({html,queryString}) {
-
-    const resourceLoader = new AssetMetadataLoader(this.assetMetadata)
-
-
-    const url = "http://example.com" + ( queryString ? `?${queryString}` : "" )
-
-    const scripts = this.assetMetadata.scriptURLs().map( (url) => `<script src="${url}"></script>` )
-    const virtualConsole = new VirtualConsole()
-    virtualConsole.sendTo(console);
-    return new JSDOM(
-      `<!DOCTYPE html>
-        <html>
-        <head>
-        ${scripts}
-        </head>
-        <body>
-        ${html}
-        </body>
-        </html>
-        `,{
-          resources: "usable",
-          runScripts: "dangerously",
-          includeNodeLocations: true,
-          resources: resourceLoader,
-          url: url
-        }
-    )
-  }
-}
-export default DOMCreator

data/brut-js/src/testing/index.js

@@ -1,48 +0,0 @@
-/**
- * Enables and implements a basic testing system for custom elements. This uses JSDOM and some hacks to allow
- * you to test your custom elements using a DOM-like experience, but without having to run a real browser.
- * It is designed to have very few dependencies to ensure the least amount of configuration and tool
- * debt.
- *
- * It assumes you are using Mocha.  To create a test, create a file named `Whatever.spec.js` in the folder where you are running
- * Mocha.  Convention is that `Whatever` is the name of your custom element's class.
- *
- * @example
- * import { withHTML } from "../src/testing/index.js"
- *
- * describe("<some-element>", () => {
- *   withHTML(`
- *   <some-element>OK</some-element>
- *   `).test("lower-cases its contents", ({document,assert}) => {
- *     const element = document.querySelector("some-element")
- *     assert.equal(element.textContent,"ok")
- *   })
- * })
- *
- * @module testing
- */
-import AssetMetadata from "./AssetMetadata.js"
-import CustomElementTest from "./CustomElementTest.js"
-
-/**
- * Bootstraps a test based on some HTML and configuration about where the bundled custom elements are. It's recommended that you
- * create the method `withHTML` in your `SpecHelper.js` file to set up the asset metadata stuff.
- *
- * This returns a {@link module:testing~CustomElementTest}, on which you can call additional setup methods, or start defining tests with the 
- * {@link module:testing~CustomElementTest#test} method.
- *
- * @param {String} html - HTML that should be in the document for the test
- * @param {Object} assetMetadata - a JSON object describing where the bundles are.  This is needed to allow JSDOM to load the custom
- * elements as if it were served up by a webserver
- * @param {String} publicRoot - The root to where JS files.  When using this in a BrutRB web app, this would be where your bundled
- * files are placed for serving.
- *
- * @see module:testing~CustomElementTest
- */
-const createTestBasedOnHTML = ({html,assetMetadata,publicRoot}) => {
-  return new CustomElementTest(html,null,new AssetMetadata(assetMetadata,publicRoot))
-}
-
-export {
-  createTestBasedOnHTML
-}

data/brut.gemspec

@@ -1,73 +0,0 @@
-lib = File.expand_path("../lib", __FILE__)
-if !$LOAD_PATH.include?(lib)
-  $LOAD_PATH.unshift(lib)
-end
-require "brut/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "brut"
-  spec.version       = Brut::VERSION
-  spec.authors       = ["David Bryant Copeland"]
-  spec.email         = ["davec@thirdtank.com"]
-
-  spec.summary       = %q{Web Framework Built around Ruby, Web Standards, Simplicity, and Object-Orientation}
-  spec.description   = %q{An opinionated web framework build on web standards}
-  spec.homepage      = "https://brutrb.com"
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    spec.metadata["allowed_push_host"] = "https://rubygems.org"
-
-    spec.metadata["homepage_uri"] = spec.homepage
-    spec.metadata["source_code_uri"] = "https://github.com/thirdtank/brut"
-    spec.metadata["changelog_uri"] = "https://github.com/thirdtank/brut/blob/main/CHANGELOG.md"
-    spec.metadata["documentation_uri"] = "https://brutrb.com/"
-    spec.metadata["rubygems_mfa_required"] = "true"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
-  end
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "irb"
-  spec.add_dependency "ostruct" # squelch some warning - this is not used
-  spec.add_dependency "concurrent-ruby"
-  spec.add_dependency "i18n"
-  spec.add_dependency "nokogiri"
-  spec.add_dependency "phlex"
-  spec.add_dependency "prism"
-  spec.add_dependency "rack-protection"
-  spec.add_dependency "rackup"
-  spec.add_dependency "semantic_logger"
-  spec.add_dependency "sequel"
-  spec.add_dependency "sinatra"
-  spec.add_dependency "tzinfo"
-  spec.add_dependency "tzinfo-data"
-  spec.add_dependency "zeitwerk"
-  spec.add_dependency "opentelemetry-sdk"
-  spec.add_dependency "opentelemetry-exporter-otlp"
-  spec.add_dependency "unicode-display_width"
-
-  spec.add_development_dependency "activesupport"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "confidence-check"
-  spec.add_development_dependency "dotenv"
-  spec.add_development_dependency "factory_bot"
-  spec.add_development_dependency "faker"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rdiscount"
-  spec.add_development_dependency "rdoc"
-  spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "rubocop-disable_syntax"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "yard"
-end