postwave 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f460f1e6202c2d56b2c355266fd8819691cdb2a8f12b6aa33febd8a0c6b5d580
+  data.tar.gz: 5159c6aa7c213bfff6ec6f1a2f3fdb8c4f1ef8f03dbe9ff5014b93709ee8c625
+SHA512:
+  metadata.gz: 5102d693e92f76288dbdf152f00cfdf6a386e0b4a27bb4415ba8baccdd13d64b04e624f136bb993046bf7b71facbf5d78848716aa8c146abe6a1f9d006b91282
+  data.tar.gz: cfbb408e719c8a56e54ef81614ae5e7a7a362e1b3f7f863e4e462d449dfab3188beca5e4536fe13381097c1eb14d8b43842c9108d5429f44909aaf87a765961a

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in trackstar.gemspec
+gemspec

data/README.md

@@ -0,0 +1,108 @@
+# Postwave 🌊
+
+Write your posts statically. Interact with them dynamically.
+
+## What is Postwave?
+
+Postwave is an opinionated flat-file based based blog engine.
+
+It lets you write posts in Markdown and then display them on a dynamic site using a client library.
+
+## Getting Started
+
+### Installation
+
+```
+gem install postwave
+```
+
+### Setup
+
+```
+> postwave new
+```
+
+Run this from the root directory of your project. It will create a `postwave.yaml` config file in the current directory and a `/_posts/` directory. This is where you will write your posts.
+
+Here is what will be created:
+
+```
+|- _posts/
+|  |- meta/
+|     |- tags/
+|     |- index.csv
+|     |- summary.yaml
+postwave.yaml
+```
+
+`_posts/`: This is where you write all your posts in Markdown
+
+`_posts/meta/tags/`: This will contain files for every tag your define in your posts
+
+`_posts/meta/index.csv`: This will contain an ordered list of all the posts
+
+`_posts/meta/summary.yaml`: This file will contain some summary information about the posts. Total count, etc.
+
+`postwave.yaml`: The config file for Postwave.
+
+### Create A New Blog Post
+
+```
+> postwave post
+```
+
+This will generate at new Markdown file in the `_posts/` directory. The filename will be the current timestamp. This will eventually be overwritten by the `build` command, so don't worry too much about it. The file will have a general structure like this:
+
+```
+---
+title:
+date: 2022-01-01
+tags:
+---
+
+Start writing!
+```
+Tags should be comma separated.
+
+You can keep a post in "draft" status (meaning it won't get processed or added to the index) by adding `draft: true` to the top section of the post.
+
+```
+---
+title: This Post Isn't Quite Ready
+date: 2022-01-01
+tags:
+draft: true
+---
+```
+
+### Build the Blog
+
+```
+> postwave build
+```
+
+This will "build" the blog. This involves:
+- regenerating the `index.csv` file
+- generating slugs for each posts based on the post title and ensuring that there are no duplicate slugs
+- changing the post file names to match `yyyy-dd-mm-slug.md`
+- updating the `summary.yaml`
+- creating and updating tag files (which will be `/tags/[tag-name].yaml` files for each tag)
+
+## Available Client Libraries
+
+- [Ruby](https://github.com/dorkrawk/postwave-ruby-client)
+
+## What is Postwave Not?
+
+Postwave is not for everything.
+
+It is not:
+- for people who want to generate a purely static site
+- for people who want unlimited customization
+- for giant blogs with many many thousands of posts (maybe?)
+
+## Why did you build another blogging tool?
+
+I don't know. I probably like writing blog engines more than I like writing blog posts.
+
+I wanted something that would let me writing simple Markdown posts but still let me just embed the index and post content into a custom dynamic site. This scratched an itch and seemed like it would be fun to build.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'spec'
+  t.test_files = FileList['spec/*_spec.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/bin/postwave

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/postwave'
+require 'optparse'
+
+options = {}
+
+subtext = <<HELP
+Commands:
+  new   :     creates new Postwave project in the current directory
+  post  :     creates a new post in the /_posts/ directory
+  build :     builds the posts and meta information for the blog
+See 'postwave COMMAND --help' for more information on a specific command.
+HELP
+
+global = OptionParser.new do |opts|
+  opts.banner = "Usage: postwave [options] [command]"
+  opts.on '-v', '--version', 'Show version' do |v|
+    options[:version] = v
+  end
+  opts.separator ""
+  opts.separator subtext
+end
+
+subcommands = { 
+  'new' => OptionParser.new do |opts|
+    opts.banner = "Usage: new"
+  end,
+ 'post' => OptionParser.new do |opts|
+    opts.banner = "Usage: post"
+  end,
+  'build' => OptionParser.new do |opts|
+    opts.banner = "Usage: build [options]"
+    opts.on("-q", "--quiet", "quietly run ") do |v|
+      options[:quiet] = v
+    end
+  end
+}
+
+global.order!
+command = ARGV.shift
+subcommands[command].order! if command
+
+Postwave.call(command, options)

data/lib/postwave/blog_builder.rb

@@ -0,0 +1,105 @@
+require "fileutils"
+require "yaml"
+require "singleton"
+require 'csv'
+require 'time'
+require_relative "blog_utilities"
+require_relative "display_helper"
+require_relative "post"
+
+module Postwave
+  class BlogBuilder
+    include Singleton
+    include BlogUtilities
+    include DisplayHelper
+
+    INDEX_HEADERS = ["slug", "date", "title"]
+
+    def build
+      start = Time.now
+      
+      output_building
+
+      if !is_set_up?
+        output_missing_setup
+        return
+      end
+
+      # load, rename, and sort post file names
+      posts = load_posts
+      posts = ensure_unique_slugs(posts).sort_by { |p| p.date }.reverse
+      draft_posts, published_posts = posts.partition { |p| p.respond_to?(:draft) ? p.draft : false }
+      tags = {}
+
+      CSV.open(File.join(Dir.pwd, POSTS_DIR, META_DIR, INDEX_FILE_NAME), "w") do |csv|
+        csv << INDEX_HEADERS
+        published_posts.each do |post|
+          post.update_file_name!
+
+          csv << [post.slug, post.date, post.title]
+
+          post.tags.each do |tag|
+            if tags.has_key? tag
+              tags[tag] << post.slug
+            else
+              tags[tag] = [post.slug]
+            end
+          end
+        end
+      end
+      output_post_processed(published_posts)
+      output_drafts_skipped(draft_posts)
+
+      build_tags_files(tags)
+      build_summary(published_posts, tags)
+
+      build_time = Time.now - start
+      output_build_completed(build_time)
+    end
+
+    def load_posts
+      posts = []
+      Dir.glob(File.join(Dir.pwd, POSTS_DIR, "*.md")) do |post_file_path|
+        posts << Postwave::Post.new_from_file_path(post_file_path)
+      end
+      posts
+    end
+
+    def ensure_unique_slugs(posts)
+      slug_count = {}
+
+      posts.sort_by { |p| p.date }.each do |post|
+        title_slug = post.title_slug
+        if slug_count.key?(title_slug)
+          slug_count[title_slug] += 1
+          post.slug = "#{title_slug}-#{slug_count[title_slug]}"
+        else
+          slug_count[title_slug] = 0
+        end
+      end
+
+      posts
+    end
+
+    def build_tags_files(tags)
+      tags.each do |tag, post_slugs|
+        tag_info = {
+          count: post_slugs.count,
+          post_slugs: post_slugs
+        }
+        File.write(File.join(Dir.pwd, POSTS_DIR, META_DIR, TAGS_DIR, "#{tag}.yaml"), tag_info.to_yaml)
+      end
+      output_tags_created(tags)
+    end
+
+    def build_summary(posts, tags)
+      summary = {
+        post_count: posts.count,
+        most_recent_file_name: posts.first.file_name,
+        most_recent_date: posts.first.date,
+        tags: tags.keys
+      }
+      File.write(File.join(Dir.pwd, POSTS_DIR, META_DIR, SUMMARY_FILE_NAME), summary.to_yaml)
+    end
+  end
+end

data/lib/postwave/blog_creator.rb

@@ -0,0 +1,49 @@
+require "fileutils"
+require "yaml"
+require "singleton"
+require_relative "blog_utilities"
+require_relative "display_helper"
+
+module Postwave
+  class BlogCreator
+    include Singleton
+    include BlogUtilities
+    include DisplayHelper
+
+    def create
+      output_creating_blog
+
+      if is_set_up?
+        output_exising_setup
+        return
+      end
+
+      build_directories
+      build_files
+      write_initial_summary_contents
+
+      output_blog_created 
+    end
+
+    def build_directories
+      directory_paths.each do |path|
+        FileUtils.mkdir_p(path)
+      end
+    end
+
+    def build_files
+      file_paths.each do |path|
+        FileUtils.touch(path)
+      end
+    end
+
+    def write_initial_summary_contents
+      summary = {
+        post_count: 0,
+        tags: []
+      }
+
+      File.write(File.join(Dir.pwd, POSTS_DIR, META_DIR, SUMMARY_FILE_NAME), summary.to_yaml)
+    end
+  end
+end

data/lib/postwave/blog_utilities.rb

@@ -0,0 +1,40 @@
+module Postwave
+  module BlogUtilities
+    CONFIG_FILE_NAME = "postwave.yaml"
+    INDEX_FILE_NAME = "index.csv"
+    SUMMARY_FILE_NAME = "summary.yaml"
+    POSTS_DIR = "_posts"
+    META_DIR = "meta"
+    TAGS_DIR = "tags"
+
+    def is_set_up?
+      missing_paths = find_missing_paths
+      missing_paths.empty?
+    end
+
+    def file_paths
+      [
+        File.join(Dir.pwd, CONFIG_FILE_NAME),
+        File.join(Dir.pwd, POSTS_DIR, META_DIR, INDEX_FILE_NAME),
+        File.join(Dir.pwd, POSTS_DIR, META_DIR, SUMMARY_FILE_NAME),
+      ]
+    end
+
+    def directory_paths
+      [
+        File.join(Dir.pwd, POSTS_DIR),
+        File.join(Dir.pwd, POSTS_DIR, META_DIR),
+        File.join(Dir.pwd, POSTS_DIR, META_DIR, TAGS_DIR),
+      ]
+    end
+
+    def find_missing_paths
+      paths_to_check = directory_paths + file_paths
+      missing_paths = []
+      paths_to_check.each do |path|
+        missing_paths << path if !FileTest.exists?(path)
+      end
+      missing_paths
+    end
+  end
+end

data/lib/postwave/display_helper.rb

@@ -0,0 +1,80 @@
+module Postwave
+  module DisplayHelper
+
+    # new
+
+    def output_creating_blog
+      puts "🌊 Creating new blog..."
+    end
+
+    def output_blog_created
+      puts "New blog set up.".green
+    end
+
+    # post
+
+    def output_creating_post
+      puts "🌊 Creating new post..."
+    end
+
+    def output_post_created(post_path)
+      puts "New post created at: #{post_path}".green
+    end
+
+    # build
+
+    def output_building
+      puts "🌊 Building..."
+    end
+
+    def output_post_processed(posts)
+      count = posts.count
+      puts "Processed #{count} #{simple_pluralizer("post", count)}."
+    end
+
+    def output_drafts_skipped(drafts)
+      if drafts.any?
+        count = drafts.count
+        puts "Skipped #{count} #{simple_pluralizer("draft", count)}."
+      end
+    end
+
+    def output_tags_created(tags)
+      count = tags.count
+      puts "Built tag files for #{count} #{simple_pluralizer("tag", count)}."
+    end
+
+    def output_build_completed(build_time)
+      puts "Built succesfully in #{build_time} seconds.".green
+    end
+
+    # errors
+
+    def output_exising_setup
+      puts "A blog already exists in this location.".red
+    end
+
+    def output_missing_setup
+      puts "You need to set up a blog first.".red
+    end
+
+    def output_general_error
+      puts "Something went wrong.".red
+    end
+
+    private
+    def simple_pluralizer(word, count)
+      if count == 1
+        word
+      else
+        word + "s"
+      end
+    end
+  end
+end
+
+# 🐒 patch String to add terminal colors
+class String
+  def red;            "\e[31m#{self}\e[0m" end
+  def green;          "\e[32m#{self}\e[0m" end
+end

data/lib/postwave/post.rb

@@ -0,0 +1,89 @@
+require_relative "blog_utilities"
+
+module Postwave
+   class Post
+    include BlogUtilities
+
+    KNOWN_FIELDS = %w(title date tags title_slug body draft)
+    REQUIRED_FIELDS = %w(title date)
+    MEATADATA_DELIMTER = "---"
+
+    attr_accessor :file_name
+
+    def self.new_from_file_path(path)
+      metadata_delimter_count = 0
+      body_buffer_count = 0
+      field_content = { "body" => "" }
+
+      File.readlines(path).each do |line|
+        clean_line = line.strip
+        if clean_line == MEATADATA_DELIMTER
+          metadata_delimter_count += 1
+          next
+        end
+
+        if metadata_delimter_count == 0
+          next
+        elsif metadata_delimter_count == 1
+          field, value = clean_line.split(":", 2).map(&:strip)
+          field_content[field] = value
+        else
+          if body_buffer_count == 0
+            body_buffer_count += 1
+            next if clean_line.empty?
+          end
+
+          field_content["body"] += "#{line}\n"
+        end
+      end
+
+      # turn "tags" into an array
+      if field_content["tags"]
+        field_content["tags"] = field_content["tags"].split(",").map do |tag|
+          tag.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+        end
+      end
+
+      # turn "draft" into boolean
+      if field_content["draft"]
+        field_content["draft"] = field_content["draft"].downcase == "true"
+      end
+
+      self.new(path, field_content)
+    end
+    
+    def initialize(file_name, field_content = {})
+      @file_name = file_name
+
+      field_content.each do |field, value|
+        instance_variable_set("@#{field}", value)
+        self.class.send(:attr_accessor, field)
+      end
+    end
+
+    def title_slug
+      @title_slug ||= @title.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+    end
+    
+    def slug
+      @slug ||= @title_slug
+    end
+
+    def slug=(new_slug)
+      @slug = new_slug
+    end
+
+    def generated_file_name
+      # YYYY-MM-DD-slug-from-title.md
+      "#{@date[..9]}-#{slug}.md"
+    end
+
+    def update_file_name!
+      desired_file_name = generated_file_name
+      return false if @file_name == desired_file_name
+
+      File.rename(@file_name, File.join(Dir.pwd, POSTS_DIR, desired_file_name))
+      @file_name = desired_file_name
+    end
+  end
+end

data/lib/postwave/post_creator.rb

@@ -0,0 +1,40 @@
+require "fileutils"
+require "singleton"
+require_relative "blog_utilities"
+require_relative "display_helper"
+
+
+module Postwave
+   class PostCreator
+    include Singleton
+    include BlogUtilities
+    include DisplayHelper
+
+    def create
+      output_creating_post
+
+      if !is_set_up?
+        output_missing_setup
+        return
+      end
+
+      now = Time.now
+      post_file_name = "#{now.to_i}.md"
+
+      initial_content = <<~CONTENT
+      ---
+      title: #{(0...8).map { (65 + rand(26)).chr }.join}
+      date: #{now.strftime("%F %R")}
+      tags:
+      ---
+      
+      Start writing!
+      CONTENT
+
+
+      File.write(File.join(Dir.pwd, POSTS_DIR, post_file_name), initial_content)
+
+      output_post_created(File.join(POSTS_DIR, post_file_name))
+    end
+  end
+end

data/lib/postwave/version.rb

@@ -0,0 +1,3 @@
+module Postwave
+  VERSION = "0.0.1"
+end

data/lib/postwave.rb

@@ -0,0 +1,21 @@
+require_relative "postwave/blog_creator"
+require_relative "postwave/blog_builder"
+require_relative "postwave/post_creator"
+require_relative "postwave/version"
+
+module Postwave
+  def self.call(command, options)
+    case command
+    when "new"
+      Postwave::BlogCreator.instance.create
+    when "post"
+      Postwave::PostCreator.instance.create
+    when "build"
+      Postwave::BlogBuilder.instance.build
+    else
+      if options[:version]
+        puts "postwave #{VERSION} [ruby]"
+      end
+    end
+  end
+end

data/postwave.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postwave/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "postwave"
+  spec.version       = Postwave::VERSION
+  spec.authors       = ["Dave Schwantes"]
+  spec.email         = ["dave.schwantes@gmail.com"]
+
+  spec.summary       = "An opinionated flatfile based blog engine."
+  spec.description   = "Write your posts statically. Interact with them dynamically."
+  spec.homepage      = "https://github.com/dorkrawk/postwave"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = ['postwave']
+  spec.require_paths = ["lib"]
+
+  # spec.add_dependency ""
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 12.3"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: postwave
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dave Schwantes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: Write your posts statically. Interact with them dynamically.
+email:
+- dave.schwantes@gmail.com
+executables:
+- postwave
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/postwave
+- lib/postwave.rb
+- lib/postwave/blog_builder.rb
+- lib/postwave/blog_creator.rb
+- lib/postwave/blog_utilities.rb
+- lib/postwave/display_helper.rb
+- lib/postwave/post.rb
+- lib/postwave/post_creator.rb
+- lib/postwave/version.rb
+- postwave.gemspec
+homepage: https://github.com/dorkrawk/postwave
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: An opinionated flatfile based blog engine.
+test_files: []