cosensee 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca076a9a5e18e0bd0f5c1825e35714536bcfad2921b8d3e997a3fe86140314b4
-  data.tar.gz: e28ec42e8750b9426275e78ba6b238b358217d8c97c7d95c1134a5f54f6f341c
+  metadata.gz: 8d86134550a97a17819c4280b1805d789f96d53eecbfb27ca62ef84a893d0064
+  data.tar.gz: 1e3fb5ffcc426841dd1a68a9b9b23fd9d42dcc0f8232545c97dfcf01ffbc60e5
 SHA512:
-  metadata.gz: 72a7eb0c65b77920c3b1784db4bf58f9d984c0f660dbda56cab55ac2ac91d83ecf3e47b08ffb413d08e1601180f1258adcb141470a1dcbe5b653bd8d77232d7b
-  data.tar.gz: 1a8bef01b367b5d8f665236e0940fb4cf823134d4cbe8a3955eab932cf76e63d21c9548b813acadfd16c5da57ee17a40cf350ed093e1c23f3955ede40862954f
+  metadata.gz: 73a4994a814da445c620e34ab927c5f0da3e22219a1189d588ae3361f89802f90b2e07d90e2b24239a4946d36d13b677302e01dd8cf60563aa04d558d555fc28
+  data.tar.gz: 4a519da076c4fafe6e82c4224c7358c1c2653d5ae95a1e64cef666c3b46cdcdcaa8020a6ba8adad4f9f77c10d9990143ccc96a7cbe94205d1f4010901b1320e9

data/.rubocop.yml

@@ -5,6 +5,7 @@ AllCops:
   NewCops: enable
 
 require:
+  - rubocop-factory_bot
   - rubocop-rake
   - rubocop-rspec
 
@@ -17,7 +18,7 @@ Layout/MultilineMethodCallIndentation:
   EnforcedStyle: indented_relative_to_receiver
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 80
 
 Metrics/ClassLength:
   Max: 300
@@ -32,11 +33,14 @@ Metrics/MethodLength:
   Max: 80
 
 Metrics/ParameterLists:
-  Max: 8
+  Max: 10
 
 Metrics/PerceivedComplexity:
   Max: 20
 
+Style/FetchEnvVar:
+  Enabled: false
+
 Style/MinMaxComparison:
   Enabled: false
 
@@ -52,5 +56,12 @@ RSpec/ExampleLength:
 RSpec/MultipleExpectations:
   Enabled: false
 
+RSpec/MultipleMemoizedHelpers:
+  Max: 7
+
 Style/NumericPredicate:
   Enabled: false
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+  EnforcedShorthandSyntax: always

data/README.md

@@ -14,19 +14,37 @@ If you use bundler, add to the application's Gemfile by executing:
 
 ## Usage
 
-To output HTML, specify the JSON file from Cosense as an argument and run `bin/build` with Cosense JSON dump file.
+First, create project directory and move to it.
 
-    $ bin/build <json file>
+    $ cosensee --init <project dir>
+    $ cd <project dir>
 
-The HTML files will be output to the .out directory. You can view them locally by using the bin/server command.
+To output HTML, specify the JSON file from Cosense as an argument and run `cosensee` with Cosense JSON page-data file.
 
-    $ $bin/server
+    $ cosensee -f <json file>
 
-By adding a Cosense JSON file as an argument, the build process will be executed before starting the server.
+If you want to output the HTML file to a directory other than `public`, use the `-d` option.
 
-    $ $bin/server <json file>
+The HTML files will be output to the `public` directory. You can view them locally by using the `-s` option.
 
-The default port used by bin/server is 1212.
+    $ cosensee -f <json file> -s
+
+The default port used by the local server is `1212`. If you want to change the port, use the `-p` option.
+
+    $ cosensee -f <json file> -s -p 3000
+
+You can also use the `-h` option to display the help message.
+
+    $ cosensee --help
+
+## Deploy
+
+Cosensee outputs static HTML and CSS files, so they can be deployed as-is.
+Use the tools and resources specific to the environment you want to deploy to.
+
+For example, in the case of Cloudflare Pages, you can deploy using [Wrangler](https://developers.cloudflare.com/workers/wrangler/) as follows:
+
+    $ npx wrangler pages deploy dist --project-name <cloudflare project name>
 
 ## Development
 

data/Rakefile

@@ -7,4 +7,4 @@ require 'rubocop/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new
 
-task default: :spec
+task default: %i[spec rubocop]

data/assets/js/search.js

@@ -0,0 +1,42 @@
+import Fuse from 'https://cdn.jsdelivr.net/npm/fuse.js@6.6.2/dist/fuse.esm.js';
+
+export function createSearch() {
+  return {
+    query: '',
+    results: [],
+    fuse: null,
+    lastResults: [],
+
+    async init() {
+      try {
+        const res = await fetch("/search.json");
+        if (!res.ok) {
+          throw new Error(`Error HTTP status: ${res.status}`);
+        }
+        const data = await res.json();
+        this.fuse = new Fuse(data, { keys: ["title", "summary"], threshold: 0.3 });
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    },
+
+    search() {
+      if (!this.fuse || this.query.trim() === '') {
+        this.clearResults();
+        return;
+      }
+      this.results = this.fuse.search(this.query);
+      this.lastResults = this.results;
+    },
+
+    clearResults() {
+      this.results = [];
+    },
+
+    restoreResults() {
+      if (this.query.trim() !== '' && this.lastResults.length > 0) {
+        this.results = this.lastResults;
+      }
+    },
+  };
+}

data/assets/styles/input.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

data/exe/cosensee

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'cosensee'
+
+require 'console'
+require 'dotenv'
+
+Dotenv.load
+logger = Console.logger
+
+option = Cosensee::CLI::Parser.parse(ARGV)
+exit 1 if option.failed?
+
+if option.init?
+  Cosensee::CLI::Initializer.new(option:, logger:).run
+  exit 0
+end
+
+begin
+  content_generator = Cosensee::WebContentGenerator.new(option:, renderer_class: Cosensee::TailwindRenderer, logger:, sid: ENV['CONNECT_SID'])
+  content_generator.generate
+rescue Cosensee::WebContentGenerator::Error => e
+  logger.error "Error: #{e.message}"
+  exit 1
+end
+
+exit 0 unless option.server?
+
+web_server = Cosensee::WebServer.new(
+  dir: option.output_dir,
+  server_url: "http://localhost:#{option.port}",
+  logger:
+)
+web_server.start

data/lib/cosensee/api/page_data.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+
+module Cosensee
+  module Api
+    # for page-data API
+    class PageData
+      def export(project_name:, sid:)
+        uri = "https://scrapbox.io/api/page-data/export/#{project_name}.json"
+        send_request(uri, sid)
+      end
+
+      def download(project_name:, sid:, filename:)
+        res = export(project_name:, sid:)
+
+        begin
+          File.binwrite(filename, res)
+        rescue SystemCallError => e
+          raise Cosensee::Error, "Failed to write to file '#{filename}': #{e.message}"
+        end
+      end
+
+      private
+
+      def send_request(uri, sid)
+        cookies = "connect.sid=#{sid}"
+        parsed_uri = URI.parse(uri)
+
+        begin
+          response = parsed_uri.open('Cookie' => cookies)
+          response.read
+        rescue OpenURI::HTTPError => e
+          raise Cosensee::Error, "HTTP error while accessing #{uri}: #{e.message}"
+        rescue SocketError => e
+          raise Cosensee::Error, "Network error: #{e.message}"
+        rescue URI::InvalidURIError => e
+          raise Cosensee::Error, "Invalid URI: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/cosensee/bracket_parser.rb

@@ -16,31 +16,37 @@ module Cosensee
 
       case content
       in [/\A\z/]
-        EmptyBracket.new(content:, raw: '[]')
+        Node::EmptyBracket.new(content:, raw: '[]')
       in [/\A([ \t]+)\z/]
-        BlankBracket.new(content:, blank: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
+        Node::BlankBracket.new(content:, blank: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
       in [/\A\$ (.*)\z/]
-        FormulaBracket.new(content:, formula: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
+        Node::FormulaBracket.new(content:, formula: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
       in [/\A(.*).icon\z/]
-        IconBracket.new(content:, icon_name: Regexp.last_match(1))
+        Node::IconBracket.new(content:, icon_name: Regexp.last_match(1), raw: Regexp.last_match(0))
+      in [%r{\A(https://www\.youtube\.com/watch\?v=([^&]+)(&.*)?)\z}]
+        Node::YoutubeBracket.new(content:, video_id: Regexp.last_match(2), raw: "[#{Regexp.last_match(0)}]")
       in [%r{\A(https?://[^\s]+)\s+(https?://[^\s\]]*\.(png|jpe?g|gif|svg|webp)(\?[^\s\]]+)?)\z}]
-        ImageBracket.new(content:, link: Regexp.last_match(1), src: Regexp.last_match(2), raw: "[#{Regexp.last_match(0)}]")
+        Node::ImageBracket.new(content:, link: Regexp.last_match(1), src: Regexp.last_match(2), raw: "[#{Regexp.last_match(0)}]")
       in [%r{\A(https?://[^\s\]]*\.(png|jpe?g|gif|svg|webp)(\?[^\s\]]+)?)\s+(https?://[^\s]+)\z}]
-        ImageBracket.new(content:, link: Regexp.last_match(4), src: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
+        Node::ImageBracket.new(content:, link: Regexp.last_match(4), src: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
       in [%r{\A(https?://[^\s\]]*\.(png|jpe?g|gif|svg|webp))\z}]
-        ImageBracket.new(content:, link: nil, src: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
+        Node::ImageBracket.new(content:, link: nil, src: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
+      in [%r{\A(https://gyazo.com/([0-9a-f]{32})(?:/raw)?)\z}]
+        Node::GyazoImageBracket.new(content:, link: nil, src: Regexp.last_match(1), image_id: Regexp.last_match(2), raw: "[#{Regexp.last_match(0)}]")
+      in [%r{\A(https://open.spotify.com/playlist/(\w+))\z}]
+        Node::SpotifyPlaylistBracket.new(content:, playlist_id: Regexp.last_match(2), src: Regexp.last_match(1), raw: "[#{Regexp.last_match(0)}]")
       in [%r{\A(https?://[^ \t]*)(\s+(.+))?\z}]
         # match_external_link_precede
         anchor = Regexp.last_match(3) || Regexp.last_match(1)
         link = Regexp.last_match(1)
         raw = "[#{Regexp.last_match(0)}]"
-        ExternalLinkBracket.new(content:, link:, anchor:, raw:)
+        Node::ExternalLinkBracket.new(content:, link:, anchor:, raw:)
       in [%r{\A((.*\S)\s+)?(https?://[^\s]+)\z}]
         # match_external_link_succeed
         anchor = Regexp.last_match(2) || Regexp.last_match(3)
         link = Regexp.last_match(3)
         raw = "[#{Regexp.last_match(0)}]"
-        ExternalLinkBracket.new(content:, link:, anchor:, raw:)
+        Node::ExternalLinkBracket.new(content:, link:, anchor:, raw:)
       in [%r{\A([_\*/\-"#%&'\(\)~\|\+<>{},\.]+) (.+)\z}]
         # match_decorate
         deco = Regexp.last_match(1)
@@ -49,7 +55,7 @@ module Cosensee
         underlined = deco.include?('_')
         deleted = deco.include?('-')
         slanted = deco.include?('/')
-        DecorateBracket.new(
+        Node::DecorateBracket.new(
           content:,
           font_size:,
           underlined:,
@@ -60,17 +66,16 @@ module Cosensee
         )
       else
         line_parser = LineParser.new
-        data = ParsedBracket.new(content:)
-        parsed = data
-                   .then { |d| line_parser.parse_url(d) }
-                   .then { |d| line_parser.parse_hashtag(d) }
+        parsed = ParsedBracket.new(content:)
+                   .then { line_parser.parse_url(it) }
         if parsed.single_text? && parsed.content == content
           anchor = parsed.first_content
           link = make_link(anchor)
           raw = raw_string
-          InternalLinkBracket.new(content:, link:, anchor:, raw:)
+          Node::InternalLinkBracket.new(content:, link:, anchor:, raw:)
         else
-          TextBracket.new(content: parsed.content, raw: raw_string)
+          parsed = parsed.then { line_parser.parse_hashtag(it) }
+          Node::TextBracket.new(content: parsed.content, raw: raw_string)
         end
       end
     end

data/lib/cosensee/bracket_serializer.rb

@@ -5,7 +5,9 @@ require 'json'
 module Cosensee
   # serializer for brackets
   module BracketSerializer
-    def to_s = raw
+    def to_s
+      content.map(&:to_s).join
+    end
 
     def to_obj
       unparsed = content.map do |elem|

data/lib/cosensee/cli/initializer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Cosensee
+  # for CLI
+  class CLI
+    # for initializer
+    class Initializer
+      def initialize(logger:, option:)
+        @logger = logger
+        @option = option
+      end
+
+      attr_reader :logger, :option
+
+      def run
+        logger.info 'Initializing...'
+        create_project_dir if option.init?
+        create_directories
+        create_files
+        logger.info 'Done!'
+      end
+
+      private
+
+      def create_project_dir
+        return if File.exist?(project_path)
+
+        FileUtils.mkdir_p(project_path)
+        logger.info "Created project directory: #{project_path}"
+      end
+
+      def create_directories
+        FileUtils.mkdir_p(project_path(option.output_dir))
+        FileUtils.mkdir_p(project_path(option.output_dir, option.css_dir))
+      end
+
+      def create_files
+        create_tailwind_config
+      end
+
+      def create_tailwind_config
+        return if File.exist?(project_path(Cosensee::TAILWIND_CONFIG_FILE))
+
+        logger.info 'Creating TailwindCSS config file...'
+        File.write(project_path(Cosensee::TAILWIND_CONFIG_FILE), <<~TAILWIND_CONFIG)
+          /** @type {import('tailwindcss').Config} */
+          module.exports = {
+            content: [
+              "dist/**/*.html"
+            ],
+            theme: {
+              extend: {},
+            },
+            plugins: [],
+          }
+        TAILWIND_CONFIG
+      end
+
+      def project_path(*relative_paths)
+        File.join(option.project_dir, *relative_paths)
+      end
+    end
+  end
+end

data/lib/cosensee/cli/option.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Cosensee
+  class CLI
+    # Option class for Cosensee::CLI
+    class Option
+      attr_accessor :port, :output_dir, :css_dir
+      attr_writer :failed, :server, :remote, :filename, :skip_tailwind_execution, :init, :clean
+
+      def initialize(filename: nil, remote: nil, port: DEFAULT_PORT, output_dir: DEFAULT_OUTPUT_DIR, css_dir: DEFAULT_CSS_DIR, server: nil, skip_tailwind_execution: false, init: nil, clean: false, base_url: nil)
+        @remote = remote
+        @filename = filename
+        @port = port
+        @output_dir = output_dir
+        @css_dir = css_dir
+        @server = server
+        @skip_tailwind_execution = skip_tailwind_execution
+        @failed = false
+        @clean = clean
+        @init = init
+        @base_url = base_url
+      end
+
+      def filename
+        @filename || ENV['COSENSEE_FILENAME']
+      end
+
+      def project_name
+        @remote || ENV['COSENSEE_PROJECT_NAME']
+      end
+
+      def base_url
+        @base_url || ENV['COSENSEE_BASE_URL']
+      end
+
+      def project_dir
+        @init || '.'
+      end
+
+      def remote?
+        !!@remote
+      end
+
+      def failed?
+        @failed
+      end
+
+      def server?
+        @server
+      end
+
+      def skip_tailwind_execution?
+        @skip_tailwind_execution
+      end
+
+      def clean?
+        @clean
+      end
+
+      def init?
+        !!@init
+      end
+    end
+  end
+end

data/lib/cosensee/cli/parser.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Cosensee
+  class CLI
+    # Parser class for Cosensee::CLI
+    class Parser
+      attr_reader :args, :option, :op
+
+      def self.parse(args)
+        new(args).parse
+      end
+
+      def initialize(args)
+        @args = args
+        @option = Option.new
+        @op = OptionParser.new
+      end
+
+      def parse
+        begin
+          op.banner = 'Usage: bin/build [-f <filename>] [-r <project_name>]'
+          op.version = Cosensee::VERSION
+
+          op.on('-f FILENAME', '--file FILENAME', 'Specify the file name') do |filename|
+            option.filename = filename
+          end
+          op.on('-r PROJECT_NAME', '--remote PROJECT_NAME', 'Retrieve the project pages file from the remote page-data API (with env var `CONNECT_SID`)') do |project_name|
+            option.remote = project_name
+          end
+          op.on('-p PORT', '--port PORT', "Specify port number of web server (default: #{DEFAULT_PORT})") do |port|
+            option.port = port
+          end
+          op.on('-d OUTPUT_DIR', '--dir OUTPUT_DIR', "Specify directory name of generated html files(default: #{DEFAULT_OUTPUT_DIR})") do |output_dir|
+            option.output_dir = output_dir
+          end
+          op.on('--css-dir CSS_DIR', "Specify directory name of generated html files(default: #{DEFAULT_CSS_DIR})") do |css_dir|
+            option.css_dir = css_dir
+          end
+          op.on('-s', '--server', 'Serves files by running a web server locally.') do
+            option.server = true
+          end
+
+          op.on('--skip-tailwind', 'Skip TailwindCSS execution') do
+            option.skip_tailwind_execution = true
+          end
+
+          op.on('--clean', 'Make dist directory clean') do
+            option.clean = true
+          end
+
+          op.on('--init PROJECT_DIR', 'Initialize the project with default files') do |project_dir|
+            option.init = project_dir
+          end
+
+          op.parse!(args)
+        rescue OptionParser::MissingArgument => e
+          return option_error("Error: option requires an argument: #{e.args.join(' ')}")
+        rescue OptionParser::InvalidOption => e
+          return option_error("Error: invalid option: #{e.args.join(' ')}")
+        end
+
+        if !option.filename && !option.server? && !option.init?
+          return option_error('Error: filename not found. You must specify -f, or use server with -s.')
+        elsif !option.filename && option.remote?
+          return option_error('Error: project_name not found. You must not specify project name -p without -f.')
+        end
+
+        option
+      end
+
+      private
+
+      def option_error(message)
+        puts message
+        puts op.help
+        option.failed = true
+        option
+      end
+    end
+  end
+end

data/lib/cosensee/delegatable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cosensee
+  # Add `delegate` method that delegate method calls to another object
+  #
+  # Usage:
+  #
+  # ```ruby
+  # class Foo
+  #   extend Delegatable
+  #
+  #   def initialize(bar)
+  #     @bar = bar
+  #   end
+  #
+  #   attr_reader :bar
+  #
+  #   delegate :buz, :baz, to: :bar
+  # end
+  # ```
+  #
+  #  This will define `buz` and `baz` method that call `bar.buz` and `bar.baz` respectively.
+  module Delegatable
+    def delegate(*methods, to:)
+      methods.each do |method|
+        define_method(method) do |*args, **kargs, &block|
+          target = send(to)
+          target.public_send(method, *args, **kargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/cosensee/html_builder.rb

@@ -8,16 +8,20 @@ require 'fileutils'
 module Cosensee
   # generate HTML files
   class HtmlBuilder
-    def initialize(project, root_dir: nil)
+    def initialize(project, output_dir: nil, css_dir: nil, base_url: nil)
       @project = project
       @templates_dir = File.join(__dir__, '../../templates')
-      @root_dir = root_dir || File.join(Dir.pwd, '.out')
-      FileUtils.mkdir_p(@root_dir)
+      @output_dir = output_dir || File.join(Dir.pwd, Cosensee::DEFAULT_OUTPUT_DIR)
+      @css_dir = css_dir || Cosensee::DEFAULT_CSS_DIR
+      @base_url = base_url
+      FileUtils.mkdir_p(@output_dir)
     end
 
-    attr_reader :project, :root_dir, :templates_dir
+    attr_reader :project, :output_dir, :css_dir, :templates_dir, :base_url
+
+    def build_all(clean: true)
+      purge_files if clean
 
-    def build_all
       build_index(project)
 
       # build all pages
@@ -26,34 +30,39 @@ module Cosensee
       end
 
       # build all orphan (title only) pages
-      project.page_store.orphan_page_titles.each do |title|
+      project.orphan_page_titles.each do |title|
         build_page_only_title(title)
       end
     end
 
     def build_index(project)
-      template = Tilt::ErubiTemplate.new(File.join(templates_dir, 'index.html.erb'))
-      output = template.render(nil, project:)
-      File.write(File.join(root_dir, 'index.html'), output)
+      render_html(src: 'index.html.erb', to: 'index.html', project:, css_dir:, base_url:)
     end
 
     def build_page(page)
-      template = Tilt::ErubiTemplate.new(File.join(templates_dir, 'page.html.erb'))
-      output = template.render(nil, project:, page:, title: page.title)
-      File.write(File.join(root_dir, page.link_path), output)
+      render_html(src: 'page.html.erb', to: page.link_path, project:, css_dir:, page:, title: page.title, base_url:)
     end
 
     def build_page_only_title(title)
-      path = File.join(root_dir, "#{title.gsub(/ /, '_').gsub('/', '%2F')}.html")
+      path = File.join(output_dir, "#{title.gsub(/ /, '_').gsub('/', '%2F')}.html")
       return if File.exist?(path)
 
-      template = Tilt::ErubiTemplate.new(File.join(templates_dir, 'page.html.erb'))
-      output = template.render(nil, project:, page: nil, title:)
+      # make a dummy page
+      page = Page.new(title:, id: 0, created: Time.now, updated: Time.now, views: 0, lines: [])
+
+      template = Tilt::ErubiTemplate.new(File.join(templates_dir, 'page.html.erb'), escape_html: true)
+      output = template.render(nil, project:, page:, title:, css_dir:, base_url:)
       File.write(path, output)
     end
 
-    def page_title(page)
-      "#{page.title} | #{project.title}"
+    def purge_files
+      FileUtils.rm_rf(Dir.glob("#{output_dir}/*.html"))
+    end
+
+    def render_html(src:, to:, **args)
+      template = Tilt::ErubiTemplate.new(File.join(templates_dir, src), escape_html: true)
+      output = template.render(nil, **args)
+      File.write(File.join(output_dir, to), output)
     end
   end
 end