rosetta-ruby 0.0.0

data/lib/rosetta/services/tree_parser.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/service_base'
+require './lib/rosetta/tokens/basic_list_item'
+require './lib/rosetta/tokens/code_block_delimiter'
+require './lib/rosetta/tokens/code_block'
+require './lib/rosetta/tokens/header'
+require './lib/rosetta/tokens/break'
+require './lib/rosetta/tokens/line_break'
+require './lib/rosetta/tokens/link'
+require './lib/rosetta/tokens/numbered_list_item'
+require './lib/rosetta/tokens/paragraph'
+require './lib/rosetta/tokens/block_quote'
+require './lib/rosetta/tokens/quote'
+require './lib/rosetta/tokens/text'
+require './lib/rosetta/tokens/basic_token'
+require './lib/rosetta/tokens/basic_list'
+require './lib/rosetta/tokens/numbered_list'
+require './lib/rosetta/tokens/block_token'
+require './lib/rosetta/tokens/new_line'
+
+# Parse tokens into AST structure.
+class TreeParser < ServiceBase
+  BLOCK_TOKEN_TYPES = {
+    QUOTE: BlockQuote,
+    BASIC_LIST_ITEM: BasicList,
+    NUMBERED_LIST_ITEM: NumberedList
+  }.freeze
+
+  def initialize(tokens)
+    @tokens = tokens
+    @counter = 0
+  end
+
+  # TODO: Investigate if this can be done without declaring and mutating the array.
+  def call
+    parsed_tree = []
+    parsed_tree << consume_next_block until end_of_file?
+
+    parsed_tree.compact
+  end
+
+  private
+
+  def consume_next_block
+    block_types = BLOCK_TOKEN_TYPES.keys + [:CODE_BLOCK_DELIMITER]
+
+    if block_types.include?(current_token.type)
+      handle_generic_block_types(current_token.type)
+    elsif current_token.type == :LINE_BREAK
+      match_break
+    elsif current_token.inline?
+      match_paragraph
+    else
+      consume_current_token
+    end
+  end
+
+  def current_token
+    @tokens[@counter]
+  end
+
+  def next_token
+    @tokens[@counter + 1]
+  end
+
+  def match_break
+    if next_token.type == :LINE_BREAK
+      @counter += 2
+      Break.new
+    else
+      @counter += 1
+      # We don't want to insert newlines all the time, the desired
+      # insertion is handled in paragraph grouping.
+      nil
+    end
+  end
+
+  def handle_generic_block_types(token_type)
+    return match_code_block if token_type == :CODE_BLOCK_DELIMITER
+
+    group_siblings_into_block(token_type)
+  end
+
+  def group_siblings_into_block(block_type)
+    block_class = BLOCK_TOKEN_TYPES[block_type]
+
+    child_tokens = []
+    child_tokens << consume_current_token while !end_of_file? && current_token.type == block_type
+
+    block_class.new(child_tokens)
+  end
+
+  def match_paragraph
+    child_tokens = []
+
+    while !end_of_file? && (current_token.inline? || current_token.type == :NEW_LINE)
+      child_tokens << consume_current_token
+    end
+
+    Paragraph.new(child_tokens)
+  end
+
+  def match_code_block
+    @counter += 1
+    child_tokens = []
+
+    while !end_of_file? && current_token.type != :CODE_BLOCK_DELIMITER
+      child_tokens << current_token
+      @counter += 1
+    end
+
+    @counter += 1 unless end_of_file?
+    CodeBlock.new(child_tokens)
+  end
+
+  def consume_current_token
+    frozen_current_token = current_token
+    @counter += 1
+    frozen_current_token
+  end
+
+  def end_of_file?
+    @counter > @tokens.length - 1
+  end
+end

data/lib/rosetta/tokens/basic_list.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/block_token'
+
+# Handles logic for Paragraph tokens
+class BasicList < BlockToken
+  def type
+    :BASIC_LIST
+  end
+end

data/lib/rosetta/tokens/basic_list_item.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+
+# Handles logic for Header tokens
+class BasicListItem < BasicToken
+  def self.matches?(text)
+    text.start_with?('* ') || text.start_with?('- ')
+  end
+
+  def type
+    :BASIC_LIST_ITEM
+  end
+
+  def value
+    # If the code reaches here we know the first 2 chars are the list delimiter.
+    @source_text[2..-1]
+  end
+end

data/lib/rosetta/tokens/basic_token.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'byebug'
+
+# Holds logic and information for basic token management.
+class BasicToken
+  TOP_LEVEL_CLASS_NAMES = [
+    :Header, :LineBreak, :Quote, :CodeBlockDelimiter, :BasicListItem, :NumberedListItem, :Link
+  ].freeze
+
+  INLINE_CLASS_NAMES = [:Bold, :Italics, :Strikethrough, :InlineCode, :Link].freeze
+
+  attr_reader :source_text
+
+  def initialize(source_text)
+    @source_text = source_text
+  end
+
+  def to_s
+    "<Token type='#{type}' value='#{value}'>"
+  end
+
+  def node_representation
+    "<#{type} value='#{value}'>"
+  end
+
+  def type
+    raise 'Subclass should handle type.'
+  end
+
+  def value
+    raise 'Subclass should handle value.'
+  end
+
+  def accept(visitor)
+    method_name = "generate_#{type.to_s.downcase}"
+    visitor.send(method_name.to_sym, self)
+  end
+
+  # TODO: Make references to token type constant everywhere
+  def inline?
+    INLINE_CLASS_NAMES.include?(camel_case_type) || type == :TEXT
+  end
+
+  private
+
+  def camel_case_type
+    # Example: :INLINE_CODE -> :InlineCode
+    type.to_s.downcase.split('_').map(&:downcase).map(&:capitalize).join.to_sym
+  end
+end

data/lib/rosetta/tokens/block_quote.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/block_token'
+
+# Handles logic for Paragraph tokens
+class BlockQuote < BlockToken
+  def type
+    :BLOCK_QUOTE
+  end
+end

data/lib/rosetta/tokens/block_token.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Holds logic and information for block token management.
+class BlockToken
+  attr_reader :children
+
+  def initialize(tokens)
+    @children = tokens
+  end
+
+  def to_s
+    "<Token type='#{type}' child_count='#{children.count}' children='#{children}'>"
+  end
+
+  def node_representation
+    opening_tag = "<#{type} child_count=#{children.count}>"
+    closing_tag = "<#{type} />"
+
+    contents = children.map { |token| "  #{token.node_representation}" }.join("\n")
+
+    "#{opening_tag}\n#{contents}\n#{closing_tag}"
+  end
+
+  def type
+    raise 'Subclass should handle #type.'
+  end
+
+  def value
+    raise 'Subclass should handle #value.'
+  end
+
+  def accept(visitor)
+    method_name = "generate_#{type.to_s.downcase}"
+    visitor.send(method_name.to_sym, self)
+  end
+end

data/lib/rosetta/tokens/bold.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+require './lib/rosetta/tokens/shared/inline_tokens'
+
+# Handles logic for Bold tokens
+class Bold < BasicToken
+  extend Shared::InlineTokens
+
+  DELIMITER_TOKEN = '*'
+
+  def type
+    :BOLD
+  end
+
+  def value
+    return DELIMITER_TOKEN * 2 if @source_text == DELIMITER_TOKEN * 2
+
+    @source_text[self.class.delimiter_length...-self.class.delimiter_length]
+  end
+end

data/lib/rosetta/tokens/break.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+
+# Handles logic for Break tokens
+class Break < BasicToken
+  def self.matches?(text)
+    text == ''
+  end
+
+  def initialize; end
+
+  def type
+    :BREAK
+  end
+
+  def value
+    nil
+  end
+end

data/lib/rosetta/tokens/code_block.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/block_token'
+
+# Handles logic for Code Block tokens
+class CodeBlock < BlockToken
+  def type
+    :CODE_BLOCK
+  end
+end

data/lib/rosetta/tokens/code_block_delimiter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+
+# Handles logic for Header tokens
+class CodeBlockDelimiter < BasicToken
+  def self.matches?(text)
+    text == '```'
+  end
+
+  def type
+    :CODE_BLOCK_DELIMITER
+  end
+
+  def value
+    nil
+  end
+end

data/lib/rosetta/tokens/header.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+
+# Handles logic for Header tokens
+class Header < BasicToken
+  def self.matches?(text)
+    return false unless text[0] == '#'
+
+    text.chars.each do |char|
+      next if char == '#'
+
+      return char == ' '
+    end
+  end
+
+  def initialize(source_text)
+    super(source_text)
+    @depth = determine_depth
+  end
+
+  def type
+    "HEADER_#{@depth}".to_sym
+  end
+
+  def value
+    @value ||= extract_value_from_text
+  end
+
+  private
+
+  def extract_value_from_text
+    prefix = "#{'#' * @depth} "
+    @source_text.delete_prefix(prefix)
+  end
+
+  def determine_depth
+    depth = 0
+    depth += 1 while @source_text[depth] == '#'
+    depth
+  end
+end

data/lib/rosetta/tokens/inline_code.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+require './lib/rosetta/tokens/shared/inline_tokens'
+
+# Handles logic for Inline Code tokens
+class InlineCode < BasicToken
+  extend Shared::InlineTokens
+
+  DELIMITER_TOKEN = '`'
+
+  def self.delimiter_length
+    DELIMITER_TOKEN.length
+  end
+
+  def type
+    :INLINE_CODE
+  end
+
+  def value
+    return DELIMITER_TOKEN * 2 if @source_text == DELIMITER_TOKEN * 2
+
+    @source_text[self.class.delimiter_length...-self.class.delimiter_length]
+  end
+end

data/lib/rosetta/tokens/italics.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+require './lib/rosetta/tokens/shared/inline_tokens'
+
+# Handles logic for Italics tokens
+class Italics < BasicToken
+  extend Shared::InlineTokens
+
+  DELIMITER_TOKEN = '_'
+
+  def type
+    :ITALICS
+  end
+
+  def value
+    return DELIMITER_TOKEN * 2 if @source_text == DELIMITER_TOKEN * 2
+
+    @source_text[self.class.delimiter_length...-self.class.delimiter_length]
+  end
+end

data/lib/rosetta/tokens/line_break.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require './lib/rosetta/tokens/basic_token'
+
+# Handles logic for Line Break tokens
+class LineBreak < BasicToken
+  def self.matches?(text)
+    text == ''
+  end
+
+  def type
+    :LINE_BREAK
+  end
+
+  def value
+    nil
+  end
+end