fasti 1.0.0

data/lib/fasti/config.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "dry-configurable"
+
+module Fasti
+  # Configuration management using dry-configurable
+  #
+  # Provides a clean interface for managing fasti configuration
+  # with type safety and validation.
+  #
+  # @example Basic usage
+  #   Fasti.configure do |config|
+  #     config.format = :quarter
+  #     config.country = :jp
+  #   end
+  #
+  # @example With styling
+  #   Fasti.configure do |config|
+  #     config.style = {
+  #       sunday: { foreground: :red, bold: true },
+  #       holiday: { background: :yellow }
+  #     }
+  #   end
+  class Config
+    extend Dry::Configurable
+
+    # Calendar display format
+    setting :format, default: :month, constructor: Types::Format
+
+    # Week start day
+    setting :start_of_week, default: :sunday, constructor: Types::StartOfWeek
+
+    # Country code for holiday detection
+    setting :country, default: :us, constructor: Types::Country
+
+    # Style configuration
+    # Accepts a hash mapping style targets to their attributes
+    # @param value [Hash<Symbol|String, Hash>] Style configuration hash
+    # @return [Hash<Symbol, Hash>] Validated and normalized style hash
+    setting :style, default: nil, constructor: ->(value) do
+      case value
+      when nil
+        nil
+      when Hash
+        validate_and_normalize_style(value)
+      else
+        raise ArgumentError, "Style must be nil or Hash, got #{value.class}"
+      end
+    end
+
+    # Validates and normalizes a style configuration hash
+    #
+    # @param style_hash [Hash] Raw style configuration
+    # @return [Hash<Symbol, Hash>] Validated and normalized style hash
+    # @raise [ArgumentError] If validation fails
+    def self.validate_and_normalize_style(style_hash)
+      validated_style = {}
+
+      style_hash.each do |target, attributes|
+        # Validate and convert target
+        target_sym = Types::StyleTarget.call(target)
+
+        # Validate attributes structure
+        unless attributes.is_a?(Hash)
+          raise ArgumentError, "Style attributes for #{target} must be a Hash, got #{attributes.class}"
+        end
+
+        # Validate individual attributes using schema
+        result = Schema::StyleAttribute.call(attributes)
+        if result.success?
+          validated_style[target_sym] = TIntMe[**result.to_h]
+        else
+          errors = result.errors.to_h.map {|key, messages|
+            "#{key}: #{Array(messages).join(", ")}"
+          }.join("; ")
+          raise ArgumentError, "Invalid style attributes for #{target}: #{errors}"
+        end
+      end
+
+      validated_style
+    end
+
+    # Reset configuration to defaults
+    def self.reset!
+      configure do |config|
+        config.format = :month
+        config.start_of_week = :sunday
+        config.country = :us
+        config.style = nil
+      end
+    end
+
+    # Load configuration from a Ruby file
+    #
+    # @param file_path [String] Path to configuration file
+    # @return [Hash] Configuration hash loaded from file
+    # @raise [ConfigError] If file has syntax errors
+    def self.load_from_file(file_path)
+      return {} unless File.exist?(file_path)
+
+      begin
+        # Execute the configuration file in the context of Fasti
+        instance_eval(File.read(file_path), file_path)
+        config.to_h
+      rescue SyntaxError => e
+        raise ConfigError, "Invalid Ruby syntax in #{file_path}: #{e.message}"
+      rescue => e
+        raise ConfigError, "Error loading configuration from #{file_path}: #{e.message}"
+      end
+    end
+  end
+
+  # Configuration error
+  class ConfigError < StandardError; end
+
+  # Convenience method for configuration
+  def self.configure(&)
+    Config.configure(&)
+  end
+
+  # Access current configuration
+  def self.config
+    Config.config
+  end
+end

data/lib/fasti/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Fasti
+  # Base error class for all Fasti-related errors
+  class Error < StandardError; end
+end

data/lib/fasti/formatter.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Fasti
+  # Handles calendar formatting and display with color-coded output.
+  #
+  # This class provides various calendar display formats (month, quarter, year)
+  # with ANSI color coding for holidays, weekends, and the current date.
+  # Holiday detection is handled by the Calendar class using the holidays gem.
+  #
+  # ## Styling
+  # - **Holidays**: Bold text
+  # - **Sundays**: Bold text
+  # - **Today**: Inverted background/text colors (combined with above styles)
+  #
+  # @example Basic month formatting
+  #   formatter = Formatter.new
+  #   calendar = Calendar.new(2024, 6, country: :jp)
+  #   puts formatter.format_month(calendar)
+  #
+  # @example Year view
+  #   formatter = Formatter.new
+  #   puts formatter.format_year(2024, start_of_week: :sunday, country: :jp)
+  class Formatter
+    # Creates a new formatter instance.
+    #
+    # @param styles [Hash<Symbol, Style>] Styles for different day types
+    #   Keys can be :sunday, :monday, ..., :saturday, :holiday, :today
+    # @example
+    #   Formatter.new(styles: config.style)
+    def initialize(styles: {})
+      @styles = styles
+      @style_cache = {}
+    end
+
+    # Formats a single month calendar with headers and color coding.
+    #
+    # Displays the month/year header, day abbreviations, and calendar grid
+    # with appropriate color coding for holidays, weekends, and today.
+    #
+    # @param calendar [Calendar] The calendar to format
+    # @return [String] Formatted calendar string with ANSI color codes
+    #
+    # @example
+    #   calendar = Calendar.new(2024, 6, country: :jp)
+    #   formatter.format_month(calendar)
+    #   # Output:
+    #   #      June 2024
+    #   #
+    #   # Su Mo Tu We Th Fr Sa
+    #   #                    1
+    #   #  2  3  4  5  6  7  8
+    #   # ...
+    def format_month(calendar)
+      output = []
+
+      # Month/Year header - centered
+      header = calendar.month_year_header
+      output << header.center(20)
+      output << ""
+
+      # Day headers
+      output << calendar.day_headers.join(" ")
+
+      # Calendar grid
+      calendar.calendar_grid.each do |week|
+        week_str = week.map {|day|
+          format_day(day, calendar)
+        }.join(" ")
+        output << week_str
+      end
+
+      output.join("\n")
+    end
+
+    # Formats three calendars side-by-side in a quarter view.
+    #
+    # Displays three months horizontally with aligned headers and grids.
+    # Typically used for showing current month with adjacent months.
+    #
+    # @param calendars [Array<Calendar>] Array of exactly 3 calendars to display
+    # @return [String] Formatted quarter view string
+    # @raise [ArgumentError] If not exactly 3 calendars provided
+    #
+    # @example Quarter view
+    #   calendars = [
+    #     Calendar.new(2024, 5, country: :jp),
+    #     Calendar.new(2024, 6, country: :jp),
+    #     Calendar.new(2024, 7, country: :jp)
+    #   ]
+    #   formatter.format_quarter(calendars)
+    def format_quarter(calendars)
+      raise ArgumentError, "Expected 3 calendars for quarter view" unless calendars.length == 3
+
+      output = []
+
+      # Headers for all three months
+      headers = calendars.map {|cal| cal.month_year_header.center(20) }
+      output << headers.join("  ")
+      output << ""
+
+      # Day headers for all three months
+      day_headers = calendars.map {|cal| cal.day_headers.join(" ") }
+      output << day_headers.join("  ")
+
+      # Calendar grids side by side
+      max_rows = calendars.map {|cal| cal.calendar_grid.length }.max
+
+      (0...max_rows).each do |row_index|
+        row_parts = calendars.map {|cal|
+          if row_index < cal.calendar_grid.length
+            week = cal.calendar_grid[row_index]
+            week.map {|day| format_day(day, cal) }.join(" ")
+          else
+            " " * 20 # Empty space for shorter months
+          end
+        }
+        output << row_parts.join("  ")
+      end
+
+      output.join("\n")
+    end
+
+    # Formats a complete year view with all 12 months in quarters.
+    #
+    # Displays the full year as 4 quarters, each containing 3 months
+    # side-by-side. Each quarter is separated by blank lines.
+    #
+    # @param year [Integer] The year to display
+    # @param start_of_week [Symbol] Week start preference (:sunday or :monday)
+    # @param country [String] Country code for holiday context
+    # @return [String] Formatted year view string
+    #
+    # @example Full year display
+    #   formatter.format_year(2024, start_of_week: :sunday, country: :jp)
+    #   # Displays all 12 months in 4 rows of 3 months each
+    def format_year(year, country:, start_of_week: :sunday)
+      output = []
+
+      # Year header
+      output << year.to_s.center(64)
+      output << ""
+
+      # Process 4 quarters (3 months each)
+      quarters = []
+      (1..12).each_slice(3) do |months|
+        calendars = months.map {|month| Calendar.new(year, month, start_of_week:, country:) }
+        quarters << format_quarter(calendars)
+      end
+
+      output << quarters.join("\n\n")
+      output.join("\n")
+    end
+
+    # Formats a single day with appropriate color coding.
+    #
+    # Applies ANSI styling based on the day's characteristics:
+    # - Today: Inverted colors (combined with other formatting)
+    # - Holidays: Bold text
+    # - Sundays: Bold text
+    # - Regular days: No special formatting
+    #
+    # @param day [Integer, nil] Day of the month (1-31) or nil for empty cells
+    # @param calendar [Calendar] Calendar context for date conversion
+    # @return [String] Formatted day string with ANSI codes, right-aligned to 2 characters
+    #
+    # @example
+    #   format_day(15, calendar)    #=> "15" (regular day)
+    #   format_day(1, calendar)     #=> styled " 1" with bold text (if Sunday/holiday)
+    #   format_day(nil, calendar)   #=> "  " (empty cell)
+    # Determines applicable style targets for a given day
+    #
+    # @param day [Integer] Day of month
+    # @param calendar [Calendar] Calendar instance
+    # @return [Array<Symbol>] Sorted array of style target symbols
+    private def determine_style_targets(day, calendar)
+      return [] unless day
+
+      date = calendar.to_date(day)
+      return [] unless date
+
+      targets = []
+
+      # Add weekday target
+      weekday_key = %i[sunday monday tuesday wednesday thursday friday saturday][date.wday]
+      targets << weekday_key if @styles.key?(weekday_key)
+
+      # Add holiday target
+      targets << :holiday if calendar.holiday?(day) && @styles.key?(:holiday)
+
+      # Add today target
+      targets << :today if date == Date.today && @styles.key?(:today)
+
+      targets.sort
+    end
+
+    # Gets or creates a composed style for the given targets
+    #
+    # @param targets [Array<Symbol>] Sorted array of style target symbols
+    # @return [TIntMe::Style, nil] Composed style object or nil if no styling needed
+    private def get_composed_style(targets)
+      return nil if targets.empty?
+
+      cache_key = targets.dup.freeze
+      return @style_cache[cache_key] if @style_cache.key?(cache_key)
+
+      # Compose styles in order using reduce without initial value
+      # This avoids unnecessary composition with DEFAULT_STYLE
+      composed_style = targets.map {|target| @styles[target] }.reduce(&:>>)
+
+      @style_cache[cache_key] = composed_style
+      composed_style
+    end
+
+    private def format_day(day, calendar)
+      return "  " unless day
+
+      date = calendar.to_date(day)
+
+      # Handle calendar transition gaps - date might be nil
+      unless date
+        # For gap days, return empty space to show the gap visually
+        return "  "
+      end
+
+      day_str = day.to_s.rjust(2)
+
+      # Determine applicable style targets and get composed style from cache
+      targets = determine_style_targets(day, calendar)
+      style = get_composed_style(targets)
+
+      style ? style.call(day_str) : day_str
+    end
+  end
+end

data/lib/fasti/style_parser.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Fasti
+  # Parses style definition strings into Style objects for calendar formatting.
+  #
+  # This class handles the parsing of style definition strings in the format:
+  # "target:attribute=value,attribute,no-attribute target:attribute=value"
+  #
+  # Supported targets:
+  # - Weekdays: sunday, monday, tuesday, wednesday, thursday, friday, saturday
+  # - Special days: holiday, today
+  #
+  # Supported attributes:
+  # - Colors: foreground=color, background=color
+  # - Text effects: bold, italic, underline, underline=double, overline, blink, inverse, hide, faint
+  # - Negation: no-bold, no-italic, etc.
+  #
+  # @example Basic usage
+  #   parser = StyleParser.new
+  #   styles = parser.parse("sunday:bold,foreground=red holiday:bold today:inverse")
+  #   styles[:sunday] #=> Style.new(bold: true, foreground: :red)
+  #
+  # @example With negation
+  #   styles = parser.parse("sunday:foreground=red,no-bold saturday:no-italic")
+  #   styles[:sunday] #=> Style.new(foreground: :red, bold: false)
+  class StyleParser
+    # Valid target names that can be used in style definitions
+    VALID_TARGETS = %w[sunday monday tuesday wednesday thursday friday saturday holiday today].freeze
+    private_constant :VALID_TARGETS
+
+    # Valid color names for foreground and background
+    VALID_COLORS = %w[red green blue yellow magenta cyan white black default].freeze
+    private_constant :VALID_COLORS
+
+    # Valid boolean attributes that can be enabled/disabled
+    BOOLEAN_ATTRIBUTES = %w[bold faint italic overline blink inverse conceal].freeze
+    private_constant :BOOLEAN_ATTRIBUTES
+
+    # Special attributes that can have specific values
+    SPECIAL_ATTRIBUTES = {"underline" => [true, false, :double]}.freeze
+    private_constant :SPECIAL_ATTRIBUTES
+
+    # Parses a style definition string into a hash of Style objects.
+    #
+    # @param style_string [String] Style definition string
+    # @return [Hash<Symbol, Style>] Hash mapping target symbols to Style objects
+    # @raise [ArgumentError] If the style string contains invalid syntax or values
+    #
+    # @example
+    #   parse("sunday:bold,foreground=red holiday:bold today:inverse")
+    #   #=> { sunday: Style.new(...), holiday: Style.new(...), today: Style.new(...) }
+    def parse(style_string)
+      return {} if style_string.nil? || style_string.strip.empty?
+
+      style_string.strip.split(/\s+/).each_with_object({}) do |entry, styles|
+        target, attributes_hash = parse_entry(entry)
+        styles[target] = create_style(attributes_hash)
+      end
+    end
+
+    # Parses a single style entry in the format "target:attributes"
+    #
+    # @param entry [String] Single style entry
+    # @return [Array<Symbol, Hash>] Target symbol and attributes hash
+    # @raise [ArgumentError] If entry format is invalid
+    private def parse_entry(entry)
+      # Entry should not contain whitespace since it comes from split(/\s+/)
+      if entry.match?(/\s/)
+        raise ArgumentError, "Style entry should not contain whitespace: '#{entry}'"
+      end
+
+      parts = entry.split(":", 2)
+      raise ArgumentError, "Invalid style entry format: '#{entry}'" if parts.length != 2
+
+      target = parts[0]
+      attributes_str = parts[1]
+
+      raise ArgumentError, "Invalid target: '#{target}'" unless VALID_TARGETS.include?(target)
+
+      attributes = parse_attributes(attributes_str)
+      [target.to_sym, attributes]
+    end
+
+    # Parses attribute string into a hash of attribute names and values
+    #
+    # @param attributes_str [String] Comma-separated attribute string
+    # @return [Hash<String, Object>] Hash of attribute names to values
+    private def parse_attributes(attributes_str)
+      attributes_str.split(",").each_with_object({}) do |attr, attributes|
+        attr = attr.strip
+        next if attr.empty?
+
+        case attr
+        when /\A(?!no-)(.+)=(.+)\z/
+          # Handle key=value format
+          key = $1
+          value = $2
+
+          # Reject keys or values with whitespace
+          if key != key.strip || value != value.strip
+            raise ArgumentError, "Attribute keys and values cannot contain leading or trailing spaces: '#{attr}'"
+          end
+
+          attributes[key] = parse_attribute_value(key, value)
+        when /\Ano-(.+)\z/
+          # Handle no- prefix (negation)
+          attribute_name = $1
+          validate_boolean_attribute(attribute_name)
+          attributes[attribute_name] = false
+        else
+          # Handle simple boolean attributes (bold, italic, etc.)
+          validate_boolean_attribute(attr)
+          attributes[attr] = true
+        end
+      end
+    end
+
+    # Parses an attribute value based on the attribute key
+    #
+    # @param key [String] Attribute name
+    # @param value [String] Attribute value
+    # @return [Object] Parsed value (Symbol, Boolean, etc.)
+    # @raise [ArgumentError] If the key or value is invalid
+    private def parse_attribute_value(key, value)
+      case key
+      when "foreground", "background"
+        parse_color_value(value)
+      when "underline"
+        parse_underline_value(value)
+      when *BOOLEAN_ATTRIBUTES
+        raise ArgumentError, "Boolean attributes should not use '=' syntax. Use '#{key}' or 'no-#{key}' instead"
+      else
+        raise ArgumentError, "Unknown attribute: '#{key}'"
+      end
+    end
+
+    # Parses a color value (color name or hex code)
+    #
+    # @param value [String] Color value
+    # @return [Symbol, String] Color as symbol or hex string
+    # @raise [ArgumentError] If color is invalid
+    private def parse_color_value(value)
+      # Check if it's a hex color (with or without #)
+      if value.match?(/\A#?\h{3}(?:\h{3})?\z/)
+        parse_hex_color(value)
+      elsif VALID_COLORS.include?(value)
+        value.to_sym
+      else
+        raise ArgumentError, "Invalid color: '#{value}'. Valid colors: #{VALID_COLORS.join(", ")}, or hex colors " \
+                             "(#RGB, #RRGGBB, RGB, RRGGBB)"
+      end
+    end
+
+    # Parses and normalizes hex color values
+    #
+    # @param value [String] Hex color value (with or without #, 3 or 6 digits)
+    # @return [String] Normalized 6-digit hex color with #
+    # @raise [ArgumentError] If hex color format is invalid
+    private def parse_hex_color(value)
+      # Remove # if present
+      hex_part = value.start_with?("#") ? value[1..] : value
+
+      case hex_part.length
+      when 3
+        # Expand 3-digit to 6-digit (F00 -> FF0000)
+        expanded = hex_part.chars.map {|c| c + c }.join
+        "##{expanded.upcase}"
+      when 6
+        "##{hex_part.upcase}"
+      else
+        raise ArgumentError, "Invalid hex color: '#{value}'. Use 3-digit (#RGB) or 6-digit (#RRGGBB) format"
+      end
+    end
+
+    # Parses underline attribute value
+    #
+    # @param value [String] Underline value
+    # @return [Symbol] Parsed underline value
+    # @raise [ArgumentError] If underline value is invalid
+    private def parse_underline_value(value)
+      case value
+      when "double"
+        :double
+      else
+        raise ArgumentError, "Invalid underline value: '#{value}'. Valid values: double"
+      end
+    end
+
+    # Validates that an attribute is a valid boolean attribute
+    #
+    # @param attribute [String] Attribute name to validate
+    # @raise [ArgumentError] If attribute is not a valid boolean attribute
+    private def validate_boolean_attribute(attribute)
+      valid_attributes = BOOLEAN_ATTRIBUTES + ["underline"]
+      return if valid_attributes.include?(attribute)
+
+      raise ArgumentError,
+        "Invalid boolean attribute: '#{attribute}'. Valid attributes: #{valid_attributes.join(", ")}"
+    end
+
+    # Creates a Style object from parsed attributes
+    #
+    # @param attributes [Hash<String, Object>] Hash of attribute names to values
+    # @return [Style] New Style object
+    private def create_style(attributes)
+      style_params = attributes.transform_keys(&:to_sym)
+
+      TIntMe[**style_params]
+    end
+  end
+end

data/lib/fasti/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Fasti
+  VERSION = "1.0.0"
+  public_constant :VERSION
+end

data/lib/fasti.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "tint_me"
+require "zeitwerk"
+
+# Manually require version for gemspec compatibility (ignored by Zeitwerk)
+require_relative "fasti/version"
+
+# Fasti - Flexible calendar application with multi-country holiday support
+#
+# Main namespace containing all Fasti components including configuration,
+# calendar logic, formatting, and CLI interface.
+module Fasti
+  # Setup Zeitwerk autoloader
+  loader = Zeitwerk::Loader.for_gem
+  # VERSION constant doesn't follow Zeitwerk naming conventions, so ignore it
+  loader.ignore("#{__dir__}/fasti/version.rb")
+  # CLI acronym inflection - cli.rb defines CLI constant, not Cli
+  loader.inflector.inflect("cli" => "CLI")
+  loader.setup
+end

data/mise.toml

@@ -0,0 +1,5 @@
+[tools]
+ruby = "3.2"
+
+[env]
+_.path = ["bin", "exe"]

data/sig/fasti.rbs

@@ -0,0 +1,4 @@
+module Fasti
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end