ortfodb 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d68be6f3abc3321418707238fb49360dd099acd9205f427dcd2aeba47da325cc
+  data.tar.gz: 1d72869648fb3efaeab1234642f1fc1126a8adef8758c6d1687ae300594e5b9a
+SHA512:
+  metadata.gz: 6369f2be64be4fde1f479cef9cdcc85ff9f7b461998b09bb09294071676b9ee2228295b419ef384ae466c025fc7f1c16a332ab43295a5d51d992cdc51b323784
+  data.tar.gz: 70429cae954a86b7cc1bf2c3bbe7e005ca467958423aa45ebbfb2c88c8aa4b814bf1e7f12d0af1d91bc0f3025726647cb793f911433318ccaefe482b049d5b13

data/lib/ortfodb/configuration.rb

@@ -0,0 +1,251 @@
+# This code may look unusually verbose for Ruby (and it is), but
+# it performs some subtle and complex validation of JSON data.
+#
+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+#
+#   configuration = Configuration.from_json! "{…}"
+#   puts configuration.technologies.repository
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+require 'json'
+require 'dry-types'
+require 'dry-struct'
+
+module Ortfodb
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Integer = Strict::Integer
+    Bool    = Strict::Bool
+    Hash    = Strict::Hash
+    String  = Strict::String
+  end
+
+  class ExtractColors < Dry::Struct
+    attribute :default_files, Types.Array(Types::String)
+    attribute :enabled,       Types::Bool
+    attribute :extract,       Types.Array(Types::String)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        default_files: d.fetch("default files"),
+        enabled:       d.fetch("enabled"),
+        extract:       d.fetch("extract"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "default files" => default_files,
+        "enabled"       => enabled,
+        "extract"       => extract,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class MakeGifs < Dry::Struct
+    attribute :enabled,            Types::Bool
+    attribute :file_name_template, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        enabled:            d.fetch("enabled"),
+        file_name_template: d.fetch("file name template"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "enabled"            => enabled,
+        "file name template" => file_name_template,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class MakeThumbnails < Dry::Struct
+    attribute :enabled,            Types::Bool
+    attribute :file_name_template, Types::String
+    attribute :input_file,         Types::String
+    attribute :sizes,              Types.Array(Types::Integer)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        enabled:            d.fetch("enabled"),
+        file_name_template: d.fetch("file name template"),
+        input_file:         d.fetch("input file"),
+        sizes:              d.fetch("sizes"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "enabled"            => enabled,
+        "file name template" => file_name_template,
+        "input file"         => input_file,
+        "sizes"              => sizes,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Media < Dry::Struct
+    attribute :at, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        at: d.fetch("at"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "at" => at,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Tags < Dry::Struct
+    attribute :repository, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        repository: d.fetch("repository"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "repository" => repository,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Technologies < Dry::Struct
+    attribute :repository, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        repository: d.fetch("repository"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "repository" => repository,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  # Configuration represents what the ortfodb.yaml configuration file describes.
+  class Configuration < Dry::Struct
+    attribute :build_metadata_file, Types::String
+
+    # Exporter-specific configuration. Maps exporter names to their configuration.
+    attribute :exporters, Types::Hash.meta(of: Types::Hash.meta(of: Types::Any)).optional
+
+    attribute :extract_colors,  ExtractColors
+    attribute :make_gifs,       MakeGifs
+    attribute :make_thumbnails, MakeThumbnails
+    attribute :media,           Media
+
+    # Path to the directory containing all projects. Must be absolute.
+    attribute :projects_at, Types::String
+
+    attribute :scattered_mode_folder, Types::String
+    attribute :tags,                  Tags
+    attribute :technologies,          Technologies
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        build_metadata_file:   d.fetch("build metadata file"),
+        exporters:             Types::Hash.optional[d["exporters"]]&.map { |k, v| [k, Types::Hash[v].map { |k, v| [k, Types::Any[v]] }.to_h] }&.to_h,
+        extract_colors:        ExtractColors.from_dynamic!(d.fetch("extract colors")),
+        make_gifs:             MakeGifs.from_dynamic!(d.fetch("make gifs")),
+        make_thumbnails:       MakeThumbnails.from_dynamic!(d.fetch("make thumbnails")),
+        media:                 Media.from_dynamic!(d.fetch("media")),
+        projects_at:           d.fetch("projects at"),
+        scattered_mode_folder: d.fetch("scattered mode folder"),
+        tags:                  Tags.from_dynamic!(d.fetch("tags")),
+        technologies:          Technologies.from_dynamic!(d.fetch("technologies")),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "build metadata file"   => build_metadata_file,
+        "exporters"             => exporters,
+        "extract colors"        => extract_colors.to_dynamic,
+        "make gifs"             => make_gifs.to_dynamic,
+        "make thumbnails"       => make_thumbnails.to_dynamic,
+        "media"                 => media.to_dynamic,
+        "projects at"           => projects_at,
+        "scattered mode folder" => scattered_mode_folder,
+        "tags"                  => tags.to_dynamic,
+        "technologies"          => technologies.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+end

data/lib/ortfodb/database.rb

@@ -0,0 +1,439 @@
+# This code may look unusually verbose for Ruby (and it is), but
+# it performs some subtle and complex validation of JSON data.
+#
+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+#
+#   database = Database.from_json! "{…}"
+#   puts database["…"].metadata.tags.first
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+require 'json'
+require 'dry-types'
+require 'dry-struct'
+
+module Ortfodb
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Integer = Strict::Integer
+    Bool    = Strict::Bool
+    Hash    = Strict::Hash
+    String  = Strict::String
+    Double  = Strict::Float | Strict::Integer
+  end
+
+  # MediaAttributes stores which HTML attributes should be added to the media.
+  class Attributes < Dry::Struct
+
+    # Controlled with attribute character > (adds)
+    attribute :autoplay, Types::Bool
+
+    # Controlled with attribute character = (removes)
+    attribute :controls, Types::Bool
+
+    # Controlled with attribute character ~ (adds)
+    attribute :attributes_loop, Types::Bool
+
+    # Controlled with attribute character > (adds)
+    attribute :muted, Types::Bool
+
+    # Controlled with attribute character = (adds)
+    attribute :playsinline, Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        autoplay:        d.fetch("autoplay"),
+        controls:        d.fetch("controls"),
+        attributes_loop: d.fetch("loop"),
+        muted:           d.fetch("muted"),
+        playsinline:     d.fetch("playsinline"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "autoplay"    => autoplay,
+        "controls"    => controls,
+        "loop"        => attributes_loop,
+        "muted"       => muted,
+        "playsinline" => playsinline,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  # ColorPalette reprensents the object in a Work's metadata.colors.
+  class Colors < Dry::Struct
+    attribute :primary,   Types::String
+    attribute :secondary, Types::String
+    attribute :tertiary,  Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        primary:   d.fetch("primary"),
+        secondary: d.fetch("secondary"),
+        tertiary:  d.fetch("tertiary"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "primary"   => primary,
+        "secondary" => secondary,
+        "tertiary"  => tertiary,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  # ImageDimensions represents metadata about a media as it's extracted from its file.
+  class Dimensions < Dry::Struct
+
+    # width / height
+    attribute :aspect_ratio, Types::Double
+
+    # Height in pixels
+    attribute :height, Types::Integer
+
+    # Width in pixels
+    attribute :width, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        aspect_ratio: d.fetch("aspectRatio"),
+        height:       d.fetch("height"),
+        width:        d.fetch("width"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "aspectRatio" => aspect_ratio,
+        "height"      => height,
+        "width"       => width,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Thumbnails < Dry::Struct
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class BlockElement < Dry::Struct
+    attribute :alt, Types::String
+
+    # whether the media has been analyzed
+    attribute :analyzed, Types::Bool
+
+    attribute :anchor,     Types::String
+    attribute :attributes, Attributes
+    attribute :caption,    Types::String
+    attribute :colors,     Colors
+
+    # html
+    attribute :content, Types::String
+
+    attribute :content_type, Types::String
+    attribute :dimensions,   Dimensions
+    attribute :dist_source,  Types::String
+
+    # in seconds
+    attribute :duration, Types::Double
+
+    attribute :has_sound,       Types::Bool
+    attribute :id,              Types::String
+    attribute :index,           Types::Integer
+    attribute :online,          Types::Bool
+    attribute :relative_source, Types::String
+
+    # in bytes
+    attribute :size, Types::Integer
+
+    attribute :text,                 Types::String
+    attribute :thumbnails,           Thumbnails
+    attribute :thumbnails_built_at,  Types::String
+    attribute :title,                Types::String
+    attribute :database_schema_type, Types::String
+    attribute :url,                  Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        alt:                  d.fetch("alt"),
+        analyzed:             d.fetch("analyzed"),
+        anchor:               d.fetch("anchor"),
+        attributes:           Attributes.from_dynamic!(d.fetch("attributes")),
+        caption:              d.fetch("caption"),
+        colors:               Colors.from_dynamic!(d.fetch("colors")),
+        content:              d.fetch("content"),
+        content_type:         d.fetch("contentType"),
+        dimensions:           Dimensions.from_dynamic!(d.fetch("dimensions")),
+        dist_source:          d.fetch("distSource"),
+        duration:             d.fetch("duration"),
+        has_sound:            d.fetch("hasSound"),
+        id:                   d.fetch("id"),
+        index:                d.fetch("index"),
+        online:               d.fetch("online"),
+        relative_source:      d.fetch("relativeSource"),
+        size:                 d.fetch("size"),
+        text:                 d.fetch("text"),
+        thumbnails:           Thumbnails.from_dynamic!(d.fetch("thumbnails")),
+        thumbnails_built_at:  d.fetch("thumbnailsBuiltAt"),
+        title:                d.fetch("title"),
+        database_schema_type: d.fetch("type"),
+        url:                  d.fetch("url"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "alt"               => alt,
+        "analyzed"          => analyzed,
+        "anchor"            => anchor,
+        "attributes"        => attributes.to_dynamic,
+        "caption"           => caption,
+        "colors"            => colors.to_dynamic,
+        "content"           => content,
+        "contentType"       => content_type,
+        "dimensions"        => dimensions.to_dynamic,
+        "distSource"        => dist_source,
+        "duration"          => duration,
+        "hasSound"          => has_sound,
+        "id"                => id,
+        "index"             => index,
+        "online"            => online,
+        "relativeSource"    => relative_source,
+        "size"              => size,
+        "text"              => text,
+        "thumbnails"        => thumbnails.to_dynamic,
+        "thumbnailsBuiltAt" => thumbnails_built_at,
+        "title"             => title,
+        "type"              => database_schema_type,
+        "url"               => url,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ContentValue < Dry::Struct
+    attribute :blocks,    Types.Array(BlockElement)
+    attribute :footnotes, Types::Hash.meta(of: Types::String)
+    attribute :layout,    Types.Array(Types.Array(Types::String))
+    attribute :title,     Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        blocks:    d.fetch("blocks").map { |x| BlockElement.from_dynamic!(x) },
+        footnotes: Types::Hash[d.fetch("footnotes")].map { |k, v| [k, Types::String[v]] }.to_h,
+        layout:    d.fetch("layout"),
+        title:     d.fetch("title"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "blocks"    => blocks.map { |x| x.to_dynamic },
+        "footnotes" => footnotes,
+        "layout"    => layout,
+        "title"     => title,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DatabaseMetadataClass < Dry::Struct
+
+    # Partial is true if the database was not fully built.
+    attribute :partial, Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        partial: d.fetch("Partial"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "Partial" => partial,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Metadata < Dry::Struct
+    attribute :additional_metadata, Types::Hash.meta(of: Types::Any)
+    attribute :aliases,             Types.Array(Types::String)
+    attribute :colors,              Colors
+    attribute :database_metadata,   DatabaseMetadataClass
+    attribute :finished,            Types::String
+    attribute :made_with,           Types.Array(Types::String)
+    attribute :page_background,     Types::String
+    attribute :private,             Types::Bool
+    attribute :started,             Types::String
+    attribute :tags,                Types.Array(Types::String)
+    attribute :thumbnail,           Types::String
+    attribute :title_style,         Types::String
+    attribute :wip,                 Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        additional_metadata: Types::Hash[d.fetch("additionalMetadata")].map { |k, v| [k, Types::Any[v]] }.to_h,
+        aliases:             d.fetch("aliases"),
+        colors:              Colors.from_dynamic!(d.fetch("colors")),
+        database_metadata:   DatabaseMetadataClass.from_dynamic!(d.fetch("databaseMetadata")),
+        finished:            d.fetch("finished"),
+        made_with:           d.fetch("madeWith"),
+        page_background:     d.fetch("pageBackground"),
+        private:             d.fetch("private"),
+        started:             d.fetch("started"),
+        tags:                d.fetch("tags"),
+        thumbnail:           d.fetch("thumbnail"),
+        title_style:         d.fetch("titleStyle"),
+        wip:                 d.fetch("wip"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "additionalMetadata" => additional_metadata,
+        "aliases"            => aliases,
+        "colors"             => colors.to_dynamic,
+        "databaseMetadata"   => database_metadata.to_dynamic,
+        "finished"           => finished,
+        "madeWith"           => made_with,
+        "pageBackground"     => page_background,
+        "private"            => private,
+        "started"            => started,
+        "tags"               => tags,
+        "thumbnail"          => thumbnail,
+        "titleStyle"         => title_style,
+        "wip"                => wip,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  # AnalyzedWork represents a complete work, with analyzed mediae.
+  class DatabaseValue < Dry::Struct
+    attribute :built_at,         Types::String
+    attribute :content,          Types::Hash.meta(of: ContentValue)
+    attribute :description_hash, Types::String
+    attribute :id,               Types::String
+    attribute :metadata,         Metadata
+    attribute :partial,          Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        built_at:         d.fetch("builtAt"),
+        content:          Types::Hash[d.fetch("content")].map { |k, v| [k, ContentValue.from_dynamic!(v)] }.to_h,
+        description_hash: d.fetch("descriptionHash"),
+        id:               d.fetch("id"),
+        metadata:         Metadata.from_dynamic!(d.fetch("metadata")),
+        partial:          d.fetch("Partial"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "builtAt"         => built_at,
+        "content"         => content.map { |k, v| [k, v.to_dynamic] }.to_h,
+        "descriptionHash" => description_hash,
+        "id"              => id,
+        "metadata"        => metadata.to_dynamic,
+        "Partial"         => partial,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module Ortfodb
+    class Database
+      def self.from_json!(json)
+        Types::Hash[JSON.parse(json, quirks_mode: true)].map { |k, v| [k, DatabaseValue.from_dynamic!(v)] }.to_h
+      end
+    end
+  end
+end

data/lib/ortfodb/exporter.rb

@@ -0,0 +1,120 @@
+# This code may look unusually verbose for Ruby (and it is), but
+# it performs some subtle and complex validation of JSON data.
+#
+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+#
+#   exporter = Exporter.from_json! "{…}"
+#   puts exporter.work&.first.log&.first
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+require 'json'
+require 'dry-types'
+require 'dry-struct'
+
+module Ortfodb
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Bool   = Strict::Bool
+    Hash   = Strict::Hash
+    String = Strict::String
+  end
+
+  class ExporterSchema < Dry::Struct
+
+    # Log a message. The first argument is the verb, the second is the color, the third is the
+    # message.
+    attribute :log, Types.Array(Types::String).optional
+
+    # Run a command in a shell
+    attribute :run, Types::String.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        log: d["log"],
+        run: d["run"],
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "log" => log,
+        "run" => run,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Exporter < Dry::Struct
+
+    # Commands to run after the build finishes. Go text template that receives .Data and
+    # .Database, the built database.
+    attribute :after, Types.Array(ExporterSchema).optional
+
+    # Commands to run before the build starts. Go text template that receives .Data
+    attribute :before, Types.Array(ExporterSchema).optional
+
+    # Initial data
+    attribute :data, Types::Hash.meta(of: Types::Any).optional
+
+    # Some documentation about the exporter
+    attribute :description, Types::String
+
+    # The name of the exporter
+    attribute :exporter_name, Types::String
+
+    # List of programs that are required to be available in the PATH for the exporter to run.
+    attribute :requires, Types.Array(Types::String).optional
+
+    # If true, will show every command that is run
+    attribute :verbose, Types::Bool.optional
+
+    # Commands to run during the build, for each work. Go text template that receives .Data and
+    # .Work, the current work.
+    attribute :work, Types.Array(ExporterSchema).optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        after:         d["after"]&.map { |x| ExporterSchema.from_dynamic!(x) },
+        before:        d["before"]&.map { |x| ExporterSchema.from_dynamic!(x) },
+        data:          Types::Hash.optional[d["data"]]&.map { |k, v| [k, Types::Any[v]] }&.to_h,
+        description:   d.fetch("description"),
+        exporter_name: d.fetch("name"),
+        requires:      d["requires"],
+        verbose:       d["verbose"],
+        work:          d["work"]&.map { |x| ExporterSchema.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "after"       => after&.map { |x| x.to_dynamic },
+        "before"      => before&.map { |x| x.to_dynamic },
+        "data"        => data,
+        "description" => description,
+        "name"        => exporter_name,
+        "requires"    => requires,
+        "verbose"     => verbose,
+        "work"        => work&.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+end

data/lib/ortfodb/tags.rb

@@ -0,0 +1,105 @@
+# This code may look unusually verbose for Ruby (and it is), but
+# it performs some subtle and complex validation of JSON data.
+#
+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+#
+#   tags = Tags.from_json! "[…]"
+#   puts tags.first.detect.search.first
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+require 'json'
+require 'dry-types'
+require 'dry-struct'
+
+module Ortfodb
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Hash   = Strict::Hash
+    String = Strict::String
+  end
+
+  class Detect < Dry::Struct
+    attribute :files,     Types.Array(Types::String)
+    attribute :made_with, Types.Array(Types::String)
+    attribute :search,    Types.Array(Types::String)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        files:     d.fetch("files"),
+        made_with: d.fetch("made with"),
+        search:    d.fetch("search"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "files"     => files,
+        "made with" => made_with,
+        "search"    => search,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Tag < Dry::Struct
+    attribute :aliases,       Types.Array(Types::String)
+    attribute :description,   Types::String
+    attribute :detect,        Detect
+    attribute :learn_more_at, Types::String
+    attribute :plural,        Types::String
+    attribute :singular,      Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        aliases:       d.fetch("aliases"),
+        description:   d.fetch("description"),
+        detect:        Detect.from_dynamic!(d.fetch("detect")),
+        learn_more_at: d.fetch("learn more at"),
+        plural:        d.fetch("plural"),
+        singular:      d.fetch("singular"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "aliases"       => aliases,
+        "description"   => description,
+        "detect"        => detect.to_dynamic,
+        "learn more at" => learn_more_at,
+        "plural"        => plural,
+        "singular"      => singular,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module Ortfodb
+    class Tags
+      def self.from_json!(json)
+        tags = JSON.parse(json, quirks_mode: true).map { |x| Tag.from_dynamic!(x) }
+        tags.define_singleton_method(:to_json) do
+          JSON.generate(self.map { |x| x.to_dynamic })
+        end
+        tags
+      end
+    end
+  end
+end

data/lib/ortfodb/technologies.rb

@@ -0,0 +1,89 @@
+# This code may look unusually verbose for Ruby (and it is), but
+# it performs some subtle and complex validation of JSON data.
+#
+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
+#
+#   technologies = Technologies.from_json! "[…]"
+#   puts technologies.first.files.first
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+require 'json'
+require 'dry-types'
+require 'dry-struct'
+
+module Ortfodb
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Hash   = Strict::Hash
+    String = Strict::String
+  end
+
+  class Technology < Dry::Struct
+    attribute :aliases, Types.Array(Types::String)
+
+    # Autodetect contains an expression of the form 'CONTENT in PATH' where CONTENT is a
+    # free-form unquoted string and PATH is a filepath relative to the work folder.
+    # If CONTENT is found in PATH, we consider that technology to be used in the work.
+    attribute :autodetect, Types.Array(Types::String)
+
+    attribute :by,          Types::String
+    attribute :description, Types::String
+
+    # Files contains a list of gitignore-style patterns. If the work contains any of the
+    # patterns specified, we consider that technology to be used in the work.
+    attribute :files, Types.Array(Types::String)
+
+    attribute :learn_more_at,   Types::String
+    attribute :technology_name, Types::String
+    attribute :slug,            Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        aliases:         d.fetch("aliases"),
+        autodetect:      d.fetch("autodetect"),
+        by:              d.fetch("by"),
+        description:     d.fetch("description"),
+        files:           d.fetch("files"),
+        learn_more_at:   d.fetch("learn more at"),
+        technology_name: d.fetch("name"),
+        slug:            d.fetch("slug"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "aliases"       => aliases,
+        "autodetect"    => autodetect,
+        "by"            => by,
+        "description"   => description,
+        "files"         => files,
+        "learn more at" => learn_more_at,
+        "name"          => technology_name,
+        "slug"          => slug,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module Ortfodb
+    class Technologies
+      def self.from_json!(json)
+        technologies = JSON.parse(json, quirks_mode: true).map { |x| Technology.from_dynamic!(x) }
+        technologies.define_singleton_method(:to_json) do
+          JSON.generate(self.map { |x| x.to_dynamic })
+        end
+        technologies
+      end
+    end
+  end
+end

data/lib/ortfodb/version.rb

@@ -0,0 +1,3 @@
+module Ortfodb
+	VERSION = "1.2.0"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: ortfodb
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Ewen Le Bihan
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+description: Client library for working with ortfo/db databases. Generated from ortfo/db's
+  JSON schemas (see https://ortfo.org/db/client-libraries).
+email:
+- ortfo@ewen.works
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ortfodb/configuration.rb
+- lib/ortfodb/database.rb
+- lib/ortfodb/exporter.rb
+- lib/ortfodb/tags.rb
+- lib/ortfodb/technologies.rb
+- lib/ortfodb/version.rb
+homepage: https://ortfo.org/db
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/ortfo/db/issues
+  changelog_uri: https://github.com/ortfo/db/blob/main/CHANGELOG.md
+  documentation_uri: https://ortfo.org/db
+  homepage_uri: https://ortfo.org/db
+  source_code_uri: https://github.com/ortfo/db/tree/main/packages/ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Client library for working with ortfo/db databases
+test_files: []