robin_cms 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 398d0d377f476c68de1e02e504cbe7353347e1f93835d3cce55811d7a90e82a3
-  data.tar.gz: 5b253a4f07db5e5282bf879695ec96ed51d28a2b8e667f1110213b45e0c63e98
+  metadata.gz: d3a49ee1ef9d638a300e82352bba65071dc6dfffecfb4cb409fbf8cbb8fbdd69
+  data.tar.gz: 928887dfc693144ebaaf9f2233a08b161faa7146ab7a037501098052d046fe74
 SHA512:
-  metadata.gz: b976e15a5ca7c7af3f44f8be1ee2df5f6ddfe766ddfedafeb6c17dd41c48dc449e13d819b0dcdac17c23263a04d9c3e7e99a1f3cc5b66d97b562c7fc8d77ecfb
-  data.tar.gz: 609ed3f32088e434615486ba25da6fdb199a074b0d628ee5e58f45b13f80151b7319437bad45538d636158e6b522701e3960663b2269db5f78ea3699e233ea07
+  metadata.gz: 17bcd5f6cc1d057c6740fb3d7cf393432cd823956fcf4e78421b085cfc1ec3ef382c40b776b5f570cfb295af6cae71fd8a0711e5accc118641509bc519947bd9
+  data.tar.gz: e7f2f736f7535dce94edbe15a41c24201959e1231d0827c542ec3b4560215d1285e49f1d94321a57bdca50c1cfd85015f8a11f74cbd952b967081e7f5b3291a3

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

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
@@ -50,7 +53,6 @@ module RobinCMS
 
     post "/login" do
       authenticate!(params[:username], params[:password])
-
       session[:auth_user] = params[:username]
       redirect to(home_page)
     rescue AuthenticationError
@@ -80,11 +82,9 @@ module RobinCMS
       end
 
       authenticate!(session[:auth_user], params[:old_password])
-
       update_credentials(params[:new_password])
       session[:auth_user] = nil
       flash[:success] = "Password updated succesfully. Please log in with your new credentials."
-
       redirect to("/login")
     rescue AuthenticationError
       flash[:error] = "Incorrect username or password"
@@ -92,75 +92,72 @@ 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])
-        halt 404 unless @item
-      else
-        @item = Item.blank(@library)
-      end
+      @item = @library.blank
+      erb :library_item
+    end
 
+    get "/libraries/:kind/item/:id" do
+      @item = @library.find_one(params[:id])
+      halt 404 unless @item
       erb :library_item
     end
 
     post "/libraries/:kind/item" do
-      if params[:id]
-        @item = Item.find_one(@library, params[:id])
-        halt 404 unless @item
-
-        if params[:image]
-          filename = params[:image][:filename]
-          tempfile = params[:image][:tempfile]
-
-          StaticItem.delete_if_exists!(@library, @item.attributes[:image_src])
-          StaticItem.create!(@library, filename, tempfile).then do |s|
-            params[:image_src] = "/" + s.filepath
-          end
-        end
-
-        @item.attributes = params
-        @item.update!
-      else
-        if params[:image]
-          filename = params[:image][:filename]
-          tempfile = params[:image][:tempfile]
-
-          StaticItem.create!(@library, filename, tempfile).then do |s|
-            params[:image_src] = "/" + s.filepath
-          end
-        end
-
-        Item.create!(@library, params)
+      if params[:image]
+        static_path = @library.create_static(
+          params[:image][:filename],
+          params[:image][:tempfile].to_path
+        )
+        params[:image_src] = "/" + static_path
       end
 
+      @library.create(params)
       redirect to("/libraries/#{params[:kind]}")
     rescue ItemExistsError
       flash[:error] = "An item with the same name already exists"
       redirect to("/libraries/#{params[:kind]}/item")
     end
 
-    post "/libraries/:kind/item/delete" do
-      if params[:id]
-        @item = Item.find_one(@library, params[:id])
-        halt 404 unless @item
+    post "/libraries/:kind/item/:id" do
+      @item = @library.find_one(params[:id])
+      halt 404 unless @item
 
-        if @item.attributes[:image_src]
-          StaticItem.delete_if_exists!(@library, @item.attributes[:image_src])
+      if params[:image]
+        # If there is an existing image for this item, delete it to prevent
+        # accumulation of old files.
+        if @item.attributes[:image_src] && !@item.attributes[:image_src].empty?
+          @library.delete_static(@item.attributes[:image_src])
         end
+        static_path = @library.create_static(
+          params[:image][:filename],
+          params[:image][:tempfile].to_path
+        )
+        params[:image_src] = "/" + static_path
+      end
 
-        @item.delete!
-      else
-        halt 404
+      @item.attributes = params
+      @library.write(@item)
+      redirect to("/libraries/#{params[:kind]}")
+    end
+
+    post "/libraries/:kind/item/:id/delete" do
+      @item = @library.find_one(params[:id])
+      halt 404 unless @item
+
+      if @item.attributes[:image_src]
+        @library.delete_static(@item.attributes[:image_src])
       end
 
+      @library.delete(@item.id)
       redirect to("/libraries/#{params[:kind]}")
     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,40 @@
+# 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, to:)
+      # The mogrify command edits images in place. For more info, see
+      # mogrify(1).
+      system("mogrify -resize #{to} #{filepath}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not resize image #{filepath}"
+      end
+    end
+
+    def convert_image(filepath, to:)
+      system("mogrify -format #{to} #{filepath}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not format image #{filepath}"
+      end
+
+      # The file created by the mogrify command will be the same as the
+      # original but with the new file extension.
+      converted = filepath.sub(/#{File.extname(filepath)}$/, ".#{to}")
+
+      if converted == filepath
+        # If the converted file has the same filename as the original (i.e. no
+        # conversion happened), there is nothing more to do.
+        filepath
+      else
+        # Otherwise, copy the contents of the mogrify output file to a new
+        # tempfile and delete the mogrify output.
+        tempfile = Tempfile.new(["robin_cms" ".#{to}"])
+        IO.copy_stream(converted, tempfile)
+        File.delete(converted)
+        tempfile
+      end
+    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

data/lib/robin_cms/library.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class Library
+    include Editable
+    include Sluggable
+    include Queryable
+
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = schema.freeze
+    end
+
+    def blank
+      Item.new(nil, **@schema)
+    end
+
+    def create(attributes)
+      raise NotImplementedError
+    end
+
+    def find_one(id)
+      raise NotImplementedError
+    end
+
+    def all
+      raise NotImplementedError
+    end
+
+    # Writes the specified item to disk.
+    #
+    # Returns the path where the item was written.
+    def write(item)
+      raise NotImplementedError
+    end
+
+    # Delete the item specified by +id+.
+    def delete(id)
+      raise NotImplementedError
+    end
+
+    def create_static(filename, tempfile)
+      path = File.join(@schema[:static_location], File.basename(make_slug(filename)))
+      FileUtils.mkdir_p(File.dirname(path))
+
+      if File.exist?(path)
+        raise ItemExistsError, "An item with the same name already exists"
+      end
+
+      image_field = @schema[:fields].find { |f| f[:type] == "image" }
+      dimensions = image_field&.dig(:dimensions)
+      filetype = image_field&.dig(:filetype)
+
+      resize_image(tempfile, to: dimensions) if dimensions
+
+      # Only convert if the specified filetype is different to the actual
+      # filetype. Unlike resize_image which modifies the image in-pace, this
+      # function necessarily creates a new file, so we need to ensure we
+      # update the path with the new file extension.
+      if filetype && File.extname(tempfile) != ".#{filetype}"
+        tempfile = convert_image(tempfile, to: filetype)
+        path = File.join(File.dirname(path), "#{File.basename(path, '.*')}.#{filetype}")
+      end
+
+      FileUtils.cp(tempfile, path)
+      path
+    end
+
+    def delete_static(filename)
+      return if filename.nil? || filename.empty?
+      path = File.join(@schema[:static_location], File.basename(filename))
+      return unless File.exist?(path)
+
+      File.delete(path)
+    end
+
+    def drafts_enabled?
+      @schema[:type].nil? || @schema[:type] == "collection"
+    end
+
+    def sorted_fields
+      @schema[:fields].sort_by { |field| field[:order] || Float::INFINITY }
+    end
+
+    def [](key)
+      @schema[key]
+    end
+
+    def kind
+      @schema[:id]
+    end
+  end
+end

data/lib/robin_cms/queryable.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
 module RobinCMS
+  # This module provides methods for querying items.
+  #
+  # In order to use this as a mixin, you only need to implement an +all+
+  # method in the base class. This method should take no parameters, and
+  # return all items.
   module Queryable
-    def where(library, **kwargs)
+    def query(**kwargs)
       by_published = lambda do |i|
         case kwargs[:published]
         when nil, ""
@@ -34,14 +39,11 @@ module RobinCMS
         end * sort_direction
       end
 
-      all(library)
-        .filter(&by_search)
-        .filter(&by_published)
-        .sort(&by_field)
+      all.filter(&by_search).filter(&by_published).sort(&by_field)
     end
 
-    def count(library)
-      all(library).size
+    def count
+      all.size
     end
   end
 end

data/lib/robin_cms/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RobinCMS
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end