slideck 0.1.0

data/lib/slideck/metadata_parser.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Slideck
+  # Responsible for parsing metadata in YAML format
+  #
+  # @api private
+  class MetadataParser
+    # The symbolize names parameter
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    SYMBOLIZE_NAMES_PARAMETER = :symbolize_names
+    private_constant :SYMBOLIZE_NAMES_PARAMETER
+
+    # The permitted classes parameter
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    PERMITTED_CLASSES_PARAMETER = :permitted_classes
+    private_constant :PERMITTED_CLASSES_PARAMETER
+
+    # The whitelist classes parameter
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    WHITELIST_CLASSES_PARAMETER = :whitelist_classes
+    private_constant :WHITELIST_CLASSES_PARAMETER
+
+    # Create a MetadataParser instance
+    #
+    # @example
+    #   MetadataParser.new(YAML, symbolize_names: true, permitted_classes: [])
+    #
+    # @param [YAML] yaml_parser
+    #   the YAML parser
+    # @param [Boolean] symbolize_names
+    #   whether or not to symobolize names
+    # @param [Array<Object>] permitted_classes
+    #   the classes allowed to be deserialized
+    #
+    # @api public
+    def initialize(yaml_parser, symbolize_names: nil, permitted_classes: nil)
+      @yaml_parser = yaml_parser
+      @symbolize_names = symbolize_names
+      @permitted_classes = permitted_classes
+    end
+
+    # Parse metadata from content
+    #
+    # @example
+    #   parser.parse("align: center\nfooter: footer content")
+    #
+    # @param [String] content
+    #   the content to parse metadata from
+    #
+    # @return [Hash{String, Symbol => Object}]
+    #   the deserialized metadata
+    #
+    # @api public
+    def parse(content)
+      parse_method = select_parse_method
+      parse_params = parse_method_params(parse_method)
+      arguments = parser_arguments(parse_params)
+      options = parser_options(parse_params)
+      metadata = @yaml_parser.send(parse_method, content, *arguments, **options)
+
+      return metadata if symbolize_names?(options)
+
+      @symbolize_names ? symbolize_keys(metadata) : metadata
+    end
+
+    private
+
+    # Select metadata parse method
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def select_parse_method
+      @yaml_parser.respond_to?(:safe_load) ? :safe_load : :load
+    end
+
+    # Parse method parameters
+    #
+    # @param [Symbol] parse_method
+    #   the parse method name
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    def parse_method_params(parse_method)
+      @yaml_parser.method(parse_method).parameters.map(&:last)
+    end
+
+    # Generate parser arguments
+    #
+    # @param [Array<Symbol>] parse_method_params
+    #   the parse method parameters
+    #
+    # @return [Array<Object>]
+    #
+    # @api private
+    def parser_arguments(parse_method_params)
+      return [] unless parse_method_params.include?(WHITELIST_CLASSES_PARAMETER)
+
+      [@permitted_classes]
+    end
+
+    # Generate parser options
+    #
+    # @param [Array<Symbol>] parse_method_params
+    #   the parse method parameters
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @api private
+    def parser_options(parse_method_params)
+      {}.tap do |opts|
+        if parse_method_params.include?(PERMITTED_CLASSES_PARAMETER)
+          opts[:permitted_classes] = @permitted_classes
+        end
+
+        if parse_method_params.include?(SYMBOLIZE_NAMES_PARAMETER)
+          opts[:symbolize_names] = @symbolize_names
+        end
+      end
+    end
+
+    # Check whether the YAML parser can symbolize names or not
+    #
+    # @param [Hash{Symbol => Object}] parse_options
+    #   the parse method options
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def symbolize_names?(parse_options)
+      parse_options.key?(:symbolize_names)
+    end
+
+    # Symbolize metadata keys
+    #
+    # @param [Object] object
+    #   the object with keys to symbolize
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @api private
+    def symbolize_keys(object)
+      case object
+      when Hash then symbolize_hash_keys(object)
+      when Array then symbolize_array_hashes(object)
+      else object
+      end
+    end
+
+    # Symbolize hash keys
+    #
+    # @param [Hash] object
+    #   the hash object with keys to symbolize
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @api private
+    def symbolize_hash_keys(object)
+      object.each_with_object({}) do |(key, val), new_hash|
+        new_hash[key.to_sym] = symbolize_keys(val)
+      end
+    end
+
+    # Symbolize array hash values
+    #
+    # @param [Array] object
+    #   the array object with hash values to symbolize
+    #
+    # @return [Array<Object>]
+    #
+    # @api private
+    def symbolize_array_hashes(object)
+      object.each_with_object([]) do |val, new_array|
+        new_array << symbolize_keys(val)
+      end
+    end
+  end # MetadataParser
+end # Slideck

data/lib/slideck/metadata_wrapper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Slideck
+  # Responsible for wrapping parsed global and slide metadata
+  #
+  # @api private
+  class MetadataWrapper
+    # Create a MetadataWrapper instance
+    #
+    # @example
+    #   MetadataWrapper.new(metadata, metadata_converter, metadata_defaults)
+    #
+    # @param [Slideck::Metadata] metadata
+    #   the metadata initialiser
+    # @param [Slideck::MetadataConverter] metadata_converter
+    #   the metadata converter
+    # @param [Slideck::MetadataDefaults] metadata_defaults
+    #   the metadata defaults
+    #
+    # @api public
+    def initialize(metadata, metadata_converter, metadata_defaults)
+      @metadata = metadata
+      @metadata_converter = metadata_converter
+      @metadata_defaults = metadata_defaults
+    end
+
+    # Wrap parsed global and slide metadata
+    #
+    # @example
+    #   metadata_wrapper.wrap({metadata: {}, slides: []})
+    #
+    # @param [Hash{Symbol => Hash, String}] deck
+    #   the deck of parsed metadata and slides
+    #
+    # @return [Array<Slideck::Metadata, Hash>]
+    #
+    # @api public
+    def wrap(deck)
+      [
+        build_metadata(deck[:metadata], @metadata_defaults),
+        deck[:slides].map do |slide|
+          {
+            content: slide[:content],
+            metadata: build_metadata(slide[:metadata], {})
+          }
+        end
+      ]
+    end
+
+    private
+
+    # Build metadata
+    #
+    # @param [Hash{Symbol => Object}] custom_metadata
+    #   the custom metadata
+    # @param [#merge] defaults
+    #   the defaults to merge with
+    #
+    # @return [Slideck::Metadata]
+    #
+    # @api private
+    def build_metadata(custom_metadata, defaults)
+      @metadata.from(@metadata_converter, custom_metadata, defaults)
+    end
+  end # MetadataWrapper
+end # Slideck

data/lib/slideck/parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Slideck
+  # Responsible for extracting metadata and slides from content
+  #
+  # @api private
+  class Parser
+    # The pattern to detect metadata configuration
+    #
+    # @return [Regexp]
+    #
+    # @api private
+    METADATA_PATTERN = /^\s*:?[^:]+:[^:]+/.freeze
+    private_constant :METADATA_PATTERN
+
+    # The pattern to detect slide separator
+    #
+    # @return [Regexp]
+    #
+    # @api private
+    SLIDE_SEPARATOR = /\n?-{3,}([^\n]*)\n/.freeze
+    private_constant :SLIDE_SEPARATOR
+
+    # The pattern to match entire lines
+    #
+    # @return [Regexp]
+    #
+    # @api private
+    LINE_PATTERN = /^[^\n]+$/.freeze
+    private_constant :LINE_PATTERN
+
+    # Create a Parser instance
+    #
+    # @example
+    #   Parser.new(StringScanner, Slideck::MetadataParser)
+    #
+    # @param [StringScanner] string_scanner
+    #   the content scanner
+    # @param [Slideck::MetadataParser] metadata_parser
+    #   the metadata parser
+    #
+    # @api public
+    def initialize(string_scanner, metadata_parser)
+      @string_scanner = string_scanner
+      @metadata_parser = metadata_parser
+    end
+
+    # Parse metadata and slides from content
+    #
+    # @example
+    #   parser.parse("align: center\n---\nSlide1\n---\nSlide2\n---")
+    #
+    # @param [String] content
+    #   the content to parse slides from
+    #
+    # @return [Hash{Symbol => Hash, Array<String>}]
+    #   the metadata and slides content
+    #
+    # @api public
+    def parse(content)
+      scanner = @string_scanner.new(content)
+      slides = split_into_slides(scanner)
+      metadata = extract_metadata(slides.first && slides.first[:content])
+
+      {metadata: metadata, slides: metadata.empty? ? slides : slides[1..-1]}
+    end
+
+    private
+
+    # Split content into slides
+    #
+    # @param [StringScanner] scanner
+    #   the slides content scanner
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    def split_into_slides(scanner)
+      slides, slide, slide_metadata = [], [], {}
+
+      until scanner.eos?
+        if scanner.scan(SLIDE_SEPARATOR)
+          slides = add_slide(slides, slide.join, slide_metadata)
+          slide_metadata = extract_metadata(scanner[1])
+          slide.clear
+        elsif scanner.scan(LINE_PATTERN)
+          slide << scanner.matched
+        else
+          slide << scanner.getch
+        end
+      end
+
+      add_slide(slides, slide.join.chomp, slide_metadata)
+    end
+
+    # Add a slide to slides
+    #
+    # @param [Array<String>] slides
+    #   the slides array
+    # @param [String] slide
+    #   the slide to add to slides
+    # @param [Hash{String, Symbol => Object}] slide_metadata
+    #   the slide metadata
+    #
+    # @return [Array<Hash{Symbol => Hash, String}>]
+    #
+    # @api private
+    def add_slide(slides, slide, slide_metadata)
+      return slides if slide.empty?
+
+      slides + [{content: slide, metadata: slide_metadata}]
+    end
+
+    # Extract metadata from a slide
+    #
+    # @param [String, nil] slide
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def extract_metadata(slide)
+      return {} if slide.nil? || !metadata_given?(slide)
+
+      @metadata_parser.parse(slide)
+    end
+
+    # Check whether or not metadata is given
+    #
+    # @param [String] content
+    #   the slide content to check
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def metadata_given?(content)
+      !(content.lines.first =~ METADATA_PATTERN).nil?
+    end
+  end # Parser
+end # Slideck

data/lib/slideck/presenter.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Slideck
+  # Responsible for presenting slides
+  #
+  # @api private
+  class Presenter
+    # Terminal screen size change signal
+    #
+    # @return [String]
+    #
+    # @api private
+    TERM_SCREEN_SIZE_CHANGE_SIG = "WINCH"
+    private_constant :TERM_SCREEN_SIZE_CHANGE_SIG
+
+    # Create a Presenter
+    #
+    # @param [TTY::Reader] reader
+    #   the keyboard input reader
+    # @param [Slideck::Renderer] renderer
+    #   the slides renderer
+    # @param [Slideck::Tracker] tracker
+    #   the tracker for slides
+    # @param [TTY::Screen] screen
+    #   the terminal screen size
+    # @param [IO] output
+    #   the output stream for the slides
+    # @param [Proc] reloader
+    #   the metadata and slides reloader
+    #
+    # @api public
+    def initialize(reader, renderer, tracker, screen, output, &reloader)
+      @reader = reader
+      @renderer = renderer
+      @tracker = tracker
+      @screen = screen
+      @output = output
+      @reloader = reloader
+      @stop = false
+      @buffer = []
+    end
+
+    # Reload presentation
+    #
+    # @example
+    #   presenter.reload
+    #
+    # @return [Slideck::Presenter]
+    #
+    # @api public
+    def reload
+      @metadata, @slides = *@reloader.()
+      @tracker = @tracker.resize(@slides.size)
+      self
+    end
+
+    # Start presentation
+    #
+    # @example
+    #   presenter.start
+    #
+    # @return [void]
+    #
+    # @api public
+    def start
+      reload
+      @reader.subscribe(self)
+      hide_cursor
+      subscribe_to_screen_resize { resize.render }
+
+      until @stop
+        render
+        @reader.read_keypress
+      end
+    ensure
+      show_cursor
+    end
+
+    # Stop presentation
+    #
+    # @example
+    #   presenter.stop
+    #
+    # @return [Slideck::Presenter]
+    #
+    # @api public
+    def stop
+      @stop = true
+      self
+    end
+
+    # Render presentation on cleared screen
+    #
+    # @example
+    #   presenter.render
+    #
+    # @return [void]
+    #
+    # @api public
+    def render
+      clear_screen
+      render_slide
+    end
+
+    # Clear terminal screen
+    #
+    # @return [void]
+    #
+    # @api private
+    def clear_screen
+      @output.print @renderer.clear
+    end
+
+    # Render the current slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def render_slide
+      @output.print @renderer.render(
+        @metadata,
+        @slides[@tracker.current],
+        @tracker.current + 1,
+        @tracker.total)
+    end
+
+    # Hide cursor
+    #
+    # @return [void]
+    #
+    # @api private
+    def hide_cursor
+      @output.print @renderer.cursor.hide
+    end
+
+    # Show cursor
+    #
+    # @return [void]
+    #
+    # @api private
+    def show_cursor
+      @output.print @renderer.cursor.show
+    end
+
+    # Subscribe to the terminal screen size change signal
+    #
+    # @param [Proc] resizer
+    #   the presentation resizer
+    #
+    # @return [void]
+    #
+    # @api private
+    def subscribe_to_screen_resize(&resizer)
+      return if @screen.windows?
+
+      Signal.trap(TERM_SCREEN_SIZE_CHANGE_SIG, &resizer)
+    end
+
+    # Resize presentation
+    #
+    # @return [Slideck::Presenter]
+    #
+    # @api private
+    def resize
+      @renderer = @renderer.resize(@screen.width, @screen.height)
+      self
+    end
+
+    # Handle a keypress event
+    #
+    # @param [TTY::Reader::KeyEvent] event
+    #   the key event
+    #
+    # @return [void]
+    #
+    # @api private
+    def keypress(event)
+      case event.value
+      when "n", "l" then keyright
+      when "p", "h" then keyleft
+      when "f", "^" then go_to_first
+      when "t", "$" then go_to_last
+      when "g" then go_to_slide
+      when /\d/ then add_to_buffer(event.value)
+      when "r" then keyctrl_l
+      when "q" then keyctrl_x
+      end
+    end
+
+    # Navigate to the next slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def keyright(*)
+      @tracker = @tracker.next
+    end
+    alias keyspace keyright
+    alias keypage_down keyright
+
+    # Navigate to the previous slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def keyleft(*)
+      @tracker = @tracker.previous
+    end
+    alias keybackspace keyleft
+    alias keypage_up keyleft
+
+    # Reload presentation
+    #
+    # @return [void]
+    #
+    # @api private
+    def keyctrl_l(*)
+      reload
+    end
+
+    # Exit presentation
+    #
+    # @return [void]
+    #
+    # @api private
+    def keyctrl_x(*)
+      clear_screen
+      stop
+    end
+    alias keyescape keyctrl_x
+
+    # Navigate to the fist slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def go_to_first
+      @tracker = @tracker.first
+    end
+
+    # Navigate to the last slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def go_to_last
+      @tracker = @tracker.last
+    end
+
+    # Navigate to a given slide
+    #
+    # @return [void]
+    #
+    # @api private
+    def go_to_slide
+      @tracker = @tracker.go_to(@buffer.join.to_i - 1)
+      @buffer.clear
+    end
+
+    # Add to the input buffer
+    #
+    # @param [String] input_key
+    #   the input key
+    #
+    # @return [void]
+    #
+    # @api private
+    def add_to_buffer(input_key)
+      @buffer += [input_key]
+    end
+  end # Presenter
+end # Slideck