tape_deck 0.1.0.beta1

data/lib/tape_deck/filter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # Narrows a diff to what one use of a tape wants compared, see "Excluding and ignoring" in {TapeDeck}.
+  #
+  # @api private
+  class Filter
+    # @param only [Array<String>, String, nil] patterns to keep, everything if nil
+    # @param ignore [Array<String>, String, nil] patterns to drop
+    def initialize(only: nil, ignore: nil)
+      @only = Array(only).map(&:to_s)
+      @ignore = Array(ignore).map(&:to_s)
+    end
+
+    # @param patterns [Array<String>] more patterns to drop
+    # @return [Filter] a copy that also drops these
+    def ignoring(patterns)
+      Filter.new(only: @only, ignore: @ignore + patterns)
+    end
+
+    # @param diff [Hash] a diff as stored on a tape
+    # @return [Hash] the diff without ignored columns, and without rows, tables and databases left empty by that
+    def apply(diff)
+      return diff if @only.empty? && @ignore.empty?
+
+      diff.each_with_object({}) do |(db_name, tables), out|
+        kept_tables = tables.each_with_object({}) do |(table, changes), kept|
+          kept_changes = filter_table("#{db_name}.#{table}", changes)
+          kept[table] = kept_changes unless kept_changes.empty?
+        end
+        out[db_name] = kept_tables unless kept_tables.empty?
+      end
+    end
+
+    private
+
+    def filter_table(table_name, changes)
+      kept = {
+        "inserted" => filter_rows(table_name, changes.fetch("inserted", [])),
+        "updated" => filter_updates(table_name, changes.fetch("updated", [])),
+        "deleted" => filter_rows(table_name, changes.fetch("deleted", []))
+      }
+      kept.reject { |_, entries| entries.empty? }
+    end
+
+    # Rows are sorted again, because their recorded order may depend on values that are now ignored.
+    def filter_rows(table_name, rows)
+      kept = rows.map { |row| filter_columns(table_name, row) }
+      kept.reject(&:empty?).sort_by(&:inspect)
+    end
+
+    # The "key" of an update is kept as it is, because it identifies the row.
+    def filter_updates(table_name, updates)
+      updates.filter_map do |update|
+        changes = filter_columns(table_name, update.fetch("changes"))
+        update.merge("changes" => changes) unless changes.empty?
+      end
+    end
+
+    def filter_columns(table_name, columns)
+      columns.select { |column, _| compare?(table_name, "#{table_name}.#{column}") }
+    end
+
+    # A column is addressed by a pattern for the column itself or one for its whole table.
+    def compare?(table_name, column_name)
+      names = [table_name, column_name]
+      return false if names.any? { Patterns.match?(@ignore, _1) }
+
+      @only.empty? || names.any? { Patterns.match?(@only, _1) }
+    end
+  end
+end

data/lib/tape_deck/patterns.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # Glob matching for table and column names, see "Patterns" in {TapeDeck}.
+  #
+  # @api private
+  module Patterns
+    # @param patterns [Array<String>]
+    # @param name [String] +"<database>.<table>"+ or +"<database>.<table>.<column>"+
+    # @return [Boolean] whether any of the patterns matches the name
+    def self.match?(patterns, name)
+      patterns.any? { File.fnmatch?(_1, name, File::FNM_EXTGLOB) }
+    end
+
+    # @param name [String]
+    # @return [String] a pattern that matches only this name
+    def self.escape(name)
+      name.gsub(/[*?\[\]{}\\]/) { "\\#{_1}" }
+    end
+  end
+end

data/lib/tape_deck/recorder.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # Snapshot of one table.
+  #
+  # @!attribute [r] checksum
+  #   @return [Integer, nil] result of +CHECKSUM TABLE+
+  # @!attribute [r] pk
+  #   @return [Array<String>] primary key columns, empty if the table has none
+  # @!attribute [r] rows
+  #   @return [Hash] +{ [pk values] => row }+ for tables with a primary key, +{ row => occurrence count }+ for tables
+  #     without one
+  # @api private
+  TableSnap = Data.define(:checksum, :pk, :rows)
+
+  # Takes snapshots of all configured databases and diffs them. Used by {Session}, but usable on its own when you don't
+  # need tape files.
+  class Recorder
+    # Database types of TIME columns, with or without fractional seconds. Sequel only types +time+ as +:time+, not
+    # +time(6)+.
+    TIME_DB_TYPE = /\Atime\b/i
+
+    # @return [Array<String>] see {Configuration#exclude_tables}
+    attr_reader :excluded_tables
+
+    # @return [Array<String>] see {Configuration#exclude_columns}
+    attr_reader :excluded_columns
+
+    # @param dbs [Hash{String => Sequel::Database}]
+    # @param exclude_tables [Array<String>] see {Configuration#exclude_tables}
+    # @param exclude_columns [Array<String>] see {Configuration#exclude_columns}
+    def initialize(dbs, exclude_tables: [], exclude_columns: [])
+      @dbs = dbs
+      @excluded_tables = exclude_tables
+      @excluded_columns = exclude_columns
+    end
+
+    # @yield the action whose database changes are recorded
+    # @return [Hash] the diff, see {#diff}
+    def record
+      before = snapshot
+      yield
+      diff(before, snapshot(previous: before))
+    end
+
+    # Reads all tables that are not excluded. With +previous:+, tables whose +CHECKSUM TABLE+ is unchanged reuse the
+    # previous snapshot, so only changed tables are read again.
+    #
+    # @param previous [Hash, nil] an earlier result of this method
+    # @return [Hash{String => Hash{String => TableSnap}}]
+    def snapshot(previous: nil)
+      @dbs.to_h do |name, db|
+        tables = checksums(db, name).to_h do |table, sum|
+          prev = previous&.dig(name, table)
+          unchanged = prev && sum && prev.checksum == sum
+          snap = if unchanged
+            prev
+          else
+            dump(db, name, table, sum)
+          end
+          [table, snap]
+        end
+        [name, tables]
+      end
+    end
+
+    # Rows are matched by primary key. Tables without one are compared as a multiset of rows (+inserted+/+deleted+
+    # only). Unchanged tables and empty sections are omitted.
+    #
+    # @param before [Hash] result of {#snapshot}
+    # @param after [Hash] result of {#snapshot}
+    # @return [Hash{String => Hash{String => Hash}}] database -> table -> +"inserted"+ / +"updated"+ / +"deleted"+
+    def diff(before, after)
+      before.keys.sort.each_with_object({}) do |db_name, out|
+        changed_tables = tables_diff(before.fetch(db_name), after.fetch(db_name))
+        out[db_name] = changed_tables unless changed_tables.empty?
+      end
+    end
+
+    # What exclude rules leave out of each database, by default the ones this recorder was created with. Reads the
+    # current schema, so other rules show what they would have left out.
+    #
+    # @param exclude_tables [Array<String>] table patterns, see {Configuration#exclude_tables}
+    # @param exclude_columns [Array<String>] column patterns, see {Configuration#exclude_columns}
+    # @return [Hash{String => Array<String>}] database -> sorted +"<table>"+ and +"<table>.<column>"+ names
+    def exclusions(exclude_tables: @excluded_tables, exclude_columns: @excluded_columns)
+      @dbs.to_h do |db_name, db|
+        tables = db.tables.map(&:to_s)
+        table_names = tables.select { Patterns.match?(exclude_tables, "#{db_name}.#{_1}") }
+        column_names = (tables - table_names).flat_map do |table|
+          excluded_column_names(db_name, table, db.schema(table.to_sym), exclude_columns).map { "#{table}.#{_1}" }
+        end
+        [db_name, (table_names + column_names).sort]
+      end
+    end
+
+    # @param db_name [String]
+    # @param name [String] +"<table>"+ or +"<table>.<column>"+, as returned by {#exclusions}
+    # @return [Boolean] whether the exclude rules leave this table or column out. Says nothing about primary keys,
+    #   which are never left out.
+    def excluded?(db_name, name)
+      patterns = if name.include?(".")
+        @excluded_columns
+      else
+        @excluded_tables
+      end
+      Patterns.match?(patterns, "#{db_name}.#{name}")
+    end
+
+    private
+
+    # Primary key columns are never excluded, because rows are matched by them.
+    #
+    # @return [Array<Symbol>]
+    def excluded_column_names(db_name, table, schema, patterns = @excluded_columns)
+      schema.filter_map do |col, info|
+        col if !info[:primary_key] && Patterns.match?(patterns, "#{db_name}.#{table}.#{col}")
+      end
+    end
+
+    # Diffs one database. A table missing on one side (created or dropped by the action) counts as empty there.
+    def tables_diff(before, after)
+      (before.keys | after.keys).sort.each_with_object({}) do |table, out|
+        b, a = before[table], after[table]
+        next if b.equal?(a) # checksum unchanged, snapshot reused
+
+        changes = table_diff(b || empty_like(a), a || empty_like(b))
+        out[table] = changes unless changes.empty?
+      end
+    end
+
+    # @return [Hash{String => Integer, nil}] table name -> checksum
+    def checksums(db, name)
+      tables = db.tables.map(&:to_s).sort.reject { excluded?(name, _1) }
+      return {} if tables.empty?
+
+      list = tables.map { db.literal(Sequel.identifier(_1)) }.join(", ")
+      db.fetch("CHECKSUM TABLE #{list}").to_h do |r|
+        _db_name, table = r[:Table].split(".", 2) # MySQL reports "<db>.<table>"
+        [table, r[:Checksum]]
+      end
+    end
+
+    # @return [TableSnap]
+    def dump(db, name, table, sum)
+      schema = db.schema(table.to_sym)
+      pk = schema.select { |_, i| i[:primary_key] }.map(&:first)
+      types = schema.to_h { |col, i| [col, column_type(i)] }
+
+      drop = excluded_column_names(name, table, schema)
+
+      ds = db[table.to_sym]
+      ds = ds.order(*pk) unless pk.empty?
+
+      rows = {}
+      ds.each do |r|
+        row = r.except(*drop).to_h { |col, v| [col.to_s, serialize(v, types[col])] }
+        if pk.empty?
+          rows[row] = rows.fetch(row, 0) + 1
+        else
+          rows[pk.map { serialize(r[_1], types[_1]) }] = row
+        end
+      end
+      TableSnap.new(checksum: sum, pk: pk.map(&:to_s), rows: rows)
+    end
+
+    # @param info [Hash] column info from +db.schema+
+    # @return [Symbol, nil] Sequel's column type, +:time+ for all TIME columns, see {TIME_DB_TYPE}
+    def column_type(info)
+      if TIME_DB_TYPE.match?(info[:db_type].to_s)
+        :time
+      else
+        info[:type]
+      end
+    end
+
+    def empty_like(snap) = TableSnap.new(checksum: nil, pk: snap.pk, rows: {})
+
+    def table_diff(b, a)
+      if b.pk.empty?
+        multiset_diff(b.rows, a.rows)
+      else
+        keyed_diff(b, a)
+      end
+    end
+
+    def keyed_diff(b, a)
+      inserted = (a.rows.keys - b.rows.keys).map { a.rows[_1] }
+      deleted = (b.rows.keys - a.rows.keys).map { b.rows[_1] }
+      updated = (a.rows.keys & b.rows.keys).filter_map do |k|
+        old, new = b.rows[k], a.rows[k]
+        next if old == new
+
+        {"key" => a.pk.zip(k).to_h, "changes" => changed_columns(old, new)}
+      end
+      compact("inserted" => inserted, "updated" => updated, "deleted" => deleted)
+    end
+
+    # @return [Hash{String => Array(Object, Object)}] column -> +[old, new]+ for columns whose value differs
+    def changed_columns(old, new)
+      (old.keys | new.keys).each_with_object({}) do |col, changes|
+        changes[col] = [old[col], new[col]] unless old[col] == new[col]
+      end
+    end
+
+    def multiset_diff(b, a)
+      inserted, deleted = [], []
+      (b.keys | a.keys).each do |row|
+        delta = a.fetch(row, 0) - b.fetch(row, 0)
+        if delta.positive?
+          inserted.concat([row] * delta)
+        elsif delta.negative?
+          deleted.concat([row] * delta.abs)
+        end
+      end
+      compact("inserted" => sort_rows(inserted), "deleted" => sort_rows(deleted))
+    end
+
+    def sort_rows(rows) = rows.sort_by(&:inspect)
+    def compact(h) = h.reject { |_, v| v.empty? }
+
+    # Converts a column value to a YAML-stable scalar. +type+ is the column type from +db.schema+.
+    def serialize(v, type = nil)
+      case v
+      when String then maybe_utf8(v)
+      when BigDecimal then v.to_s("F")
+      when Sequel::SQLTime then time_of_day(v)
+      when Time then timestamp(v, type)
+      when Date then v.iso8601
+      else v # Integer, Float, true/false, nil
+      end
+    end
+
+    # mysql2 returns TIME columns as a +Time+ on 2000-01-01, not as +Sequel::SQLTime+. Those keep their local time of
+    # day, because converting them to UTC would shift the hour.
+    def timestamp(v, type)
+      if type == :time
+        time_of_day(v)
+      else
+        v.utc.iso8601(6)
+      end
+    end
+
+    def time_of_day(v) = v.strftime("%H:%M:%S.%6N")
+
+    # Small binaries encode as hex. Large ones are shown as a digest so the YAML stays small.
+    def bin(v)
+      if v.bytesize <= 64
+        "0x#{v.unpack1("H*")}"
+      else
+        "sha256:#{Digest::SHA256.hexdigest(v)}"
+      end
+    end
+
+    # BINARY, VARBINARY and BLOB columns arrive as ASCII-8BIT strings (or Sequel::SQL::Blob, depending on the adapter).
+    # Ones that hold valid UTF-8 become plain UTF-8 strings, because YAML would otherwise store them as base64
+    # (+!binary+). Everything else goes through {#bin}.
+    def maybe_utf8(v)
+      binary = v.encoding == Encoding::BINARY || v.is_a?(Sequel::SQL::Blob)
+      return v unless binary
+
+      utf8 = String.new(v, encoding: Encoding::UTF_8)
+      if utf8.valid_encoding?
+        utf8
+      else
+        bin(v)
+      end
+    end
+  end
+end

data/lib/tape_deck/session.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # One run of one tape: takes the "before" snapshot when created, and on {#finish} captures the diff and records it
+  # to the tape or verifies it against the tape.
+  #
+  # @api private
+  class Session
+    # @return [Tape]
+    attr_reader :tape
+
+    # @param tape [Tape]
+    # @param recorder [Recorder]
+    # @param filter [Filter] narrows what is compared when verifying
+    # @param on_schema_change [Symbol] see {Configuration#on_schema_change}
+    def initialize(tape, recorder, filter, on_schema_change: :error)
+      @tape = tape
+      @recorder = recorder
+      @filter = filter
+      @on_schema_change = on_schema_change
+      @before = recorder.snapshot
+    end
+
+    # @param discard [Boolean] neither record nor verify, e.g. because the block failed
+    # @return [void]
+    # @raise [UnexpectedDiffError] if verifying and the diff does not match the tape
+    # @raise [IncompatibleTapeError] if verifying and the tape lacks data that is no longer excluded, or the schema
+    #   changed and {Configuration#on_schema_change} is +:error+
+    # @raise [TapeLoadingError] if verifying and the tape cannot be read, see {Tape#read}
+    def finish(discard: false)
+      return if discard
+
+      after = @recorder.snapshot(previous: @before)
+      actual = round_trip(@recorder.diff(@before, after))
+      exclusions = @recorder.exclusions
+      if tape.recording?
+        tape.write(actual, recorded: {
+          "exclude_tables" => @recorder.excluded_tables,
+          "exclude_columns" => @recorder.excluded_columns,
+          "databases" => exclusions
+        })
+      else
+        verify(actual, exclusions)
+      end
+    end
+
+    private
+
+    # @return [Hash] the diff with the same shape as a tape read from disk
+    def round_trip(diff) = YAML.safe_load(Tape.serialize(diff))
+
+    # Compares the watched databases only. What is excluded now, but is on the tape, is dropped from both sides.
+    def verify(actual, exclusions)
+      recorded = tape.read.fetch("recorded")
+      tape_exclusions = recorded.fetch("databases").slice(*exclusions.keys)
+      report_schema_changes(recorded, tape_exclusions)
+      filter = @filter.ignoring(newly_excluded(tape_exclusions, exclusions))
+      expected = filter.apply(tape.read.fetch("diff").slice(*exclusions.keys))
+      actual = filter.apply(actual)
+      raise UnexpectedDiffError.new(tape, expected, actual) unless expected == actual
+    end
+
+    # The recorded exclude rules, applied to the current schema, must leave out what they did when recording.
+    def report_schema_changes(recorded, tape_exclusions)
+      return if @on_schema_change == :ignore
+
+      now = @recorder.exclusions(
+        exclude_tables: recorded.fetch("exclude_tables"),
+        exclude_columns: recorded.fetch("exclude_columns")
+      )
+      changes = tape_exclusions.filter_map do |db_name, names|
+        added = now.fetch(db_name) - names
+        removed = names - now.fetch(db_name)
+        "#{db_name}: added #{added.inspect}, removed #{removed.inspect}" unless added.empty? && removed.empty?
+      end
+      return if changes.empty?
+
+      message = "schema changed since tape #{tape.file} was recorded, its exclude rules now match " \
+        "other tables or columns (#{changes.join(", ")})"
+      raise IncompatibleTapeError, message if @on_schema_change == :error
+
+      warn "TapeDeck: #{message}"
+    end
+
+    # @return [Array<String>] patterns for what is excluded now, but was recorded on the tape
+    # @raise [IncompatibleTapeError] if the tape left out something that is no longer excluded
+    def newly_excluded(tape_exclusions, exclusions)
+      exclusions.flat_map do |db_name, names|
+        tape_names = tape_exclusions.fetch(db_name)
+        no_longer_excluded = tape_names.reject { @recorder.excluded?(db_name, _1) }
+        unless no_longer_excluded.empty?
+          raise IncompatibleTapeError, "tape #{tape.file} left out #{no_longer_excluded.inspect} of #{db_name}, " \
+            "which is no longer excluded. Re-record the tape."
+        end
+
+        (names - tape_names).map { Patterns.escape("#{db_name}.#{_1}") }
+      end
+    end
+  end
+end

data/lib/tape_deck/tape.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # One recorded diff, stored as a YAML file. Like a +File+, a tape knows where it lives, whether it is there to be
+  # recorded or verified, and how to read and write itself. It never touches a database.
+  #
+  # Next to the diff, a tape stores what was recorded: the exclude rules, the watched databases, and per database the
+  # tables and columns the rules left out. Empty lists are left out of the file.
+  #
+  #   recorded:
+  #     exclude_tables: [shop.sessions]
+  #     exclude_columns: ["*.created_at"]
+  #     databases:
+  #       shop:
+  #         excluded: [orders.created_at, sessions]
+  #       billing:
+  #   diff:
+  #     shop:
+  #       orders:
+  #         inserted: [...]
+  class Tape
+    # Lists in the +recorded+ section of a tape file, written on one line.
+    RECORDED_LISTS = %w[exclude_tables exclude_columns excluded].freeze
+
+    # Supported values for the +:record+ option:
+    # [+:once+]      record if the tape file is missing, otherwise verify
+    # [+:verify+]    verify only, never record. A missing tape raises {TapeLoadingError}
+    # [+:overwrite+] always record, replacing an existing tape
+    RECORD_MODES = %i[once verify overwrite].freeze
+
+    # Characters in a tape name that are replaced with +_+ in its file name.
+    UNSAFE_FILE_NAME_CHARS = %r{[^\w\-/]+}
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Symbol] one of {RECORD_MODES}
+    attr_reader :record_mode
+
+    # @param diff [Hash] a diff as returned by {Recorder#diff}
+    # @return [String] the YAML stored in a tape file
+    def self.serialize(diff) = YAML.dump(diff, line_width: -1)
+
+    # @param mode [Symbol]
+    # @return [void]
+    # @raise [ArgumentError] unless the mode is one of {RECORD_MODES}
+    def self.validate_record_mode(mode)
+      return if RECORD_MODES.include?(mode)
+
+      raise ArgumentError, "invalid record mode #{mode.inspect}, use one of #{RECORD_MODES.inspect}"
+    end
+
+    # Like {.serialize}, but writes the {RECORDED_LISTS} on one line, so the +recorded+ section stays short.
+    #
+    # @param content [Hash] see {#read}
+    # @return [String] the YAML stored in a tape file
+    def self.dump(content)
+      tree = Psych::Visitors::YAMLTree.create(line_width: -1)
+      tree << content
+      tree.tree.each do |node|
+        next unless node.is_a?(Psych::Nodes::Mapping)
+
+        node.children.each_slice(2) do |key, value|
+          recorded_list = RECORDED_LISTS.include?(key.value) && value.is_a?(Psych::Nodes::Sequence)
+          value.style = Psych::Nodes::Sequence::FLOW if recorded_list
+        end
+      end
+      tree.tree.yaml(nil, line_width: -1)
+    end
+
+    # @param name [String] tape name, may contain +/+ to create subdirectories
+    # @param record [Symbol] one of {RECORD_MODES}, defaults to {Configuration#default_record_mode}
+    # @raise [ArgumentError] for an unknown record mode
+    # @raise [TapeLoadingError] if the tape must be verified but does not exist
+    def initialize(name, record: TapeDeck.configuration.default_record_mode)
+      self.class.validate_record_mode(record)
+      @name = name.to_s
+      @record_mode = record
+
+      tape_exists = File.exist?(file)
+      raise TapeLoadingError, "no tape at #{file} (record mode :verify)" if @record_mode == :verify && !tape_exists
+
+      @recording = @record_mode == :overwrite || !tape_exists
+    end
+
+    # @return [Boolean] whether the tape is to be written
+    def recording? = @recording
+
+    # @return [Boolean] whether the tape is to be read and compared
+    def verifying? = !recording?
+
+    # @return [String] path of the tape file, see {#file_name}
+    def file
+      File.join(TapeDeck.configuration.tape_library_dir, file_name)
+    end
+
+    # @return [String] the tape name with {UNSAFE_FILE_NAME_CHARS} replaced, plus +.yml+
+    def file_name
+      "#{name.gsub(UNSAFE_FILE_NAME_CHARS, "_")}.yml"
+    end
+
+    # Reads the tape file once, later calls return the same content.
+    #
+    # @return [Hash] +"recorded"+: see {#write}, and +"diff"+: the stored diff
+    # @raise [TapeLoadingError] if the file is not valid YAML or does not hold a recording
+    def read
+      @content ||= load
+    end
+
+    # @param diff [Hash] the diff to store in the tape file, replacing its content
+    # @param recorded [Hash] +"exclude_tables"+ and +"exclude_columns"+: the exclude rules, +"databases"+: database ->
+    #   names the rules left out of it, as returned by {Recorder#exclusions}
+    # @return [void]
+    def write(diff, recorded:)
+      databases = recorded.fetch("databases").transform_values do |names|
+        {"excluded" => names} unless names.empty?
+      end
+      patterns = recorded.slice("exclude_tables", "exclude_columns").reject { |_, list| list.empty? }
+      FileUtils.mkdir_p(File.dirname(file))
+      File.write(file, self.class.dump("recorded" => {**patterns, "databases" => databases}, "diff" => diff))
+      @content = nil
+    end
+
+    private
+
+    def load
+      content = YAML.safe_load_file(file)
+      raise TapeLoadingError, "tape #{file} does not hold a recording" unless valid_content?(content)
+
+      recorded = content["recorded"]
+      databases = recorded["databases"].transform_values { Array(_1&.dig("excluded")) }
+      {
+        "recorded" => {
+          "exclude_tables" => Array(recorded["exclude_tables"]),
+          "exclude_columns" => Array(recorded["exclude_columns"]),
+          "databases" => databases
+        },
+        "diff" => content["diff"]
+      }
+    rescue Psych::Exception => e
+      raise TapeLoadingError, "cannot load tape #{file}: #{e.message}"
+    end
+
+    def valid_content?(content)
+      return false unless content.is_a?(Hash) && content["diff"].is_a?(Hash)
+
+      recorded = content["recorded"]
+      databases = recorded["databases"] if recorded.is_a?(Hash)
+      databases.is_a?(Hash) && databases.values.all? { _1.nil? || _1.is_a?(Hash) }
+    end
+  end
+end

data/lib/tape_deck/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # Version of the gem.
+  VERSION = "0.1.0.beta1"
+end