power-hours 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 120c0ef0265c61867c8bcf0d6506442e50f4ecad7037b3663f3f355dfc9fe605
+  data.tar.gz: 3e39ab4635b914147372f6ad1aad6d03bd5c9f20006d5262fa7cb9b8f9b62152
+SHA512:
+  metadata.gz: '09bbc89cd542d4231045c51cdeb34b0cc585752c5e91c81f4ffcfcbc6ec52753731639c22c21e319868342744223eb24b4753b6efac584bc394197219526886c'
+  data.tar.gz: a6553f5ac3a66a4fc637c1c470eee3c36dd9fe648c88d19a7d0ea71e90e107ca0781cc653658905f89223b79f5ad8e2d20244048d6e337cb0d6795469306e467

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Max Power
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+# Power Hours
+
+Power Hours provides a small, explicit DSL for weekly opening-hours schedules.
+
+It supports:
+- multiple windows per day
+- overnight windows (for example `22:00-02:00`)
+- serialization to/from hashes
+- optional model mixin helpers via `OpeningHours::Model`
+
+## Installation
+
+```bash
+bundle add power-hours
+```
+
+or
+
+```bash
+gem install power-hours
+```
+
+## Usage
+
+### Build a schedule
+
+```ruby
+require "opening_hours"
+
+schedule = OpeningHours::Schedule.build do
+  mon "09:00".."12:00", "13:00".."17:00"
+  fri "22:00".."02:00"
+end
+
+schedule.open?(at: Time.new(2024, 1, 1, 10, 0, 0)) # => true (Monday)
+schedule.open?(at: Time.new(2024, 1, 6, 1, 0, 0))  # => true (Saturday, from Friday overnight)
+```
+
+### Construct directly from hash data
+
+```ruby
+schedule = OpeningHours::Schedule.from_hash(
+  "mon" => ["09:00-17:00"],
+  "fri" => ["22:00-02:00"]
+)
+```
+
+### Serialize for persistence
+
+```ruby
+schedule.to_h
+# {
+#   sun: [],
+#   mon: ["09:00-17:00"],
+#   tue: [],
+#   wed: [],
+#   thu: [],
+#   fri: ["22:00-02:00"],
+#   sat: []
+# }
+
+schedule.as_json
+# {
+#   mon: ["09:00-17:00"],
+#   fri: ["22:00-02:00"]
+# }
+
+schedule.as_json(include_empty: true) # include empty weekdays too
+```
+
+### Optional mixin for app models
+
+`OpeningHours::Model` is a Rails integration mixin (uses typed attributes).
+
+```ruby
+class Venue < ApplicationRecord
+  include OpeningHours::Model
+  # expects an `opening_hours` attribute (for example json/jsonb)
+end
+
+venue = Venue.new
+venue.define_hours do
+  mon "09:00".."17:00"
+end
+
+venue.open?(at: Time.new(2024, 1, 1, 10, 0, 0)) # => true
+```
+
+### Use a custom backing column
+
+```ruby
+class Venue < ApplicationRecord
+  include OpeningHours::Model
+  opening_hours_column :business_hours
+end
+```
+
+### Use the value type directly
+
+```ruby
+class Venue < ApplicationRecord
+  attribute :opening_hours, OpeningHours::Type.new
+end
+```
+
+## Development
+
+```bash
+bin/setup
+bundle exec rake test
+bundle exec gem build power-hours.gemspec
+```
+
+## License
+
+Released under the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/examples/opening_hours.html

@@ -0,0 +1,275 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Opening Hours Multi-Window Test</title>
+    <style>
+      :root {
+        --paper: #f8fafc;
+        --ink: #1f2937;
+        --muted: #6b7280;
+        --line: #e5e7eb;
+        --panel: #ffffff;
+        --accent: #4f46e5;
+        --danger: #b91c1c;
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        padding: 16px 12px;
+        font-family: "Avenir Next", "Segoe UI", sans-serif;
+        color: var(--ink);
+        background: var(--paper);
+        accent-color: var(--accent);
+      }
+
+      .playground-grid {
+        max-width: 980px;
+        margin: 0 auto;
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 12px;
+        align-items: start;
+      }
+
+      .hours-editor {
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: 10px;
+        padding: 12px;
+        box-shadow: 0 3px 10px rgba(17, 24, 39, 0.06);
+      }
+
+      .editor-header {
+        margin-bottom: 10px;
+        border-bottom: 1px solid var(--line);
+        padding-bottom: 8px;
+      }
+
+      .editor-header h2 {
+        margin: 0;
+        font-size: 1.05rem;
+        letter-spacing: 0.01em;
+      }
+
+      .editor-header p {
+        margin: 4px 0 0;
+        color: var(--muted);
+        font-size: 0.82rem;
+      }
+
+      .day-card {
+        border-bottom: 1px solid var(--line);
+        padding: 8px 0;
+        margin-bottom: 0;
+        background: transparent;
+      }
+
+      .day-grid {
+        display: grid;
+        grid-template-columns: 120px minmax(0, 1fr);
+        gap: 8px;
+        align-items: start;
+      }
+
+      .day-label {
+        font-weight: 700;
+        text-transform: none;
+        font-size: 0.78rem;
+        letter-spacing: 0.01em;
+        color: #374151;
+      }
+
+      .day-content {
+        min-width: 0;
+      }
+
+      .window-row {
+        display: flex;
+        width: fit-content;
+        align-items: stretch;
+        gap: 0;
+        margin-bottom: 6px;
+        border-radius: 7px;
+      }
+
+      .time-range {
+        display: inline-flex;
+        align-items: center;
+        border: 1px solid #cbd5e1;
+        border-right: 0;
+        border-radius: 7px 0 0 7px;
+        background: #fff;
+        overflow: hidden;
+      }
+
+      .time-range input[type="time"] {
+        width: fit-content;
+        padding: 5px 6px;
+        border: 0;
+        border-radius: 0;
+        background: transparent;
+        font-family: "SFMono-Regular", Consolas, monospace;
+        font-size: 0.78rem;
+      }
+
+      .window-row:focus-within {
+        box-shadow: 0 0 0 2px rgba(79, 70, 229, 0.2);
+      }
+
+      .window-row:focus-within .time-range,
+      .window-row:focus-within .btn-remove {
+        border-color: var(--accent);
+      }
+
+      .window-sep {
+        padding: 0 2px;
+        color: #6b7280;
+        font-weight: 700;
+      }
+
+      .btn {
+        border: 1px solid transparent;
+        border-radius: 6px;
+        padding: 4px 8px;
+        cursor: pointer;
+        font-size: 0.72rem;
+        font-weight: 600;
+      }
+
+      .btn-add {
+        border: 1px solid #cbd5e1;
+        border-radius: 999px;
+        background: #fff;
+        padding: 2px 8px;
+        color: #4b5563;
+        font-size: 0.74rem;
+        font-weight: 600;
+        text-decoration: none;
+      }
+
+      .btn-add:hover {
+        color: #374151;
+        border-color: #9ca3af;
+        background: #f9fafb;
+      }
+
+      .btn-remove {
+        padding: 0 8px;
+        border-radius: 0 7px 7px 0;
+        border-color: #d1d5db;
+        background: #fff;
+        color: #6b7280;
+        font-size: 0.9rem;
+        line-height: 1;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        align-self: stretch;
+      }
+
+      .btn-remove:hover {
+        color: #374151;
+        border-color: #9ca3af;
+        background: #f9fafb;
+      }
+
+      .day-actions {
+        margin-top: 4px;
+        display: flex;
+        justify-content: flex-start;
+      }
+
+      .debug-panel {
+        padding: 10px;
+        background: #111827;
+        color: #d1d5db;
+        border-radius: 8px;
+        border: 1px solid #374151;
+      }
+
+      .debug-panel strong {
+        display: block;
+        margin-bottom: 6px;
+        color: #f3f4f6;
+      }
+
+      .debug-tools {
+        margin-bottom: 8px;
+        font-size: 0.75rem;
+      }
+
+      .debug-tools label {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.4rem;
+        color: #cbd5e1;
+        cursor: pointer;
+      }
+
+      pre {
+        margin: 0;
+        white-space: pre-wrap;
+        font-size: 0.75rem;
+      }
+
+      @media (max-width: 900px) {
+        .playground-grid {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      @media (max-width: 700px) {
+        .day-grid {
+          grid-template-columns: 1fr;
+          gap: 6px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div data-controller="opening-hours">
+      <div class="playground-grid">
+        <div class="hours-editor">
+          <div class="editor-header">
+            <h2>Business Availability</h2>
+            <p>
+              Multiple time windows per day, directly mapped to Schedule ranges.
+            </p>
+          </div>
+
+          <div id="hours-container" data-opening-hours-target="container"></div>
+        </div>
+
+        <div class="debug-panel">
+          <strong
+            >Rails Params Payload (business[opening_hours][day][])
+          </strong>
+          <div class="debug-tools">
+            <label>
+              <input
+                type="checkbox"
+                data-opening-hours-target="includeEmpty"
+                data-action="change->opening-hours#refreshPayload"
+              />
+              Include empty weekdays in payload
+            </label>
+          </div>
+          <pre data-opening-hours-target="debugOutput">{}</pre>
+        </div>
+      </div>
+    </div>
+
+    <script src="https://unpkg.com/@hotwired/stimulus/dist/stimulus.umd.js"></script>
+    <script src="./opening_hours_controller.js"></script>
+    <script>
+      const application = Stimulus.Application.start();
+      application.register("opening-hours", window.OpeningHoursController);
+    </script>
+  </body>
+</html>

data/examples/opening_hours_controller.js

@@ -0,0 +1,175 @@
+(function () {
+  const DAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+
+  class OpeningHoursController extends Stimulus.Controller {
+    static targets = ["container", "debugOutput", "includeEmpty"];
+
+    connect() {
+      this.nextId = 1;
+      this.state = Object.fromEntries(DAYS.map((day) => [day, []]));
+      this.weekdayFormatter = new Intl.DateTimeFormat(undefined, { weekday: "long" });
+
+      this.insertWindow("mon", "09:00", "12:00");
+      this.insertWindow("mon", "13:00", "17:00");
+      this.insertWindow("fri", "22:00", "02:00");
+
+      this.render();
+    }
+
+    addWindow(event) {
+      this.insertWindow(event.currentTarget.dataset.day);
+      this.render();
+    }
+
+    removeWindow(event) {
+      const row = event.currentTarget.closest(".window-row");
+      if (!row) return;
+
+      const day = row.dataset.day;
+      const id = Number(row.dataset.id);
+      this.state[day] = this.state[day].filter((window) => window.id !== id);
+      this.render();
+    }
+
+    updateWindow(event) {
+      const input = event.currentTarget;
+      const row = input.closest(".window-row");
+      if (!row) return;
+
+      const day = row.dataset.day;
+      const id = Number(row.dataset.id);
+      const window = this.state[day].find((item) => item.id === id);
+      if (!window) return;
+
+      window[input.dataset.field] = input.value;
+      this.renderPayload();
+    }
+
+    refreshPayload() {
+      this.renderPayload();
+    }
+
+    insertWindow(day, start = "09:00", end = "17:00") {
+      this.state[day].push({ id: this.nextId++, start, end });
+    }
+
+    isComplete(window) {
+      return Boolean(window.start && window.end);
+    }
+
+    toRangeString(window) {
+      return `${window.start}-${window.end}`;
+    }
+
+    buildOpeningHours(includeEmpty) {
+      const openingHours = {};
+
+      DAYS.forEach((day) => {
+        const ranges = this.state[day]
+          .filter((window) => this.isComplete(window))
+          .map((window) => this.toRangeString(window));
+
+        if (includeEmpty || ranges.length > 0) {
+          openingHours[day] = ranges;
+        }
+      });
+
+      return openingHours;
+    }
+
+    formatDayLabel(day) {
+      try {
+        const index = DAYS.indexOf(day);
+        if (index < 0) return day;
+
+        // Jan 1, 2024 is a Monday; use local noon to avoid TZ rollover.
+        const date = new Date(2024, 0, 1 + index, 12, 0, 0, 0);
+        return this.weekdayFormatter.format(date);
+      } catch (_error) {
+        return day;
+      }
+    }
+
+    dayMarkup(day) {
+      const windows = this.state[day];
+
+      const windowsMarkup = windows
+        .map((window) => {
+          return `
+            <div class="window-row" data-day="${day}" data-id="${window.id}">
+              <div class="time-range">
+                <input
+                  type="time"
+                  step="900"
+                  value="${window.start}"
+                  data-field="start"
+                  data-action="input->opening-hours#updateWindow"
+                />
+                <span class="window-sep">&ndash;</span>
+                <input
+                  type="time"
+                  step="900"
+                  value="${window.end}"
+                  data-field="end"
+                  data-action="input->opening-hours#updateWindow"
+                />
+              </div>
+              <button
+                type="button"
+                class="btn btn-remove"
+                data-action="click->opening-hours#removeWindow"
+                aria-label="Remove window"
+                title="Remove window"
+              >
+                ×
+              </button>
+            </div>
+          `;
+        })
+        .join("");
+
+      const addButtonMarkup = `
+        <button
+          type="button"
+          class="btn btn-add"
+          data-day="${day}"
+          data-action="click->opening-hours#addWindow"
+        >
+          + add window
+        </button>
+      `;
+
+      const bodyMarkup =
+        windows.length === 0
+          ? `<div class="day-actions">${addButtonMarkup}</div>`
+          : `${windowsMarkup}<div class="day-actions">${addButtonMarkup}</div>`;
+
+      return `
+        <section class="day-card" data-day-card="${day}">
+          <div class="day-grid">
+            <span class="day-label">${this.formatDayLabel(day)}</span>
+            <div class="day-content">${bodyMarkup}</div>
+          </div>
+        </section>
+      `;
+    }
+
+    renderPayload() {
+      const includeEmpty = this.includeEmptyTarget.checked;
+      const payload = {
+        business: {
+          opening_hours: this.buildOpeningHours(includeEmpty),
+        },
+      };
+
+      this.debugOutputTarget.textContent = JSON.stringify(payload, null, 2);
+    }
+
+    render() {
+      this.containerTarget.innerHTML = DAYS.map((day) => this.dayMarkup(day)).join("");
+      this.renderPayload();
+    }
+  }
+
+  window.OpeningHoursController = OpeningHoursController;
+})();

data/lib/opening_hours/builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OpeningHours
+  class Builder
+    attr_reader :schedule
+
+    def initialize
+      @schedule = Schedule.new
+    end
+
+    Schedule.members.each do |day|
+      define_method(day) do |*ranges|
+        windows = ranges.map { |range| TimeWindow[range] }.freeze
+        @schedule = @schedule.with(day => windows)
+      end
+    end
+  end
+end

data/lib/opening_hours/model.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/time"
+
+module OpeningHours
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :opening_hours_column_name, instance_accessor: false, default: :opening_hours
+      register_opening_hours_attribute!
+      delegate :opening_hours_column, to: :class
+    end
+
+    class_methods do
+      def opening_hours_column(name = nil)
+        unless name.nil?
+          self.opening_hours_column_name = name.to_sym
+          register_opening_hours_attribute!
+        end
+
+        opening_hours_column_name
+      end
+
+      private
+
+      def register_opening_hours_attribute!
+        attribute(opening_hours_column_name, OpeningHours::Type.new, default: -> { OpeningHours::Schedule.new })
+      end
+    end
+
+    def define_hours(&block)
+      OpeningHours::Schedule.build(&block).tap do |schedule|
+        public_send(:"#{opening_hours_column}=", schedule)
+      end
+    end
+
+    def open?(at: Time.current)
+      zone = respond_to?(:timezone) ? timezone.presence : nil
+      public_send(opening_hours_column).open?(at: zone ? at.in_time_zone(zone) : at)
+    end
+  end
+end

data/lib/opening_hours/schedule.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpeningHours
+  class Schedule < Data.define(:sun, :mon, :tue, :wed, :thu, :fri, :sat)
+    class << self
+      def build(&block)
+        return new unless block_given?
+
+        builder = Builder.new
+        builder.instance_eval(&block)
+        builder.schedule
+      end
+
+      def from_hash(hash)
+        new(**hash.to_h.transform_keys(&:to_sym))
+      end
+    end
+
+    def initialize(mon: [], tue: [], wed: [], thu: [], fri: [], sat: [], sun: [])
+      super(
+        sun: normalize_day(sun),
+        mon: normalize_day(mon),
+        tue: normalize_day(tue),
+        wed: normalize_day(wed),
+        thu: normalize_day(thu),
+        fri: normalize_day(fri),
+        sat: normalize_day(sat)
+      )
+    end
+
+    def open?(at: Time.now)
+      current_time = at.strftime("%H:%M")
+      windows_to_check(at).any? { |window| window.cover?(current_time) }
+    end
+
+    def to_h
+      super.transform_values { |windows| windows.map(&:to_s) }
+    end
+
+    def as_json(options = nil)
+      include_empty = options.is_a?(Hash) && options[:include_empty]
+      include_empty ? to_h : to_h.reject { |_day, windows| windows.empty? }
+    end
+
+    private
+
+    def normalize_day(values)
+      Array(values).map { TimeWindow[it] }.freeze
+    end
+
+    # Check current day windows + previous day's overnight leftovers
+    def windows_to_check(time)
+      curr_day = members[time.wday]
+      prev_day = members[(time.wday - 1) % 7]
+
+      public_send(curr_day) + public_send(prev_day).select(&:overnight?)
+    end
+  end
+end

data/lib/opening_hours/time_of_day.rb

@@ -0,0 +1,50 @@
+module OpeningHours
+  class TimeOfDay
+    include Comparable
+    REGEX = /\A(\d{1,2})(?::(\d{1,2}))?\z/.freeze
+
+    def self.[](input)
+      input.is_a?(self) ? input : new(input)
+    end
+
+    attr_reader :hour, :min
+
+    def initialize(input)
+      case input
+      in Time
+        @hour = input.hour
+        @min  = input.min
+      else
+        @hour, @min = parse(input)
+      end
+
+      validate!
+    end
+
+    def <=>(other)
+      to_minutes <=> TimeOfDay[other].to_minutes
+    end
+
+    def to_minutes
+      hour * 60 + min
+    end
+
+    def to_s
+      format("%02d:%02d", hour, min)
+    end
+
+    private
+
+    def parse(input)
+      match = REGEX.match(input.to_s.strip)
+      raise ArgumentError, "Invalid time: #{input.inspect}" unless match
+
+      [match[1].to_i, (match[2] || 0).to_i]
+    end
+
+    def validate!
+      raise ArgumentError unless hour.between?(0, 23)
+      raise ArgumentError unless min.between?(0, 59)
+    end
+  end
+end

data/lib/opening_hours/time_window.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module OpeningHours
+  class TimeWindow < Data.define(:opens, :closes)
+    def self.[](input)
+      case input
+      in TimeWindow => tw
+        tw
+      in Range => r
+        new(r.begin, r.end)
+      in [opens, closes]
+        new(opens, closes)
+      in String => s if s.include?("-")
+        new(*s.split("-", 2))
+      else
+        raise ArgumentError, "Cannot build TimeWindow from #{input.inspect}"
+      end
+    end
+
+    def initialize(opens:, closes:)
+      opens  = TimeOfDay[opens]
+      closes = TimeOfDay[closes]
+      super
+    end
+
+    def to_a = deconstruct
+    def to_s = deconstruct.uniq.join("-")
+
+    def overnight?
+      closes < opens
+    end
+
+    def cover?(value)
+      time = TimeOfDay[value]
+
+      if overnight?
+        time >= opens || time <= closes
+      else
+        time >= opens && time <= closes
+      end
+    end
+  end
+end

data/lib/opening_hours/type.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module OpeningHours
+  class Type < ActiveModel::Type::Value
+    def type
+      :opening_hours
+    end
+
+    def cast(value)
+      coerce(value)
+    end
+
+    def serialize(value)
+      coerce(value).as_json(include_empty: false)
+    end
+
+    def changed_in_place?(raw_old_value, new_value)
+      deserialize(raw_old_value) != cast(new_value)
+    end
+
+    private
+
+    def coerce(value)
+      case value
+      in nil
+        OpeningHours::Schedule.new
+      in OpeningHours::Schedule => schedule
+        schedule
+      in Hash => hash
+        OpeningHours::Schedule.from_hash(hash)
+      in candidate if (hash = hash_from(candidate))
+        OpeningHours::Schedule.from_hash(hash)
+      else
+        raise ArgumentError, "Cannot cast #{value.inspect} to OpeningHours::Schedule"
+      end
+    end
+
+    def hash_from(value)
+      return unless value.respond_to?(:to_h)
+
+      hash = value.to_h
+      hash if hash.is_a?(Hash)
+    end
+  end
+end

data/lib/opening_hours/version.rb

@@ -0,0 +1,3 @@
+module OpeningHours
+  VERSION = "0.1.0"
+end

data/lib/opening_hours.rb

@@ -0,0 +1,9 @@
+module OpeningHours
+  require_relative "opening_hours/version"
+  require_relative "opening_hours/time_of_day"
+  require_relative "opening_hours/time_window"
+  require_relative "opening_hours/schedule"
+  require_relative "opening_hours/builder"
+  autoload :Type,  "opening_hours/type"
+  autoload :Model, "opening_hours/model"
+end

data/lib/power/hours.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "opening_hours"

data/sig/power/hours.rbs

@@ -0,0 +1,94 @@
+module OpeningHours
+  type day = :sun | :mon | :tue | :wed | :thu | :fri | :sat
+  type time_input = Integer | String | Time | OpeningHours::TimeOfDay
+  type time_window_input = OpeningHours::TimeWindow | Range[time_input] | [time_input, time_input] | String
+  type day_windows_input = nil | time_window_input | Array[time_window_input]
+  type serialized_schedule = Hash[day, Array[String]]
+
+  VERSION: String
+
+  class TimeOfDay
+    include Comparable[time_input]
+
+    attr_reader hour: Integer
+    attr_reader min: Integer
+
+    def self.[]: (time_input input) -> OpeningHours::TimeOfDay
+    def initialize: (time_input input) -> void
+
+    def <=>: (time_input other) -> Integer?
+    def to_minutes: () -> Integer
+    def to_s: () -> String
+  end
+
+  class TimeWindow
+    attr_reader opens: OpeningHours::TimeOfDay
+    attr_reader closes: OpeningHours::TimeOfDay
+
+    def self.[]: (time_window_input input) -> OpeningHours::TimeWindow
+    def initialize: (opens: time_input, closes: time_input) -> void
+
+    def to_a: () -> [OpeningHours::TimeOfDay, OpeningHours::TimeOfDay]
+    def to_s: () -> String
+    def overnight?: () -> bool
+    def cover?: (time_input value) -> bool
+  end
+
+  class Schedule
+    attr_reader sun: Array[OpeningHours::TimeWindow]
+    attr_reader mon: Array[OpeningHours::TimeWindow]
+    attr_reader tue: Array[OpeningHours::TimeWindow]
+    attr_reader wed: Array[OpeningHours::TimeWindow]
+    attr_reader thu: Array[OpeningHours::TimeWindow]
+    attr_reader fri: Array[OpeningHours::TimeWindow]
+    attr_reader sat: Array[OpeningHours::TimeWindow]
+
+    def self.build: () -> OpeningHours::Schedule
+                | () { () -> untyped } -> OpeningHours::Schedule
+    def self.from_hash: (Hash[Symbol | String, untyped] hash) -> OpeningHours::Schedule
+    def initialize: (
+      ?mon: day_windows_input,
+      ?tue: day_windows_input,
+      ?wed: day_windows_input,
+      ?thu: day_windows_input,
+      ?fri: day_windows_input,
+      ?sat: day_windows_input,
+      ?sun: day_windows_input
+    ) -> void
+
+    def open?: (?at: untyped) -> bool
+    def to_h: () -> serialized_schedule
+    def as_json: (?Hash[Symbol, untyped] options) -> serialized_schedule
+  end
+
+  class Builder
+    attr_reader schedule: OpeningHours::Schedule
+
+    def initialize: () -> void
+
+    def sun: (*time_window_input ranges) -> OpeningHours::Schedule
+    def mon: (*time_window_input ranges) -> OpeningHours::Schedule
+    def tue: (*time_window_input ranges) -> OpeningHours::Schedule
+    def wed: (*time_window_input ranges) -> OpeningHours::Schedule
+    def thu: (*time_window_input ranges) -> OpeningHours::Schedule
+    def fri: (*time_window_input ranges) -> OpeningHours::Schedule
+    def sat: (*time_window_input ranges) -> OpeningHours::Schedule
+  end
+
+  class Type
+    def type: () -> Symbol
+    def cast: (untyped value) -> OpeningHours::Schedule
+    def serialize: (untyped value) -> serialized_schedule
+    def changed_in_place?: (untyped raw_old_value, untyped new_value) -> bool
+  end
+
+  module Model
+    module ClassMethods
+      def opening_hours_column: (?Symbol name) -> Symbol
+    end
+
+    def define_hours: () -> OpeningHours::Schedule
+                  | () { () -> untyped } -> OpeningHours::Schedule
+    def open?: (?at: untyped) -> bool
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: power-hours
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Max Power
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Power Hours models weekly opening windows, including overnight ranges,
+  with a small Ruby DSL and optional model mixin helpers.
+email:
+- kevin.melchert@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/opening_hours.html
+- examples/opening_hours_controller.js
+- lib/opening_hours.rb
+- lib/opening_hours/builder.rb
+- lib/opening_hours/model.rb
+- lib/opening_hours/schedule.rb
+- lib/opening_hours/time_of_day.rb
+- lib/opening_hours/time_window.rb
+- lib/opening_hours/type.rb
+- lib/opening_hours/version.rb
+- lib/power/hours.rb
+- sig/power/hours.rbs
+homepage: https://github.com/kevin/power-hours
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kevin/power-hours
+  source_code_uri: https://github.com/kevin/power-hours/tree/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.5
+specification_version: 4
+summary: Simple opening-hours DSL with overnight window support.
+test_files: []