terminal_calendar 0.1.0

data/lib/terminal_calendar/selection/grid.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+# rubocop:disable Naming::MethodParameterName
+class TerminalCalendar
+  module Selection
+    class Grid
+      # @return [Array<Array>]
+      # @api private
+      attr_reader :grid
+
+      attr_reader :highlighted_position
+
+      # @return [Integer]
+      # @api private
+      attr_accessor :redraw_at
+
+      # Builds a new grid from a array of arrays of objects
+      #
+      # @param [Array<Array>] objects The objects to build the grid from.
+      # @param [Hash] opts
+      #
+      # @return [Grid]
+      # @api public
+      def self.build_from_objects(objects, _opts={})
+        new(objects.first.length, objects.length).tap do |new_grid|
+          new_grid.populate_from_objects(objects)
+        end
+      end
+
+      # Initializes a new grid with the specified width and height.
+
+      # @param width [Integer] the width of the grid
+      # @param height [Integer] the height of the grid
+      # @param pastel [Pastel] The pastel object to used for decorating text
+      def initialize(width, height, pastel: Pastel.new)
+        @grid = Array.new(height) do
+          Array.new(width) { NullCell.new }
+        end
+        @pastel = pastel
+      end
+
+      # Builds a the grid from an array of arrays of objects
+      #
+      # @param [Array<Array>] objects the objects to populate the grid with
+      # @return [Grid] self
+      #
+      # @api public
+      def populate_from_objects(objects)
+        objects.each_with_index do |object_row, y|
+          object_row.each_with_index do |obj, x|
+            populate_position(x, y, obj)
+          end
+        end
+        self
+      end
+
+      # Populates a position on the grid with the given object.
+
+      # @param x      [Integer] the x-coordinate of the position
+      # @param y      [Integer] the y-coordinate of the position
+      # @param object [Object] the object to wrap in the cell
+      # @return       [Cell] the created cell
+      def populate_position(x, y, object)
+        return grid[y][x] if object.null?
+
+        grid[y][x] = Cell.new(object)
+      end
+
+      # Returns the cell at the given coordinates.
+      #
+      # @param [Integer] x the x coordinate
+      # @param [Integer] y the y coordinate
+      # @return [Cell] the cell at the given coordinates
+      #
+      # @api public
+      def cell(x, y)
+        grid[y][x]
+      end
+
+      # Renders specified number of lines from the bottom of the grid as printable strings
+      # @param count [Integer, Symbol] The number of lines to render. If set to :all, all lines will be rendered.
+      # @return [Array<String>] An array of strings representing the rendered lines.
+      def render_lines(count=:all)
+        start_at = render_start(count)
+
+        (start_at..bottom_of_grid).map do |i|
+          render_row(i)
+        end
+      end
+
+      # Returns the y value of the bottom of the grid
+      #
+      # @return [Integer] the bottom of the grid
+      #
+      # @api public
+      def bottom_of_grid
+        grid.length - 1
+      end
+
+      # Returns the y value of the top of the grid
+      #
+      # @return [Integer] the top of the grid
+      #
+      # @api public
+      def top_of_grid
+        0
+      end
+
+      # Returns the bottom row of the grid
+      #
+      # @return [Array<TerminalCalendar::Selection::Cell>]
+      #
+      # @api public
+      def bottom_row
+        grid[bottom_of_grid]
+      end
+
+      # Returns the top row of the grid
+      #
+      # @return [Array<TerminalCalendar::Selection::Cell>]
+      #
+      # @api public
+      def top_row
+        grid[top_of_grid]
+      end
+
+      # Returns the first cell in the grid that is not null working from right to left, bottom to top.
+      #
+      # @return [Array<Integer>] the bottom right live cell position in the grid format x,y
+      #
+      # @example
+      #   bottom_right_live_cell_position #=> [3, 3]
+      #
+      # @api public
+      def bottom_right_live_cell_position
+        bottom_of_grid.downto(top_of_grid).each do |y|
+          row = grid[y]
+          (row.length - 1).downto(0).each do |x|
+            return [x, y] unless row[x].null?
+          end
+        end
+      end
+
+      # Returns the first cell in the grid that is not null working from left to right, top to bottom.
+      #
+      # @return [Array<Integer>] the top left live cell position in the grid format x, y
+      #
+      # @example
+      #   top_left_live_cell_position #=> [2, 0]
+      #
+      # @api public
+      def top_left_live_cell_position
+        (top_of_grid..bottom_of_grid).each do |y|
+          grid[y].each_with_index do |cell, x|
+            return [x, y] unless cell.null?
+          end
+        end
+      end
+
+      # Returns all selected cells in the grid
+      # @return [Array<Cell>] Selected cells
+      def selected_cells
+        grid.flatten.select(&:selected?)
+      end
+
+      def redraw_lines
+        render_lines(redraw_at.nil? || redraw_at <= 0 ? :all : (grid.length - redraw_at))
+      end
+
+      def row_end
+        grid.first.length - 1
+      end
+
+      def highlighted_position=(pos)
+        @highlighted_position = pos
+      end
+
+      def clear_highlight!
+        @highlighted_position = nil
+      end
+
+      def highlighted?
+        @highlighted_position.nil?
+      end
+
+      private
+
+      # @api private
+      def render_row(i)
+        row = grid[i]
+        highlighted_x, highlighted_y = highlighted_position
+        return row.map(&:render).join(' ') unless highlighted_y == i
+
+        (0..row_end).map do |x|
+          rendered = row[x].render
+          next rendered unless x == highlighted_x
+
+          @pastel.inverse(rendered)
+        end.join(' ')
+      end
+
+      # @api private
+      def render_start(count)
+        return 0 if count == :all || count > bottom_of_grid
+
+        bottom_of_grid - count
+      end
+    end
+  end
+end
+# rubocop:enable Naming::MethodParameterName

data/lib/terminal_calendar/selection/month_page.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+class TerminalCalendar
+  module Selection
+    class MonthPage
+      WEEK_ROW = %w(Su Mo Tu We Th Fr Sa).freeze
+
+      attr_reader :selection_grid, :month
+
+      def self.build(month)
+        new(month)
+      end
+
+      def initialize(month, pastel=Pastel.new)
+        @selection_grid = Grid.build_from_objects(month.as_rows)
+        @month = month
+        @pastel = pastel
+      end
+
+      # Renders the calendar as a string.
+      # @return [String] the rendered calendar as a string.
+      def render
+        render_rows.join("\n")
+      end
+
+      def redraw_lines
+        if selection_grid.redraw_at.nil? || selection_grid.redraw_at.negative?
+          calendar_header(selected: selection_grid&.redraw_at == -1).concat(selection_grid.redraw_lines)
+        else
+          selection_grid.redraw_lines
+        end
+      end
+
+      def line_count
+        @line_count ||= render_rows.count
+      end
+
+      def selection_grid_lines
+        selection_grid.render_lines
+      end
+
+      private
+
+      def render_rows
+        calendar_header.concat(selection_grid_lines)
+      end
+
+      def refresh(lines)
+        TTY::Cursor.clear_lines(lines)
+      end
+
+      def calendar_header(selected: false)
+        week_row = WEEK_ROW.join(' ')
+        month_row = month_header
+        pad_size = (week_row.length - month_row.length) / 2
+        month_row = @pastel.inverse(month_row) if selected
+        month_row = (' ' * pad_size).concat(month_row)
+        [
+          month_row,
+          week_row
+        ]
+      end
+
+      def month_header
+        Date::MONTHNAMES[@month.month] + " #{@month.year}"
+      end
+    end
+  end
+end

data/lib/terminal_calendar/selection/month_year_dialog.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+class TerminalCalendar
+  module Selection
+    class MonthYearDialog
+      extend Forwardable
+
+      # Initializes a new MonthYearDialog instance.
+      #
+      # @param start_at [Date] the starting date for the dialog (default: Date.today)
+      # @param input [IO] the input stream to read user input from (default: $stdin)
+      # @param output [IO] the output stream to write messages to (default: $stdout)
+      # @param env [Hash] the environment variables (default: ENV)
+      # @param interrupt [Symbol] the behavior when an interrupt signal is received (:error or :exit) (default: :error)
+      # @param track_history [Boolean] whether to track user input history (default: true)
+      # @return [MonthYearDialog] the initialized MonthYearDialog instance
+      def initialize(input: $stdin, output: $stdout, env: ENV, interrupt: :error, track_history: true,
+                     start_at: Date.today)
+        @output = output
+        @reader = TTY::Reader.new(
+          input: input,
+          output: output,
+          interrupt: interrupt,
+          track_history: track_history,
+          env: env
+        )
+        initialize_carousels(start_at)
+        @cursor = TTY::Cursor
+      end
+
+      # Renders the dialog for month and year to the output
+      def render
+        month_car.render
+        @output.puts
+        year_car.render
+      end
+
+      def select
+        cursor.invisible do
+          render
+
+          key_capture
+        end
+      end
+
+      def redraw(amt=2)
+        @output.print(cursor.clear_lines(amt))
+        amt == 2 ? render : year_car.render
+      end
+
+      def_delegator :@month_car, :selected_option, :selected_month
+      def_delegator :@year_car, :selected_option, :selected_year
+
+      private
+
+      def key_capture
+        loop do
+          case get_key_press
+          when :up, :down
+            toggle_selected
+            redraw(2)
+          when :left
+            selected_car.move_left
+            redraw(@selected == :year ? 1 : 2)
+          when :right
+            selected_car.move_right
+            redraw(@selected == :year ? 1 : 2)
+          when :return
+            return Date.new(selected_year.to_i, Date::MONTHNAMES.find_index(selected_month), 1)
+          end
+        end
+      end
+
+      def get_key_press
+        press = reader.read_keypress
+        TTY::Reader::Keys.keys.fetch(press) { press }
+      end
+
+      def initialize_carousels(start_at)
+        @selected = :month
+        @month_car = TTY::Prompt::Carousel.new(Date::MONTHNAMES.compact, start_at: start_at.month - 1,
+                                                                         option_style: :inverse, output: output)
+        @year_car = TTY::Prompt::Carousel.new((0..3000).map(&:to_s), start_at: start_at.year, output: output,
+                                                                     margin: 0, padding: 4)
+      end
+
+      def selected_car
+        @selected == :month ? month_car : year_car
+      end
+
+      attr_reader(:output, :month_car, :year_car, :cursor, :reader)
+
+      def toggle_selected
+        @selected = @selected == :month ? :year : :month
+        month_car.option_style = @selected == :month ? :inverse : nil
+        year_car.option_style = @selected == :year ? :inverse : nil
+      end
+    end
+  end
+end

data/lib/terminal_calendar/selection/null_cell.rb

@@ -0,0 +1,32 @@
+
+
+# frozen_string_literal: true
+class TerminalCalendar
+  module Selection
+    class NullCell < Cell
+      def initialize
+        super(nil)
+      end
+
+      def render
+        '  '
+      end
+
+      # Checks if the object is null.
+      #
+      # @return [true] Returns true.
+      def null?
+        true
+      end
+
+      # @return [false] Returns false.
+      def selected
+        false
+      end
+
+      def toggle_selected!
+        false
+      end
+    end
+  end
+end

data/lib/terminal_calendar/selection/selector.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+# rubocop:disable Naming::MethodParameterName
+class TerminalCalendar
+  module Selection
+    class Selector
+      extend Forwardable
+
+      DIRECTIONS = %i(up down left right).freeze
+
+      attr_reader(:x, :y, :selection_grid)
+
+      def_delegator :@page, :selection_grid
+      def_delegators :selection_grid, :bottom_of_grid, :top_of_grid, :row_end
+
+      def self.build(page, initial_spot)
+        if initial_spot == :bottom
+          x, y = page.selection_grid.bottom_right_live_cell_position
+        else
+          x, y = page.selection_grid.top_left_live_cell_position
+        end
+
+        new(x, y, page)
+      end
+
+      # Initializes a new selector
+      #
+      # @param x [Integer] the x-coordinate of the selector
+      # @param y [Integer] the y-coordinate of the selector
+      # @param selection_grid [Array<Array<TerminalCalendar::Selection::Cell>>] the selection grid
+      # @param wrap [Symbol] (optional) the wrap direction, defaults to :all
+      def initialize(x, y, page, wrap: [])
+        @x = x
+        @page = page
+        @top_of_grid = 0
+        @y = y
+        @wrap_directions = wrap == :all ? DIRECTIONS : wrap
+        post_move
+      end
+
+      def on_header?
+        y == -1
+      end
+
+      # Toggles the selected state of the cell at the current position on the grid.
+      #
+      # @return [void]
+      def toggle_selected!
+        return unless on_grid?
+
+        selection_grid.cell(@x, @y).toggle_selected!
+      end
+
+      # Determines if the selector is within the selection grid.
+      #
+      # @return [Boolean] Returns true if the point is within the selection grid, false otherwise.
+      def on_grid?
+        x >= leftmost_gridsquare && x <= selection_grid.row_end &&
+          y >= selection_grid.top_of_grid && y <= selection_grid.bottom_of_grid
+      end
+
+      # Returns the leftmost grid square.
+      #
+      # @return [Integer] the leftmost grid square
+      def leftmost_gridsquare
+        0
+      end
+
+      # Moves the selector in the specified direction.
+      #
+      # @param direction [Symbol] The direction to move in.
+      #   Valid directions are: :up, :down, :left, :right.
+      # @raise [ArgumentError] if the specified direction is not valid.
+      # @return [void]
+      def move(direction)
+        fail ArgumentError.new("Unknown direction #{direction}") unless DIRECTIONS.include?(direction)
+
+        pre_move
+
+        result = send("move_#{direction}")
+
+        post_move
+
+        result
+      end
+
+      private
+
+      attr_writer(:x, :y)
+
+      def pre_move
+        selection_grid.redraw_at = nil
+        selection_grid.clear_highlight!
+      end
+
+      def post_move
+        unless selection_grid.redraw_at
+          selection_grid.redraw_at = y
+        end
+        return unless on_grid?
+
+        selection_grid.highlighted_position = [x, y]
+      end
+
+      def wrap(direction)
+        case direction
+        when :up
+          selection_grid.redraw_at = 0
+          self.y = bottom_of_grid
+        when :down
+          self.y = top_of_grid
+        when :left
+          self.x = row_end
+        when :right
+          self.x = leftmost_gridsquare
+        end
+      end
+
+      def move_up
+        if y == top_of_grid
+          wrap(:up) if @wrap_directions.include? :up
+          self.y -= 1
+        elsif on_header?
+          selection_grid.redraw_at = -2
+          self.y = bottom_of_grid
+        else
+          self.y -= 1
+        end
+      end
+
+      def move_down
+        if y == bottom_of_grid
+          wrap(:down)
+        elsif on_header?
+          selection_grid.redraw_at = y == -1 ? -2 : y
+          self.y += 1
+        else
+          self.y += 1
+        end
+      end
+
+      def move_left
+        if x == leftmost_gridsquare
+          return wrap(:left) if @wrap_directions.include? :left
+
+          :off_left
+        else
+          self.x -= 1
+        end
+      end
+
+      def move_right
+        if x == row_end
+          return wrap(:right) if @wrap_directions.include? :right
+
+          :off_right
+        else
+          self.x += 1
+        end
+      end
+
+      def redraw_header!
+        selection_grid.redraw_at = -2
+      end
+    end
+  end
+end
+# rubocop:enable Naming::MethodParameterName

data/lib/terminal_calendar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TerminalCalendar
+  VERSION = '0.1.0'
+end

data/lib/terminal_calendar.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'tty/prompt/carousel'
+require_relative 'terminal_calendar/version'
+require_relative 'terminal_calendar/month'
+require_relative 'terminal_calendar/selection/cell'
+require_relative 'terminal_calendar/selection/null_cell'
+require_relative 'terminal_calendar/selection/selector'
+require_relative 'terminal_calendar/selection/grid'
+require_relative 'terminal_calendar/selection/month_page'
+require_relative 'terminal_calendar/selection/month_year_dialog'
+require_relative 'terminal_calendar/date_picker'
+require_relative 'date_extensions'
+require 'pastel'
+require 'tty-cursor'
+require 'tty-reader'
+
+class TerminalCalendar
+  class Error < StandardError; end
+
+  # This method allows the user to select one or more days starting from the current month calendar.
+  #
+  # @return [Array<Date>] The selected days.
+  def self.date_picker
+    TerminalCalendar::DatePicker.pick
+  end
+
+  # @param month [Month] month to render, defaults to the current month
+  # @return [String] the month page as a string
+  def self.cal(month=Month.this_month())
+    Selection::MonthPage.build(month).render
+  end
+
+  # Stores a cache of month objects
+  # @api private
+  def self.all_months
+    @all_months ||= {}
+  end
+end