synotion 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e245b18b4c8a491475b7a561d079ca31a5ccaeeb451fea9ab27e7cba62a768ee
+  data.tar.gz: 68e471af7154e8c488d983898bda7ad580a2adb64d599f167342bc47f6bc570a
+SHA512:
+  metadata.gz: 6a1a6879d09e30060b8b6c37d5d8a49cbfa52c60f3dec80199d30fd042c4d803c8bdcdc951837879d0fa4052eb41d61b4ed082b3c903f9e742f950792593f411
+  data.tar.gz: f1dc5845d7ca55c1ca7ea92367b709631837b0b60e985edf2f2420939ac0c3474afbcea57e7cf40a9ad45315f2115cdfd3e0596690d8b594c19a87ecc65324bf

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+- Initial release
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,167 @@
+# Synotion
+
+A Ruby gem to sync Markdown files to Notion pages.
+
+## Features
+
+- Multiple update modes: create, append, replace, or upsert pages
+- Flexible page identification by custom properties, filenames, or titles
+- Automatic Markdown to Notion blocks conversion
+- Command-line interface
+- YAML front matter support
+
+## Installation
+
+```bash
+gem install synotion
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'synotion'
+```
+
+## Quick Start
+
+1. Create a Notion integration at https://www.notion.so/my-integrations
+2. Share your database with the integration
+3. Run:
+
+```bash
+synotion sync README.md \
+  --api-key=secret_xxx \
+  --database-id=your-database-id
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Basic usage
+synotion sync README.md \
+  --api-key=$NOTION_API_KEY \
+  --database-id=your-database-id
+
+# Specify update mode
+synotion sync CHANGELOG.md \
+  --api-key=$NOTION_API_KEY \
+  --database-id=your-database-id \
+  --mode=append
+
+# Use config file
+synotion sync README.md --config=.notion-sync.yml
+```
+
+### Ruby API
+
+```ruby
+require 'synotion'
+
+# Configure globally
+Synotion.configure do |config|
+  config.notion_api_key = ENV['NOTION_API_KEY']
+  config.database_id = 'your-database-id'
+end
+
+# Sync a file
+syncer = Synotion::Syncer.new
+result = syncer.sync('README.md')
+# => { action: 'created', page_id: 'xxx', mode: :upsert }
+
+# Sync with options
+result = syncer.sync('docs/api.md',
+  mode: :replace,
+  title: 'API Documentation'
+)
+```
+
+### Configuration File
+
+Create `.notion-sync.yml`:
+
+```yaml
+notion_api_key: secret_xxx
+database_id: your-database-id
+update_mode: upsert
+unique_property: source_file
+```
+
+## Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `notion_api_key` | Notion API key (required) | - |
+| `database_id` | Target database ID | - |
+| `page_id` | Target page ID (alternative to database_id) | - |
+| `update_mode` | How to handle existing pages | `:upsert` |
+| `unique_property` | Property for page identification | `'source_file'` |
+| `title_from` | How to extract page title | `:first_heading` |
+| `sync_metadata` | Add last_synced timestamp | `true` |
+
+### Update Modes
+
+| Mode | Behavior |
+|------|----------|
+| `:create` | Create new page only (skip if exists) |
+| `:append` | Append content to existing page |
+| `:replace` | Replace entire page content |
+| `:upsert` | Update if exists, create if not (default) |
+
+### Supported Markdown Elements
+
+- Headings (H1, H2, H3)
+- Paragraphs
+- Code blocks with syntax highlighting
+- Bulleted lists
+- Numbered lists
+- Quotes
+- Dividers
+- Todo items / Checkboxes
+- YAML front matter
+
+## Notion Setup
+
+1. Create an Integration
+
+- Go to https://www.notion.so/my-integrations
+- Click "New integration"
+- Copy the "Internal Integration Token"
+
+2. Create a Database
+
+Create a Notion database with these properties:
+
+| Property | Type | Purpose |
+|----------|------|---------|
+| Name | Title | Page title (required) |
+| source_file | Text | File path for unique identification |
+| last_synced | Date | Last sync timestamp (optional) |
+
+3. Share Database
+
+- Open your database in Notion
+- Click "..." → "Add connections"
+- Select your integration
+
+## Development
+
+```bash
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Try in console
+bundle exec exe/synotion --help
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ydah/synotion.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/synotion

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'synotion'
+
+Synotion::CLI.start(ARGV)

data/lib/synotion/cli.rb

@@ -0,0 +1,66 @@
+require 'thor'
+require 'yaml'
+
+module Synotion
+  class CLI < Thor
+    desc 'sync FILE_PATH', 'Sync a markdown file to Notion'
+    method_option :api_key, type: :string, desc: 'Notion API key (or set NOTION_API_KEY env var)'
+    method_option :database_id, type: :string, desc: 'Notion database ID'
+    method_option :page_id, type: :string, desc: 'Notion page ID for direct update'
+    method_option :mode, type: :string, default: 'upsert', desc: 'Update mode: create, append, replace, upsert'
+    method_option :unique_property, type: :string, default: 'source_file', desc: 'Property name for unique identification'
+    method_option :unique_value, type: :string, desc: 'Value for unique property (defaults to file path)'
+    method_option :title, type: :string, desc: 'Custom page title'
+    method_option :config, type: :string, desc: 'Path to config file (.notion-sync.yml)'
+
+    def sync(file_path)
+      if options[:config] && File.exist?(options[:config])
+        load_config_file(options[:config])
+      end
+
+      syncer_options = {}
+      syncer_options[:notion_api_key] = options[:api_key] if options[:api_key]
+      syncer_options[:database_id] = options[:database_id] if options[:database_id]
+      syncer_options[:page_id] = options[:page_id] if options[:page_id]
+
+      sync_options = {}
+      sync_options[:mode] = options[:mode].to_sym if options[:mode]
+      sync_options[:unique_property] = options[:unique_property] if options[:unique_property]
+      sync_options[:unique_value] = options[:unique_value] if options[:unique_value]
+      sync_options[:title] = options[:title] if options[:title]
+
+      syncer = Syncer.new(syncer_options)
+      result = syncer.sync(file_path, sync_options)
+
+      puts "✓ Successfully #{result[:action]} page"
+      puts "  Page ID: #{result[:page_id]}"
+      puts "  Mode: #{result[:mode]}" if result[:mode]
+    rescue StandardError => e
+      puts "✗ Error: #{e.message}"
+      exit 1
+    end
+
+    desc 'version', 'Show version'
+    def version
+      puts "Synotion version #{Synotion::VERSION}"
+    end
+
+    private
+
+    def load_config_file(config_path)
+      config_data = YAML.load_file(config_path)
+
+      Synotion.configure do |config|
+        config.notion_api_key = config_data['notion_api_key'] if config_data['notion_api_key']
+        config.database_id = config_data['database_id'] if config_data['database_id']
+        config.page_id = config_data['page_id'] if config_data['page_id']
+        config.unique_property = config_data['unique_property'] if config_data['unique_property']
+        config.update_mode = config_data['update_mode'].to_sym if config_data['update_mode']
+        config.title_from = config_data['title_from'].to_sym if config_data['title_from']
+        config.sync_metadata = config_data['sync_metadata'] if config_data.key?('sync_metadata')
+      end
+    rescue StandardError => e
+      puts "Warning: Failed to load config file: #{e.message}"
+    end
+  end
+end

data/lib/synotion/client.rb

@@ -0,0 +1,106 @@
+require 'notion-ruby-client'
+
+module Synotion
+  class Client
+    attr_reader :api_client
+
+    def initialize(api_key)
+      @api_client = Notion::Client.new(token: api_key)
+    end
+
+    def find_page(database_id:, property:, value:)
+      response = api_client.database_query(
+        database_id: database_id,
+        filter: {
+          property: property,
+          rich_text: {
+            equals: value
+          }
+        }
+      )
+
+      return nil if response.results.empty?
+
+      response.results.first
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to find page: #{e.message}"
+    end
+
+    def create_page(database_id:, properties:, children: [])
+      response = api_client.create_page(
+        parent: { database_id: database_id },
+        properties: properties,
+        children: children
+      )
+      response
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to create page: #{e.message}"
+    end
+
+    def update_page(page_id:, children:, mode:)
+      case mode
+      when UpdateMode::REPLACE
+        delete_blocks(page_id)
+        append_blocks(page_id, children)
+      when UpdateMode::APPEND
+        append_blocks(page_id, children)
+      else
+        raise ArgumentError, "Invalid update mode for update_page: #{mode}"
+      end
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to update page: #{e.message}"
+    end
+
+    def append_blocks(page_id, children)
+      return if children.empty?
+
+      children.each_slice(100) do |chunk|
+        api_client.block_append_children(
+          block_id: page_id,
+          children: chunk
+        )
+      end
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to append blocks: #{e.message}"
+    end
+
+    def delete_blocks(page_id)
+      blocks = get_page_blocks(page_id)
+      blocks.each do |block|
+        api_client.delete_block(block_id: block.id)
+      end
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to delete blocks: #{e.message}"
+    end
+
+    def get_page_blocks(page_id)
+      blocks = []
+      cursor = nil
+
+      loop do
+        response = api_client.block_children(
+          block_id: page_id,
+          start_cursor: cursor
+        )
+
+        blocks.concat(response.results)
+
+        break unless response.has_more
+        cursor = response.next_cursor
+      end
+
+      blocks
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to get page blocks: #{e.message}"
+    end
+
+    def update_page_properties(page_id:, properties:)
+      api_client.update_page(
+        page_id: page_id,
+        properties: properties
+      )
+    rescue Notion::Api::Errors::NotionError => e
+      raise NotionAPIError, "Failed to update page properties: #{e.message}"
+    end
+  end
+end

data/lib/synotion/configuration.rb

@@ -0,0 +1,27 @@
+module Synotion
+  class Configuration
+    attr_accessor :notion_api_key,
+                  :database_id,
+                  :page_id,
+                  :unique_property,
+                  :update_mode,
+                  :title_from,
+                  :sync_metadata
+
+    def initialize
+      @notion_api_key = ENV.fetch('NOTION_API_KEY', nil)
+      @database_id = nil
+      @page_id = nil
+      @unique_property = 'source_file'
+      @update_mode = UpdateMode::UPSERT
+      @title_from = :first_heading
+      @sync_metadata = true
+    end
+
+    def validate!
+      raise ConfigurationError, 'notion_api_key is required' if notion_api_key.nil? || notion_api_key.empty?
+      raise ConfigurationError, 'Either database_id or page_id must be specified' if database_id.nil? && page_id.nil?
+      raise ConfigurationError, "Invalid update_mode: #{update_mode}" unless UpdateMode.valid?(update_mode)
+    end
+  end
+end

data/lib/synotion/markdown_converter.rb

@@ -0,0 +1,225 @@
+require 'redcarpet'
+require 'front_matter_parser'
+
+module Synotion
+  class MarkdownConverter
+    attr_reader :markdown_content, :frontmatter, :content_without_frontmatter
+
+    def initialize(markdown_content)
+      @markdown_content = markdown_content
+      parse_frontmatter
+    end
+
+    def to_notion_blocks
+      blocks = []
+      lines = content_without_frontmatter.split("\n")
+      i = 0
+
+      while i < lines.length
+        line = lines[i]
+
+        if line.strip.empty?
+          i += 1
+          next
+        end
+
+        if line.start_with?('#')
+          blocks << parse_heading(line)
+          i += 1
+        elsif line.start_with?('```')
+          code_block, lines_consumed = parse_code_block(lines[i..-1])
+          blocks << code_block if code_block
+          i += lines_consumed
+        elsif line.match?(/^\s*[-*]\s+\[[ x]\]/)
+          blocks << parse_todo(line)
+          i += 1
+        elsif line.match?(/^\s*[-*+]\s/)
+          list_items, lines_consumed = parse_list(lines[i..-1], :bulleted_list_item)
+          blocks.concat(list_items)
+          i += lines_consumed
+        elsif line.match?(/^\s*\d+\.\s/)
+          list_items, lines_consumed = parse_list(lines[i..-1], :numbered_list_item)
+          blocks.concat(list_items)
+          i += lines_consumed
+        elsif line.start_with?('>')
+          blocks << parse_quote(line)
+          i += 1
+        elsif line.match?(/^[-*_]{3,}$/)
+          blocks << { type: 'divider', divider: {} }
+          i += 1
+        else
+          paragraph, lines_consumed = parse_paragraph(lines[i..-1])
+          blocks << paragraph if paragraph
+          i += lines_consumed
+        end
+      end
+
+      blocks
+    rescue StandardError => e
+      raise MarkdownParseError, "Failed to parse markdown: #{e.message}"
+    end
+
+    def extract_title
+      first_heading = content_without_frontmatter.lines.find { |line| line.start_with?('#') }
+      return first_heading.sub(/^#+\s*/, '').strip if first_heading
+
+      return frontmatter['title'] if frontmatter&.key?('title')
+
+      nil
+    end
+
+    def extract_frontmatter
+      frontmatter
+    end
+
+    private
+
+    def parse_frontmatter
+      parsed = FrontMatterParser::Parser.new(:md).call(@markdown_content)
+      @frontmatter = parsed.front_matter
+      @content_without_frontmatter = parsed.content
+    rescue StandardError
+      @frontmatter = {}
+      @content_without_frontmatter = @markdown_content
+    end
+
+    def parse_heading(line)
+      level = line.match(/^(#+)/)[1].length
+      text = line.sub(/^#+\s*/, '')
+
+      heading_type = case level
+                     when 1 then 'heading_1'
+                     when 2 then 'heading_2'
+                     else 'heading_3'
+                     end
+
+      {
+        type: heading_type,
+        heading_type => {
+          rich_text: [{ type: 'text', text: { content: text.strip } }]
+        }
+      }
+    end
+
+    def parse_code_block(lines)
+      first_line = lines[0]
+      language = first_line.sub('```', '').strip
+      language = 'plain text' if language.empty?
+
+      code_lines = []
+      i = 1
+
+      while i < lines.length && !lines[i].start_with?('```')
+        code_lines << lines[i]
+        i += 1
+      end
+
+      code_content = code_lines.join("\n")
+
+      block = {
+        type: 'code',
+        code: {
+          rich_text: [{ type: 'text', text: { content: code_content } }],
+          language: language
+        }
+      }
+
+      [block, i + 1]
+    end
+
+    def parse_list(lines, type)
+      items = []
+      i = 0
+
+      pattern = if type == :bulleted_list_item
+                  /^\s*[-*+]\s/
+                else
+                  /^\s*\d+\.\s/
+                end
+
+      while i < lines.length
+        line = lines[i]
+        break unless line.match?(pattern)
+
+        text = if type == :bulleted_list_item
+                 line.sub(/^\s*[-*+]\s+/, '').strip
+               else
+                 line.sub(/^\s*\d+\.\s+/, '').strip
+               end
+
+        items << {
+          type: type.to_s,
+          type => {
+            rich_text: [{ type: 'text', text: { content: text } }]
+          }
+        }
+        i += 1
+      end
+
+      [items, i]
+    end
+
+    def parse_quote(line)
+      text = line.sub(/^>\s*/, '')
+
+      {
+        type: 'quote',
+        quote: {
+          rich_text: [{ type: 'text', text: { content: text.strip } }]
+        }
+      }
+    end
+
+    def parse_todo(line)
+      match = line.match(/^\s*[-*]\s+\[([x ])\]\s*(.*)/)
+      checked = match[1] == 'x'
+      text = match[2].strip
+
+      {
+        type: 'to_do',
+        to_do: {
+          rich_text: [{ type: 'text', text: { content: text } }],
+          checked: checked
+        }
+      }
+    end
+
+    def parse_paragraph(lines)
+      paragraph_lines = []
+      i = 0
+
+      while i < lines.length
+        line = lines[i]
+        break if line.strip.empty?
+        break if line.start_with?('#', '```', '>', '-', '*', '+') || line.match?(/^\d+\./)
+
+        paragraph_lines << line
+        i += 1
+      end
+
+      return [nil, i] if paragraph_lines.empty?
+
+      text = paragraph_lines.join(' ').strip
+      rich_text = parse_inline_formatting(text)
+
+      block = {
+        type: 'paragraph',
+        paragraph: {
+          rich_text: rich_text
+        }
+      }
+
+      [block, i]
+    end
+
+    def parse_inline_formatting(text)
+      segments = []
+      current_pos = 0
+
+      [{
+        type: 'text',
+        text: { content: text }
+      }]
+    end
+  end
+end

data/lib/synotion/syncer.rb

@@ -0,0 +1,175 @@
+require 'time'
+
+module Synotion
+  class Syncer
+    attr_reader :config, :client
+
+    def initialize(options = {})
+      @config = build_config(options)
+      @config.validate!
+      @client = Client.new(@config.notion_api_key)
+    end
+
+    def sync(markdown_file_path, options = {})
+      raise ArgumentError, "File not found: #{markdown_file_path}" unless File.exist?(markdown_file_path)
+
+      markdown_content = File.read(markdown_file_path)
+      identifier = options[:unique_value] || markdown_file_path
+
+      sync_content(markdown_content, identifier, options.merge(filename: markdown_file_path))
+    end
+
+    def sync_content(markdown_content, identifier, options = {})
+      mode = options[:mode] || config.update_mode
+      database_id = options[:database_id] || config.database_id
+      page_id = options[:page_id] || config.page_id
+
+      converter = MarkdownConverter.new(markdown_content)
+      blocks = converter.to_notion_blocks
+      title = options[:title] || extract_title(converter, options[:filename])
+
+      if page_id
+        sync_to_page(page_id, blocks, mode, title)
+      elsif database_id
+        unique_property = options[:unique_property] || config.unique_property
+        sync_to_database(database_id, identifier, blocks, mode, title, unique_property, options)
+      else
+        raise ConfigurationError, 'Either page_id or database_id must be specified'
+      end
+    end
+
+    private
+
+    def build_config(options)
+      if options.empty?
+        Synotion.configuration
+      else
+        config = Configuration.new
+        options.each do |key, value|
+          config.public_send("#{key}=", value) if config.respond_to?("#{key}=")
+        end
+        config
+      end
+    end
+
+    def extract_title(converter, filename = nil)
+      case config.title_from
+      when :first_heading
+        converter.extract_title || (filename ? File.basename(filename, '.*') : 'Untitled')
+      when :filename
+        filename ? File.basename(filename, '.*') : 'Untitled'
+      when :custom
+        'Untitled'
+      else
+        converter.extract_title || 'Untitled'
+      end
+    end
+
+    def sync_to_page(page_id, blocks, mode, title)
+      case mode
+      when UpdateMode::REPLACE
+        client.update_page(page_id: page_id, children: blocks, mode: mode)
+        { action: 'updated', page_id: page_id, mode: mode }
+      when UpdateMode::APPEND
+        client.update_page(page_id: page_id, children: blocks, mode: mode)
+        { action: 'appended', page_id: page_id, mode: mode }
+      else
+        raise ArgumentError, "Invalid mode for page sync: #{mode}. Use :replace or :append"
+      end
+    end
+
+    def sync_to_database(database_id, identifier, blocks, mode, title, unique_property, options)
+      existing_page = client.find_page(
+        database_id: database_id,
+        property: unique_property,
+        value: identifier
+      )
+
+      case mode
+      when UpdateMode::CREATE
+        if existing_page
+          { action: 'skipped', page_id: existing_page.id, reason: 'page already exists' }
+        else
+          create_database_page(database_id, identifier, blocks, title, unique_property, options)
+        end
+      when UpdateMode::UPSERT
+        if existing_page
+          update_database_page(existing_page.id, blocks, UpdateMode::REPLACE)
+        else
+          create_database_page(database_id, identifier, blocks, title, unique_property, options)
+        end
+      when UpdateMode::REPLACE
+        if existing_page
+          update_database_page(existing_page.id, blocks, UpdateMode::REPLACE)
+        else
+          raise PageNotFoundError, "Page not found for identifier: #{identifier}"
+        end
+      when UpdateMode::APPEND
+        if existing_page
+          update_database_page(existing_page.id, blocks, UpdateMode::APPEND)
+        else
+          raise PageNotFoundError, "Page not found for identifier: #{identifier}"
+        end
+      else
+        raise ArgumentError, "Invalid update mode: #{mode}"
+      end
+    end
+
+    def create_database_page(database_id, identifier, blocks, title, unique_property, options)
+      properties = build_properties(title, identifier, unique_property, options[:additional_properties])
+
+      response = client.create_page(
+        database_id: database_id,
+        properties: properties,
+        children: blocks
+      )
+
+      { action: 'created', page_id: response.id, mode: UpdateMode::CREATE }
+    end
+
+    def update_database_page(page_id, blocks, mode)
+      client.update_page(page_id: page_id, children: blocks, mode: mode)
+
+      action = mode == UpdateMode::REPLACE ? 'updated' : 'appended'
+      { action: action, page_id: page_id, mode: mode }
+    end
+
+    def build_properties(title, identifier, unique_property, additional_properties = {})
+      properties = {
+        'title' => {
+          'title' => [
+            {
+              'text' => {
+                'content' => title
+              }
+            }
+          ]
+        }
+      }
+
+      if unique_property != 'title'
+        properties[unique_property] = {
+          'rich_text' => [
+            {
+              'text' => {
+                'content' => identifier
+              }
+            }
+          ]
+        }
+      end
+
+      if config.sync_metadata
+        properties['last_synced'] = {
+          'date' => {
+            'start' => Time.now.iso8601
+          }
+        }
+      end
+
+      properties.merge!(additional_properties) if additional_properties
+
+      properties
+    end
+  end
+end

data/lib/synotion/update_mode.rb

@@ -0,0 +1,14 @@
+module Synotion
+  module UpdateMode
+    CREATE = :create
+    APPEND = :append
+    REPLACE = :replace
+    UPSERT = :upsert
+
+    ALL = [CREATE, APPEND, REPLACE, UPSERT].freeze
+
+    def self.valid?(mode)
+      ALL.include?(mode)
+    end
+  end
+end

data/lib/synotion/version.rb

@@ -0,0 +1,3 @@
+module Synotion
+  VERSION = "0.1.0"
+end

data/lib/synotion.rb

@@ -0,0 +1,31 @@
+require_relative "synotion/version"
+require_relative "synotion/update_mode"
+require_relative "synotion/configuration"
+require_relative "synotion/client"
+require_relative "synotion/markdown_converter"
+require_relative "synotion/syncer"
+require_relative "synotion/cli"
+
+module Synotion
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class NotionAPIError < Error; end
+  class PageNotFoundError < Error; end
+  class MarkdownParseError < Error; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: synotion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: notion-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: front_matter_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: A Ruby gem to synchronize Markdown files to Notion pages with support
+  for multiple update modes (create, append, replace, upsert)
+email:
+- t.yudai92@gmail.com
+executables:
+- synotion
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/synotion
+- lib/synotion.rb
+- lib/synotion/cli.rb
+- lib/synotion/client.rb
+- lib/synotion/configuration.rb
+- lib/synotion/markdown_converter.rb
+- lib/synotion/syncer.rb
+- lib/synotion/update_mode.rb
+- lib/synotion/version.rb
+homepage: https://github.com/ydah/synotion
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/synotion
+  source_code_uri: https://github.com/ydah/synotion
+  changelog_uri: https://github.com/ydah/synotion/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Sync Markdown files to Notion pages
+test_files: []