robin_cms 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36e4c02115d1c4d3849376ff70e8c20fd0fb1e80c6ae806f4ae09a7a88e981bf
-  data.tar.gz: f6a86d8721ee1180221c19f7480341accfc3cf5e191f1fde4eab4a7747c757ce
+  metadata.gz: 7496d517d8e733bc0e0876e806347a0c3670efc489d974b16718e3b015d0a8e1
+  data.tar.gz: cc6df56fde6950e75fddf3fef947e5363cdc67f506bd07c16f5bbe0f1940d629
 SHA512:
-  metadata.gz: cefc9e3a84b3b19c786f2110e0baffe2ceafdea25e120320d3a0241ca4aa934775674df7157e0acb9a03dda831d5787516751ec59716ff39436e724e874a696f
-  data.tar.gz: ca16243899f791e64780e268aea3a45c54e2f4d9e6dfd160b4ba07adaf5d25e79f6d3fd7404f42fd67f0b849725963f17e879db10c0ace46dba641d5e95d5f51
+  metadata.gz: 6f4c01cfe9c26b0c7e864af98d405dfe55fbe986f78a3ee9295cb20e9c6bd808bbd9473685ddd17c158574540a63535c16a783a650a937f3e6419f215a81c51f
+  data.tar.gz: 36e240374f3bcf0c564d15347b4847a6b781d7b6192b3b3214fbf35f297748415d1729773039dca5f61b00ce088d681d7b3b02ac340fc3aa1f981c2fa4dd63dc

data/README.md

@@ -1,5 +1,9 @@
 # Robin CMS
 
+> [!IMPORTANT]
+> This software is currently in beta. There may be bugs and breaking changes.
+> If you find a bug, I'd love to hear about it.
+
 ![Robin CMS logo](./assets/robin-logo.png)
 
 Robin CMS is a minimalist flat-file CMS built with Ruby and Sinatra. It is
@@ -65,6 +69,63 @@ Just the usual incantation:
 gem install robin_cms
 ```
 
+## Configuring
+
+You can define your content model in a `_cms.yml` file like this:
+
+```yml
+url: https://example.com
+title: Example
+libraries:
+  - id: poem
+    type: collection
+    label: Poem
+    location: poems
+    filetype: html
+    fields:
+      - { label: Title, id: title, type: input }
+      - { label: Author, id: author_name, type: input }
+      - { label: Content, id: content, type: richtext }
+  - id: book
+    type: data
+    label: Book
+    location: books
+    filetype: yml
+    fields:
+      - { label: Title, id: title, type: input }
+      - { label: Author, id: author_name, type: input }
+```
+
+The admin username and password needs to be set in a `.htpasswd` file in the
+root directory of the project. Obviously make sure you `.gitignore` that file.
+Also make sure your static site generator is ignoring it because you don't want
+it in your public directory! Each line of the `.htpasswd` file should follow
+the format `<username>:<password>`, but note that only a single
+username/password is supported for now. The password needs to be encrypted with
+bcrypt. You can do this in Ruby with the `bcrypt` gem:
+
+```sh
+ruby -r bcrypt -e "puts BCrypt::Password.create('mypassword')"
+```
+
+Another thing to note is that if no `.htpasswd` file is found, it will
+automatically create one with username "admin" and password "admin". This lets
+you play around with it locally without configuring a password. So make sure
+you create a `.htpasswd` file before running it in production!
+
+You'll also need to expose a `SESSION_SECRET` environment variable. If you
+don't, it will create one for you, but it creates a new secret each time
+the server starts, meaning you will have to log in again whenever you restart
+the server. It is recommended to create one via Ruby's SecureRandom package.
+
+```sh
+ruby -r securerandom -e "puts SecureRandom.hex(64)"
+```
+
+See the [examples](./examples) folder for a full example. I haven't written any
+documentation yet, but the example `_cms.yml` file is thoroughly commented to
+explain each of the fields.
+
 ## Usage
 
 You have a few options for using this gem in your project. Firstly, you can use
@@ -107,60 +168,10 @@ end
 ```
 
 After running `bundle exec jekyll serve`, the CMS should be available on your
-website under `/admin`.
-
-## Configuring
-
-You can define your content model in a `_cms.yml` file like this:
-
-```yml
-libraries:
-  - name: "poem"
-    label: "Poem"
-    location: "poems"
-    filetype: "html"
-    fields:
-      - { label: "Title", name; "title", type: "input" }
-      - { label: "Author", name; "author_name", type: "input" }
-      - { label: "Content", name; "content", type: "richtext" }
-  - name: "book"
-    label: "Book"
-    location: "books"
-    filetype: "yml"
-    fields:
-      - { label: "Title", name; "title", type: "input" }
-      - { label: "Author", name; "author_name", type: "input" }
-```
-
-The admin username and password needs to be set in a `.htpasswd` file in the
-root directory of the project. Obviously make sure you `.gitignore` that file.
-Also make sure your static site generator is ignoring it because you don't want
-it in your public directory! Each line of the `.htpasswd` file should follow
-the format `<username>:<password>`, but note that only a single
-username/password is supported for now. The password needs to be encrypted with
-bcrypt. You can do this in Ruby with the `bcrypt` gem:
-
-```sh
-ruby -r bcrypt -e "puts BCrypt::Password.create('mypassword')"
-```
-
-Another thing to note is that if no `.htpasswd` file is found, it will
-automatically create one with username "admin" and password "admin". This lets
-you play around with it locally without configuring a password. So make sure
-you create a `.htpasswd` file before running it in production!
-
-You'll also need to expose a `SESSION_SECRET` environment variable. If you
-don't, it will create one for you, but it creates a new secret each time
-the server starts, meaning you will have to log in again whenever you restart
-the server. It is recommended to create one via Ruby's SecureRandom package.
-
-```sh
-ruby -r securerandom -e "puts SecureRandom.hex(64)"
-```
-
-See the [examples](./examples) folder for a full example. I haven't written any
-documentation yet, but the example `_cms.yml` file is thoroughly commented to
-explain each of the fields.
+website under `/admin`. Note that if using it as a Jekyll plugin, you can put
+your config in Jekyll's `_config.yml` file under the `cms` field. You also
+don't need to specify the `url` and `title` fields, as these are taken from the
+Jekyll config.
 
 ## Testing
 

data/lib/robin_cms/cms.rb

@@ -2,9 +2,8 @@
 
 module RobinCMS
   class CMS < Sinatra::Base
-    set :logging, true
-    set :sessions, true
-    set :session_secret, ENV.fetch("SESSION_SECRET", SecureRandom.hex(64))
+    include Helpers
+    include Auth
 
     attr_accessor :config
 
@@ -14,10 +13,9 @@ module RobinCMS
       @config = Configuration.parse(**opts)
     end
 
-    helpers do
-      include Helpers
-      include Auth
-    end
+    set :logging, true
+    set :sessions, true
+    set :session_secret, ENV.fetch("SESSION_SECRET", SecureRandom.hex(64))
 
     before do
       if %w[/login /logout].include?(request.path_info)
@@ -27,13 +25,18 @@ module RobinCMS
       redirect to("/login") unless session[:auth_user]
     end
 
-    before(/\/libraries\/(.*).*/) do
+    before /\/libraries\/(.*).*/ do
       kind = params[:captures].first.split("/").first
+      library_schema = @config.find_library(kind)
 
-      @library = @config.find_library(kind)
-      @sorted_fields = @config.sorted_fields(kind)
+      halt 404 unless library_schema
 
-      halt 404 unless @library
+      @library = case library_schema[:type]
+                 when "collection"
+                   CollectionLibrary.new(library_schema)
+                 when "data"
+                   DataLibrary.new(library_schema)
+                 end
     end
 
     after do
@@ -92,20 +95,21 @@ module RobinCMS
     end
 
     get "/libraries/:kind" do
-      @items = Item.where(@library,
+      @items = @library.query(
         sort: params[:sort],
         published: params[:published],
-        q: params[:q])
+        q: params[:q]
+      )
 
       erb :library
     end
 
     get "/libraries/:kind/item" do
       if params[:id]
-        @item = Item.find_one(@library, params[:id])
+        @item = @library.find_one(params[:id])
         halt 404 unless @item
       else
-        @item = Item.blank(@library)
+        @item = @library.blank
       end
 
       erb :library_item
@@ -113,32 +117,30 @@ module RobinCMS
 
     post "/libraries/:kind/item" do
       if params[:id]
-        @item = Item.find_one(@library, params[:id])
+        @item = @library.find_one(params[:id])
         halt 404 unless @item
 
         if params[:image]
           filename = params[:image][:filename]
-          tempfile = params[:image][:tempfile]
+          tempfile = params[:image][:tempfile].to_path
 
-          StaticItem.delete_if_exists!(@library, @item.attributes[:image_src])
-          StaticItem.create!(@library, filename, tempfile).then do |s|
-            params[:image_src] = "/" + s.filepath
-          end
+          @library.delete_static(@item.attributes[:image_src])
+          static_path = @library.create_static(filename, tempfile)
+          params[:image_src] = "/" + static_path
         end
 
         @item.attributes = params
-        @item.update!
+        @library.write(@item)
       else
         if params[:image]
           filename = params[:image][:filename]
-          tempfile = params[:image][:tempfile]
+          tempfile = params[:image][:tempfile].to_path
 
-          StaticItem.create!(@library, filename, tempfile).then do |s|
-            params[:image_src] = "/" + s.filepath
-          end
+          static_path = @library.create_static(filename, tempfile)
+          params[:image_src] = "/" + static_path
         end
 
-        Item.create!(@library, params)
+        @library.create(params)
       end
 
       redirect to("/libraries/#{params[:kind]}")
@@ -149,14 +151,14 @@ module RobinCMS
 
     post "/libraries/:kind/item/delete" do
       if params[:id]
-        @item = Item.find_one(@library, params[:id])
+        @item = @library.find_one(params[:id])
         halt 404 unless @item
 
         if @item.attributes[:image_src]
-          StaticItem.delete_if_exists!(@library, @item.attributes[:image_src])
+          @library.delete_static(@item.attributes[:image_src])
         end
 
-        @item.delete!
+        @library.delete(@item.id)
       else
         halt 404
       end

data/lib/robin_cms/collection_library.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class CollectionLibrary < Library
+    def create(attributes)
+      id = make_slug(attributes[:title], @schema[:pattern])
+      item = Item.new(id, attributes, **@schema)
+
+      if File.exist?(filepath(id))
+        raise ItemExistsError, "An item with the same name already exists"
+      end
+
+      write(item)
+    end
+
+    def find_one(id)
+      path = filepath(id)
+
+      return unless File.exist?(path)
+
+      deserialize(path)
+    end
+
+    def all
+      Dir.glob(filepath("*"))
+        .filter { |f| File.file?(f) }
+        .map { |path| deserialize(path) }
+    end
+
+    def write(item)
+      path = filepath(item.id)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      FileUtils.touch(path)
+
+      item.update_timestamps!
+
+      serialized = YAML.dump(item.frontmatter, stringify_names: true)
+      if item.attributes[:content]
+        serialized << "---\n"
+        serialized << item.attributes[:content]
+      end
+      File.write(path, serialized)
+
+      path
+    end
+
+    def delete(id)
+      File.delete(filepath(id))
+    end
+
+    private
+
+    def filepath(id)
+      File.join(@schema[:location], "#{id}.#{@schema[:filetype]}")
+    end
+
+    def deserialize(path)
+      raw = File.read(path)
+      id = File.basename(path, File.extname(path))
+
+      _, frontmatter, content = raw.split("---")
+
+      attributes = YAML.load(frontmatter, symbolize_names: true)
+      attributes[:content] = content.strip
+
+      Item.new(id, attributes, **@schema)
+    end
+  end
+end

data/lib/robin_cms/configuration-schema.json

@@ -50,6 +50,7 @@
 				"can_create": { "type": "boolean" },
 				"can_delete": { "type": "boolean" },
 				"pattern": { "type": "string" },
+				"display_name_pattern": { "type": "string" },
 				"fields": {
 					"type": "array",
 					"items": {
@@ -89,6 +90,7 @@
 				"can_create": { "type": "boolean" },
 				"can_delete": { "type": "boolean" },
 				"pattern": { "type": "string" },
+				"display_name_pattern": { "type": "string" },
 				"fields": {
 					"type": "array",
 					"items": {

data/lib/robin_cms/configuration.rb

@@ -102,27 +102,13 @@ module RobinCMS
     end
 
     def find_library(kind)
-      self[:libraries].find { |c| c[:id] == kind }
-    end
-
-    def sorted_fields(kind)
-      find_library(kind)
-        &.dig(:fields)
-        &.sort_by { |field| field[:order] || Float::INFINITY }
-    end
-
-    def drafts_enabled?(library)
-      collection?(library)
+      self[:libraries].find { |library| library[:id] == kind }
     end
 
     def collection?(library)
       library[:type].nil? || library[:type] == "collection"
     end
 
-    def data?(library)
-      !collection?(library)
-    end
-
     def has_image?(library)
       library[:fields].find { |f| f[:type] == "image" }
     end
@@ -148,7 +134,7 @@ module RobinCMS
       config[:libraries].each do |library|
         library[:fields].append(*AUTOMATIC_FIELDS)
 
-        if drafts_enabled?(library)
+        if collection?(library)
           library[:fields].append(*AUTOMATIC_DRAFT_FIELDS)
         end
 

data/lib/robin_cms/data_library.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class DataLibrary < Library
+    def create(attributes)
+      item = Item.new(nil, attributes, **@schema)
+      write(item)
+    end
+
+    def find_one(id)
+      all[id.to_i]
+    end
+
+    def all
+      return [] unless File.exist?(filepath)
+
+      items = YAML.load_file(filepath, symbolize_names: true)
+
+      return [] unless items
+
+      items.each_with_index.map do |attrs, i|
+        Item.new(i, attrs, **@schema)
+      end
+    end
+
+    def write(item)
+      FileUtils.mkdir_p(File.dirname(filepath))
+      FileUtils.touch(filepath)
+
+      item.update_timestamps!
+
+      all_items = YAML.load_file(filepath) || []
+      if item.id.nil?
+        all_items.append(item.frontmatter)
+      else
+        all_items[item.id.to_i] = item.frontmatter
+      end
+
+      serialized = YAML.dump(all_items, stringify_names: true)
+      File.write(filepath, serialized)
+
+      filepath
+    end
+
+    def delete(id)
+      all_items = YAML.load_file(filepath)
+      all_items[id.to_i] = nil
+      serialized = YAML.dump(all_items.compact, stringify_names: true)
+      File.write(filepath, serialized)
+    end
+
+    private
+
+    def filepath
+      File.join(@schema[:location], "#{@schema[:id]}.#{@schema[:filetype]}")
+    end
+  end
+end

data/lib/robin_cms/editable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  # This module provides methods for editing image files.
+  # No methods are required in the base class in order to use this mixin.
+  module Editable
+    def resize_image(filepath, dimensions)
+      # The mogrify command edits images in place. For more info, see
+      # mogrify(1).
+
+      system("mogrify -resize #{dimensions} #{filepath}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not resize image #{filepath}"
+      end
+    end
+
+    def format_image(filepath, filetype)
+      system("mogrify -format #{filetype} #{filepath}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not format image #{filepath}"
+      end
+
+      # The name of the converted file will be the same as the original but
+      # with a new file extension.
+      converted = filepath.sub(/#{File.extname(filepath)}$/, ".#{filetype}")
+
+      # Mogrify's format command creates a new file with the new extension.
+      # Copy the contents of this file to the original, then delete the newly
+      # created file.
+      IO.copy_stream(converted, filepath)
+      File.delete(converted)
+    end
+  end
+end

data/lib/robin_cms/item.rb

@@ -1,34 +1,104 @@
 # frozen_string_literal: true
 
 module RobinCMS
-  # This is a wrapper class for providing a uniform interface to both the
-  # DataItem class and the CollectionItem class. It's sole job is to dispatch
-  # methods to the appropriate class based on the settings of the library.
   class Item
-    METHOD_NAMES = %i[all where create! find_one blank]
+    attr_reader :id, :attributes
 
-    def self.method_missing(method_name, *args, **kwargs)
-      unless METHOD_NAMES.include?(method_name)
-        super
-        return
+    DATETIME_FORMAT = "%Y-%m-%d"
+
+    # The keys which we don't want to serialize.
+    FRONTMATTER_IGNORE_KEYS = [:id, :content, :image, :captures].freeze
+
+    def initialize(id, attrs = {}, **opts)
+      if !attrs.empty? && !attrs.has_key?(:title)
+        raise TypeError, "Missing required field `title'"
+      end
+
+      @id = id
+      @opts = opts
+
+      # Be sure to use the setter here so the keys get converted to symbols.
+      self.attributes = attrs
+    end
+
+    def attributes=(attributes)
+      @attributes = attributes.to_h.transform_keys(&:to_sym)
+
+      if attributes.has_key?(:published)
+        @attributes[:published] = attributes[:published].to_s == "true"
+      end
+    end
+
+    def inspect
+      "<#{self.class} id=\"#{id}\">"
+    end
+
+    def published?
+      if @attributes.has_key?(:published)
+        @attributes[:published]
+      else
+        true
+      end
+    end
+
+    def published_label
+      if published?
+        "Published"
+      else
+        "Draft"
       end
+    end
+
+    def created_at
+      return unless @attributes[:created_at]
+
+      Time.parse(@attributes[:created_at])
+    end
 
-      # All the class methods for DataItem and CollectionItem should have
-      # the library as the first argument.
-      library = args.first
+    def updated_at
+      return unless @attributes[:updated_at]
 
-      case library[:type]
-      when "data"
-        DataItem.send(method_name, *args, **kwargs)
-      when "collection"
-        CollectionItem.send(method_name, *args, **kwargs)
+      Time.parse(@attributes[:updated_at])
+    end
+
+    def update_timestamps!
+      timestamp = Time.now.strftime(DATETIME_FORMAT)
+
+      if !@attributes.has_key?(:created_at) || @attributes[:created_at].empty?
+        @attributes[:created_at] = timestamp
+      end
+      @attributes[:updated_at] = timestamp
+    end
+
+    def display_name
+      return @attributes[:title] unless @opts[:display_name_pattern]
+
+      @opts[:display_name_pattern].clone.tap do |name|
+        @attributes.each { |key, value| name.gsub!(":#{key}", value) }
+      end
+    end
+
+    # Get the frontmatter as a hash with stringified keys.
+    def frontmatter
+      frontmatter = @attributes.clone
+      FRONTMATTER_IGNORE_KEYS.each { |key| frontmatter.delete(key) }
+
+      if published?
+        frontmatter.delete(:published)
       else
-        super
+        frontmatter[:published] = false
       end
+
+      # The Psych module (for which YAML is an alias) has a
+      # stringify_names option which does exactly this. However it was
+      # only introduced in Ruby 3.4. Using transform_keys is a workaround
+      # to support earlier versions of Ruby.
+      frontmatter.to_h.transform_keys(&:to_s)
     end
 
-    def self.respond_to_missing?(method_name)
-      METHOD_NAMES.include?(method_name)
+    def field_value_or_default(field)
+      value = @attributes[field[:id].to_sym] || field[:default]
+      value.to_s
     end
   end
 end