cosensee 0.6.0

data/lib/cosensee/line_parser.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cosensee
+  # parse a line
+  class LineParser
+    INDENT_PATTERN = /\A([\t ]*)(.*)\z/
+    QUOTE_PATTERN = /\A(>)(.*)\z/
+    CODEBLOCK_PATTERN = /\A(code:)(.+)\z/
+    COMMANDLINE_PATTERN = /\A([$%]) (.+)\z/
+
+    def self.parse(line)
+      new.parse(line)
+    end
+
+    def initialize
+      @bracket_parser = Cosensee::BracketParser.new
+    end
+
+    def parse(line)
+      parsed_line = ParsedLine.new(rest: line)
+      parsed_line
+        .then { parse_indent(it) }
+        .then { parse_whole_line(it) }
+        .then { parse_code(it) }
+        .then { parse_double_bracket(it) }
+        .then { parse_bracket(it) }
+        .then { parse_url(it) }
+        .then { parse_hashtag(it) }
+        .then { done_parsing(it) }
+    end
+
+    def parse_indent(line)
+      matched = line.match(INDENT_PATTERN)
+      ParsedLine.new(indent: Cosensee::Indent.new(matched[1], matched[1]),
+                     rest: matched[2])
+    end
+
+    def parse_whole_line(line)
+      # parse quote
+      matched = line.match(QUOTE_PATTERN)
+      if matched
+        line.update(rest: matched[2],
+                    line_content: Cosensee::Quote.new(content: nil, raw: matched[0], mark: matched[1]))
+        return line
+      end
+
+      # parse codeblock
+      matched = line.match(CODEBLOCK_PATTERN)
+      if matched
+        return line.update(rest: nil,
+                           line_content: Cosensee::Codeblock.new(content: matched[2], raw: matched[0]),
+                           parsed: true)
+      end
+
+      # parse command line
+      matched = line.match(COMMANDLINE_PATTERN)
+      if matched
+        return line.update(rest: nil,
+                           line_content: Cosensee::CommandLine.new(content: matched[2],
+                                                                   prompt: matched[1],
+                                                                   raw: matched[0]),
+                           parsed: true)
+      end
+
+      line
+    end
+
+    def parse_code(line)
+      return line if line.parsed?
+
+      parsed = []
+      strs = line.split_rest_by('`')
+      loop do
+        str = strs.shift
+        unless str
+          return line.update(rest: nil,
+                             content: parsed)
+        end
+
+        parsed << str
+
+        str = strs.shift
+        unless str
+          line.update(rest: nil,
+                      content: parsed)
+          return line
+        end
+
+        if strs.empty?
+          parsed.last.concat("`#{str}")
+          return line.update(rest: nil,
+                             content: parsed)
+        else
+          parsed << Code.new(str, "`#{str}`")
+        end
+      end
+    end
+
+    def parse_hashtag(line)
+      return line if line.parsed?
+
+      parsed = []
+
+      line.content.each do |elem|
+        if elem.is_a?(String)
+          loop do
+            matched = elem.match(/(^|\s)#(\S+)/)
+            if matched
+              parsed << "#{matched.pre_match}#{matched[1]}"
+              parsed << Cosensee::HashTag.new(content: matched[2], raw: "##{matched[2]}")
+              elem = matched.post_match
+            else
+              parsed << elem
+              break # loop
+            end
+          end
+        else
+          parsed << elem
+        end
+      end
+
+      line.update(content: clean_elements(parsed))
+    end
+
+    def parse_url(line)
+      return line if line.parsed?
+
+      parsed = []
+
+      line.content.each do |elem|
+        if elem.is_a?(String)
+          loop do
+            matched = elem.match(%r{(^|\s)(https?://[^\s]+)})
+            if matched
+              parsed << "#{matched.pre_match}#{matched[1]}"
+              parsed << Cosensee::Link.new(matched[2], matched[2])
+              elem = matched.post_match
+            else
+              parsed << elem
+              break # loop
+            end
+          end
+        else
+          parsed << elem
+        end
+      end
+
+      line.update(content: clean_elements(parsed))
+    end
+
+    def parse_double_bracket(line)
+      return line if line.parsed?
+
+      parsed = []
+
+      line.content.each do |elem|
+        if elem.is_a?(String)
+          loop do
+            matched = elem.match(/\[\[(.+?)\]\]/)
+            if matched
+              parsed << matched.pre_match
+              parsed << Cosensee::DoubleBracket.new(content: [matched[1]], raw: matched[0])
+              elem = matched.post_match
+            else
+              parsed << elem
+              break # loop
+            end
+          end
+        else
+          parsed << elem
+        end
+      end
+
+      line.update(content: clean_elements(parsed))
+    end
+
+    def parse_bracket(line)
+      return line if line.parsed?
+
+      parsed = []
+      stack = nil
+      target_char = '[' # or "]"
+
+      line.content.each do |elem|
+        case elem
+        when Cosensee::Code, Cosensee::DoubleBracket
+          if target_char == '['
+            parsed << elem
+          else
+            stack << elem
+          end
+        else # elem is String
+          loop do
+            n = elem.index(target_char)
+            if n
+              if target_char == '['
+                parsed << elem[0, n]
+                target_char = ']'
+                stack = []
+              else
+                stack << elem[0, n]
+                target_char = '['
+                parsed << @bracket_parser.parse(stack)
+                stack = nil
+              end
+              elem = elem[(n + 1)..]
+            else
+              if target_char == '['
+                parsed << elem
+              else
+                stack << elem
+              end
+              break
+            end
+          end
+        end
+      end
+
+      if stack
+        # parsed += ['['] + stack
+        parsed << '['
+        parsed.concat(stack)
+      end
+
+      line.update(content: clean_elements(parsed))
+    end
+
+    def done_parsing(line)
+      # If the line_content is Cosensee::Quote, move content into it.
+      if line.line_content.is_a?(Cosensee::Quote)
+        new_quote = line.line_content.replace_content(line.content)
+        line.update(line_content: new_quote, content: [])
+      end
+      line.update(parsed: true)
+    end
+
+    def clean_elements(elements)
+      fixed = []
+      elements.each do |elem|
+        last_elem = fixed.last
+        if last_elem.is_a?(String) && elem.is_a?(String)
+          fixed[-1] = "#{last_elem}#{elem}"
+        else
+          fixed << elem
+        end
+      end
+
+      fixed.filter { |elem| !elem.nil? && elem != '' }
+    end
+  end
+end

data/lib/cosensee/link.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cosensee
+  # link node
+  Link = Data.define(:content, :raw) do
+    alias_method :to_s, :raw
+
+    def to_obj
+      content
+    end
+
+    def to_json(*)
+      to_obj.to_json(*)
+    end
+  end
+end

data/lib/cosensee/link_encodable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Cosensee
+  # parser of Bracket
+  module LinkEncodable
+    UNESCAPED_REGEX = /[A-Za-z0-9!"\$&'\(\)\-\~@+;:*<>,._]/
+
+    def make_link(anchor)
+      "#{encode_link(anchor)}.html"
+    end
+
+    def encode_link(str)
+      str.chars.map do |char|
+        if char.match?(UNESCAPED_REGEX)
+          char
+        elsif char == ' '
+          '_'
+        else
+          URI.encode_www_form_component(char)
+        end
+      end.join
+    end
+  end
+end

data/lib/cosensee/page.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'json'
+# require 'uri'
+
+module Cosensee
+  # for Page
+  Page = Data.define(:id, :title, :created, :updated, :views, :lines) do
+    def self.from_array(args_list)
+      args_list.map { |args| new(**args) }
+    end
+
+    def self.from_hash(obj)
+      new(**obj)
+    end
+
+    def initialize(id:, title:, created:, updated:, views:, lines:)
+      @parsed_lines = Cosensee::Line.from_array(lines.drop(1)).map(&:parsed)
+      @linking_page_titles = @parsed_lines.map(&:internal_links).flatten
+
+      super(
+        id:,
+        title:,
+        created: Time.at(created),
+        updated: Time.at(updated),
+        views:,
+        lines:
+      )
+    end
+
+    attr_accessor :parsed_lines, :linking_page_titles
+
+    def body_lines
+      lines.drop(1)
+    end
+
+    def some_images?
+      lines.any?(&:some_image?)
+    end
+
+    def first_image
+      lines.find(&:some_image?)&.first_image
+    end
+
+    def link_path
+      # body = URI.encode_www_form_component(title.gsub(/ /, '_'))
+      body = title.gsub(/ /, '_').gsub('/', '%2F')
+
+      "#{body}.html"
+    end
+
+    def to_html
+      Cosensee::TailwindRenderer.new(content: self).render
+    end
+
+    def to_obj
+      { id:, title:, created: created.to_i, updated: updated.to_i, views:, lines: }
+    end
+
+    def to_json(*)
+      to_obj.to_json(*)
+    end
+
+    def inspect
+      "#<data Cosensee::Page id: #{id}, title: #{title}>"
+    end
+  end
+end

data/lib/cosensee/page_store.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+# require 'uri'
+
+module Cosensee
+  # To search for pages
+  class PageStore
+    def initialize(project:)
+      @project = project
+      @pages = project.pages
+      @pages_by_title = nil
+      @linking_pages = nil
+      @linked_pages = nil
+    end
+
+    def pages_by_title
+      @pages_by_title ||= create_title_index(@pages)
+    end
+
+    def linking_pages
+      setup_link_indexes unless @linking_pages
+
+      @linking_pages
+    end
+
+    def linked_pages
+      setup_link_indexes unless @linked_pages
+
+      @linked_pages
+    end
+
+    def title_exist?(title)
+      !!pages_by_title[title]
+    end
+
+    def orphan_page_titles
+      linked_pages.keys.reject { |title| title_exist?(title) }
+    end
+
+    def create_title_index(pages)
+      pages.each_with_object({}) do |page, hash|
+        hash[page.title] = page
+      end
+    end
+
+    def find_link_pages_by_title(title)
+      pages = linking_pages[title] + linked_pages[title]
+      pages.sort_by(&:updated)
+    end
+
+    def setup_link_indexes
+      @linking_pages = Hash.new { |h, k| h[k] = [] }
+      @linked_pages = Hash.new { |h, k| h[k] = [] }
+      @project.pages.each do |page|
+        page.linking_page_titles.each do |linking_title|
+          @linking_pages[page.title] << pages_by_title[linking_title] if pages_by_title[linking_title]
+          @linked_pages[linking_title] << page
+        end
+      end
+    end
+  end
+end

data/lib/cosensee/parsed_bracket.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cosensee
+  # parse a line
+  class ParsedBracket
+    def initialize(content: [])
+      @content = content
+      @parsed = false
+    end
+
+    attr_accessor :content
+
+    def parsed?
+      @parsed
+    end
+
+    def update(**attributes)
+      attributes.each do |key, value|
+        # Check if the key is a valid accessor
+        raise ArgumentError, "Attribute #{key} is not allowed to be updated." unless self.class.method_defined?("#{key}=")
+
+        public_send("#{key}=", value)
+      end
+
+      self
+    end
+
+    def single_text?
+      content.size == 1 && content.first.is_a?(String)
+    end
+
+    def first_content
+      content.first
+    end
+
+    def ==(other)
+      other.is_a?(Cosensee::ParsedBracket) &&
+        other.content == content &&
+        other.parsed? == parsed?
+    end
+  end
+end

data/lib/cosensee/parsed_line.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Cosensee
+  # parse a line
+  class ParsedLine
+    def initialize(indent: nil, line_content: nil, content: [], rest: nil, parsed: false)
+      @indent = indent
+      @line_content = line_content
+      @content = content
+      @rest = rest
+      @parsed = parsed
+    end
+
+    attr_accessor :indent, :line_content, :content, :rest, :parsed
+
+    def codeblock?
+      line_content.is_a?(Cosensee::Codeblock)
+    end
+
+    def parsed?
+      @parsed
+    end
+
+    def rest?
+      !!rest
+    end
+
+    def line_content?
+      !!line_content
+    end
+
+    def indent_level
+      indent.level
+    end
+
+    def match(pattern)
+      rest.match(pattern)
+    end
+
+    def split_rest_by(str)
+      rest.split(str, -1)
+    end
+
+    def update(**attributes)
+      attributes.each do |key, value|
+        # Check if the key is a valid accessor
+        raise ArgumentError, "Attribute #{key} is not allowed to be updated." unless self.class.method_defined?("#{key}=")
+
+        public_send("#{key}=", value)
+      end
+
+      self
+    end
+
+    def internal_links
+      content.select { |c| c.is_a?(Cosensee::InternalLinkBracket) || c.is_a?(Cosensee::HashTag) }.map(&:anchor)
+    end
+
+    def raw
+      if line_content?
+        "#{indent.raw}#{line_content.raw}"
+      else
+        "#{indent.raw}#{content.map(&:to_s).join}"
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Cosensee::ParsedLine) &&
+        other.indent == indent &&
+        other.line_content == line_content &&
+        other.content == content &&
+        other.rest == rest &&
+        other.parsed? == parsed?
+    end
+  end
+end

data/lib/cosensee/project.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cosensee
+  # for Project
+  class Project
+    def self.parse(source)
+      json = JSON.parse(source, symbolize_names: true)
+      name, display_name, exported, users, pages = json.values_at(:name, :displayName, :exported, :users, :pages)
+      Cosensee::Project.new(name:, display_name:, exported:, users:, pages:, source:)
+    end
+
+    def self.parse_file(filename)
+      src = File.read(filename)
+      parse(src)
+    end
+
+    def initialize(name:, exported:, users:, pages:, source:, **kwargs)
+      @name = name
+      @display_name = if kwargs.keys.size == 1 && kwargs.key?(:display_name)
+                        kwargs[:display_name]
+                      elsif kwargs.keys.size == 1 && kwargs.key?(:displayName)
+                        kwargs[:displayName]
+                      else
+                        raise Cosensee::Error, 'Cosensee::User.new need an argument :display_name or :displayName'
+                      end
+      @users = Cosensee::User.from_array(users)
+      @pages = Cosensee::Page.from_array(pages)
+      @exported = Time.at(exported)
+      @source = source
+
+      @page_store = PageStore.new(project: self)
+    end
+
+    attr_reader :name, :display_name, :users, :pages, :exported, :source, :page_store
+
+    def to_obj
+      { name:, displayName: display_name, exported: exported.to_i, users:, pages: }
+    end
+
+    def to_json(*)
+      to_obj.to_json(*)
+    end
+  end
+end

data/lib/cosensee/quote.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cosensee
+  # for quote
+  Quote = Data.define(:content, :raw, :mark) do
+    alias_method :to_s, :raw
+
+    def replace_content(new_content)
+      Quote.new(content: new_content, raw:, mark:)
+    end
+
+    def to_obj
+      content
+    end
+
+    def to_json(*)
+      to_obj.to_json(*)
+    end
+  end
+end

data/lib/cosensee/tailwind_renderer/blank_bracket.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cosensee
+  class TailwindRenderer
+    BlankBracket = Data.define(:content) do
+      def render
+        %(<span>#{content.blank}</span>)
+      end
+    end
+  end
+end

data/lib/cosensee/tailwind_renderer/code.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cosensee
+  class TailwindRenderer
+    Code = Data.define(:content) do
+      include HtmlEncodable
+
+      def render
+        code = content.content
+        %(<code class="bg-gray-100 text-red-500 px-1 py-0.5 rounded">#{escape_html(code)}</code>)
+      end
+    end
+  end
+end

data/lib/cosensee/tailwind_renderer/codeblock_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cosensee
+  class TailwindRenderer
+    # connect parsed lines to a code block
+    class CodeblockBuilder
+      include HtmlEncodable
+
+      def initialize(parsed_line)
+        @first_line = parsed_line
+        @base_indent_level = parsed_line.indent_level
+        @lines = []
+      end
+
+      attr_reader :first_line, :lines, :base_indent_level
+
+      def append(parsed_line)
+        @lines << parsed_line
+      end
+
+      def continued_line?(parsed_line)
+        parsed_line.indent_level >= base_indent_level
+      end
+
+      def render
+        indent_level = base_indent_level * 2
+        title = first_line.line_content.content
+        <<~HTML_BLOCK
+          <div class="relative pl-[#{indent_level}rem]">
+            <div class="bg-orange-300 text-gray-900 px-4 py-1 rounded-t-lg font-mono text-sm">#{title}</div>
+            <div class="px-4 bg-gray-300 text-gray-900 rounded-b-lg shadow-md"><pre class="overflow-x-auto"><code class="block font-mono text-sm leading-relaxed">#{escape_html(lines.map(&:raw).join("\n"))}</code></pre></div>
+          </div>
+        HTML_BLOCK
+      end
+    end
+  end
+end

data/lib/cosensee/tailwind_renderer/command_line.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cosensee
+  class TailwindRenderer
+    CommandLine = Data.define(:content) do
+      include HtmlEncodable
+
+      def render
+        code = content.content
+        prompt = content.prompt
+        %(<code class="bg-gray-100 text-gray-800 px-4"><span class="text-red-400">#{prompt}</span>#{escape_html(code)}</code>)
+      end
+    end
+  end
+end