robin_cms 0.1.0

data/lib/robin_cms/configuration.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class Configuration < Hash
+    DEFAULTS = {
+      title: "Robin CMS",
+      build_command: nil,
+      accent_color: "#fd8a13"
+    }.freeze
+
+    COLLECTION_DEFAULTS = {
+      type: "collection",
+      location: ".",
+      static_location: "assets",
+      filetype: "html",
+      description: "",
+      can_create: true,
+      can_delete: true,
+      fields: []
+    }.freeze
+
+    DATA_DEFAULTS = {
+      type: "data",
+      location: ".",
+      static_location: "assets",
+      filetype: "yml",
+      description: "",
+      can_create: true,
+      can_delete: true,
+      fields: []
+    }.freeze
+
+    FIELD_DEFAULTS = {
+      type: "text",
+      default: nil,
+      required: false,
+      readonly: false
+    }.freeze
+
+    AUTOMATIC_FIELDS = [{
+      label: "Title",
+      id: "title",
+      type: "text",
+      required: true,
+      order: 1
+    }, {
+      label: "Published date",
+      id: "created_at",
+      type: "hidden"
+    }, {
+      label: "Last edited",
+      id: "updated_at",
+      type: "hidden"
+    }].freeze
+
+    AUTOMATIC_DRAFT_FIELDS = [{
+      label: "Published",
+      id: "published",
+      type: "select",
+      default: false,
+      options: [{
+        label: "Draft",
+        value: false
+      }, {
+        label: "Published",
+        value: true
+      }],
+      order: 2
+    }].freeze
+
+    AUTOMATIC_IMAGE_FIELDS = [{
+      id: "image_src",
+      type: "hidden"
+    }, {
+      id: "image_alt",
+      type: "text",
+      label: "Alt text"
+    }].freeze
+
+    def self.parse(config_file: "_cms.yml", jekyll_plugin: false)
+      data = if jekyll_plugin
+        YAML.load_file("_config.yml", symbolize_names: true).then do |yaml|
+          # If running as a Jekyll plugin, get the url and title from the
+          # Jekyll config, and get everything else from the 'cms' key.
+          {url: yaml[:url], title: yaml[:title], **yaml[:cms]}
+        end
+      else
+        YAML.load_file(config_file, symbolize_names: true)
+      end
+
+      schema_file = File.join(__dir__, "configuration-schema.json")
+      schema = JSON.parse(File.read(schema_file))
+      JSON::Validator.validate!(schema, data)
+
+      config = from_h(DEFAULTS).merge_config(data).merge_automatic_fields
+      config.validate!
+      config.freeze
+    end
+
+    def self.from_h(hash)
+      hash.each_with_object(new) { |(k, v), h| h[k] = v }
+    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)
+    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
+
+    def merge_config(config)
+      merge(config, {
+        libraries: config[:libraries].map do |library|
+          library_defaults =
+            collection?(library) ? COLLECTION_DEFAULTS : DATA_DEFAULTS
+
+          library_defaults.merge(library, {
+            fields: library[:fields].map do |field|
+              FIELD_DEFAULTS.merge(field)
+            end
+          })
+        end
+      })
+    end
+
+    def merge_automatic_fields
+      config = clone
+
+      config[:libraries].each do |library|
+        library[:fields].append(*AUTOMATIC_FIELDS)
+
+        if drafts_enabled?(library)
+          library[:fields].append(*AUTOMATIC_DRAFT_FIELDS)
+        end
+
+        if has_image?(library)
+          library[:fields].append(*AUTOMATIC_IMAGE_FIELDS)
+        end
+
+        library[:fields].uniq! { |f| f[:id] }
+      end
+
+      config
+    end
+
+    # This method provides custom validation which can't be expressed (or is
+    # too difficult to express) using the Json Schema standard.
+    def validate!
+      self[:libraries].each do |library|
+        next if library[:fields].nil?
+
+        if library[:fields].count { |f| f[:type] == "richtext" } > 1
+          raise ValidationError, "Only one richtext field per library allowed"
+        end
+
+        if library[:fields].count { |f| f[:type] == "image" } > 1
+          raise ValidationError, "Only one image field per library allowed"
+        end
+      end
+    end
+  end
+end

data/lib/robin_cms/data_item.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class DataItem
+    include Itemable
+    extend Queryable
+
+    def self.blank(library)
+      new(nil, library)
+    end
+
+    def self.create!(library, attributes)
+      new(nil, library, attributes).tap do |item|
+        item.save!
+      end
+    end
+
+    def self.find_one(library, id)
+      all(library)[id.to_i]
+    end
+
+    def self.all(library)
+      location = library[:location]
+      name = library[:id]
+      ext = library[:filetype]
+      path = File.join(location, "#{name}.#{ext}")
+
+      return [] unless File.exist?(path)
+
+      deserialize(library, path)
+    end
+
+    def self.deserialize(library, path)
+      raw = File.read(path)
+      items = YAML.load(raw, symbolize_names: true)
+
+      return [] unless items
+
+      items.each_with_index.map do |attrs, i|
+        new(i, library, attrs)
+      end
+    end
+
+    private_class_method :deserialize
+
+    def initialize(id, library, attrs = {})
+      super
+
+      @mark_for_deletion = false
+    end
+
+    def filepath
+      location = @library[:location]
+      name = @library[:id]
+      ext = @library[:filetype]
+      File.join(location, "#{name}.#{ext}")
+    end
+
+    def delete!
+      @mark_for_deletion = true
+      save!
+    end
+
+    private
+
+    def serialize
+      # See comment in corresponding method in lib/collection_item.rb.
+      fm = frontmatter.to_h.transform_keys(&:to_s)
+
+      items = if File.exist?(filepath)
+        raw = File.read(filepath)
+        YAML.load(raw)
+      else
+        []
+      end
+
+      if @mark_for_deletion
+        items[@id.to_i] = nil
+      elsif @id.nil?
+        items.append(fm)
+      else
+        items[@id.to_i] = fm
+      end
+
+      YAML.dump(items.compact, stringify_names: true)
+    end
+  end
+end

data/lib/robin_cms/flash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class Flash
+    attr_reader :now, :next
+
+    def initialize(hash)
+      @now = hash || {}
+      @next = {}
+    end
+
+    def []=(key, value)
+      @next[key] = value
+    end
+
+    def method_missing(method_name, *args)
+      @now.send(method_name, *args)
+    end
+
+    def respond_to_missing?(method_name)
+      true
+    end
+  end
+end

data/lib/robin_cms/helpers.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  module Helpers
+    SORT_OPTIONS = [{
+      label: "Sort by name (a-z)",
+      value: "id"
+    }, {
+      label: "Sort by name (z-a)",
+      value: "-id"
+    }, {
+      label: "Sort by created date (newest - oldest)",
+      value: "created_at"
+    }, {
+      label: "Sort by created date (oldest - newest)",
+      value: "-created_at"
+    }, {
+      label: "Sort by updated date (newest - oldest)",
+      value: "updated_at"
+    }, {
+      label: "Sort by updated date (oldest - newest)",
+      value: "-updated_at"
+    }].freeze
+
+    PUBLISHED_OPTIONS = [{
+      label: "Any status",
+      value: ""
+    }, {
+      label: "Draft",
+      value: "false"
+    }, {
+      label: "Published",
+      value: "true"
+    }].freeze
+
+    def query_params
+      URI.decode_www_form(request.query_string).to_h
+    end
+
+    def current_page
+      _, libraries, item = request.path_info.split("/")
+      item || libraries
+    end
+
+    def home_page
+      "/libraries/#{@config[:libraries].first[:id]}"
+    end
+
+    # For generating safe id's where the id needs to be based on user
+    # input. Prevents potential id collisions.
+    def safe_id(id, prefix)
+      id = id.to_s.tr("-", "_").gsub(/\W+/, "")
+      "__#{prefix}_#{id}"
+    end
+
+    def flash
+      @flash ||= Flash.new(session ? session[:flash] : {})
+    end
+  end
+end

data/lib/robin_cms/item.rb

@@ -0,0 +1,34 @@
+# 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]
+
+    def self.method_missing(method_name, *args, **kwargs)
+      unless METHOD_NAMES.include?(method_name)
+        super
+        return
+      end
+
+      # All the class methods for DataItem and CollectionItem should have
+      # the library as the first argument.
+      library = args.first
+
+      case library[:type]
+      when "data"
+        DataItem.send(method_name, *args, **kwargs)
+      when "collection"
+        CollectionItem.send(method_name, *args, **kwargs)
+      else
+        super
+      end
+    end
+
+    def self.respond_to_missing?(method_name)
+      METHOD_NAMES.include?(method_name)
+    end
+  end
+end

data/lib/robin_cms/itemable.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  module Itemable
+    attr_reader :id, :library, :attributes
+
+    DATETIME_FORMAT = "%Y-%m-%d"
+
+    # The keys which we don't want to serialize.
+    SERIALIZE_IGNORE_KEYS = [:id, :kind, :content, :image, :captures].freeze
+
+    def initialize(id, library, attrs = {})
+      [:id, :location, :filetype].each do |key|
+        unless library.has_key?(key)
+          raise TypeError, "Missing required field #{key}"
+        end
+      end
+
+      if !attrs.empty? && !attrs.has_key?(:title)
+        raise TypeError, "Missing required field `title'"
+      end
+
+      @id = id
+      @library = library
+
+      # 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 kind
+      @library[:id]
+    end
+
+    def inspect
+      "<#{self.class} id=\"#{id}\" kind=\"#{kind}\">"
+    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
+      if @attributes[:created_at]
+        Time.parse(@attributes[:created_at])
+      else
+        File.birthtime(filepath)
+      end
+    end
+
+    def updated_at
+      if @attributes[:updated_at]
+        Time.parse(@attributes[:updated_at])
+      else
+        File.mtime(filepath)
+      end
+    end
+
+    def display_name
+      return @attributes[:title] unless @library[:display_name_pattern]
+
+      @library[:display_name_pattern].clone.tap do |name|
+        @attributes.each { |key, value| name.gsub!(":#{key}", value) }
+      end
+    end
+
+    def save!
+      timestamp = Time.now.strftime(DATETIME_FORMAT)
+      @attributes[:created_at] = timestamp
+      @attributes[:updated_at] = timestamp
+
+      FileUtils.mkdir_p(File.dirname(filepath))
+      File.write(filepath, serialize)
+    end
+
+    def update!
+      timestamp = Time.now.strftime(DATETIME_FORMAT)
+      @attributes[:updated_at] = timestamp
+
+      if !@attributes.has_key?(:created_at) || @attributes[:created_at].empty?
+        @attributes[:created_at] = timestamp
+      end
+
+      FileUtils.mkdir_p(File.dirname(filepath))
+      File.write(filepath, serialize)
+    end
+
+    def delete!
+      File.delete(filepath)
+    end
+
+    def frontmatter
+      frontmatter = @attributes.clone
+      SERIALIZE_IGNORE_KEYS.each { |key| frontmatter.delete(key) }
+
+      if published?
+        frontmatter.delete(:published)
+      else
+        frontmatter[:published] = false
+      end
+
+      frontmatter
+    end
+  end
+end

data/lib/robin_cms/queryable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  module Queryable
+    def where(library, **kwargs)
+      by_published = lambda do |i|
+        case kwargs[:published]
+        when nil, ""
+          true
+        when "true", true
+          i.published?
+        when "false", false
+          !i.published?
+        end
+      end
+
+      by_search = lambda do |i|
+        return true if kwargs[:q].nil?
+
+        i.attributes[:title].match?(/#{kwargs[:q]}/i)
+      end
+
+      by_field = lambda do |a, b|
+        return 0 if kwargs[:sort].nil?
+
+        sort_by = kwargs[:sort].sub("-", "").to_sym
+        sort_direction = kwargs[:sort].start_with?("-") ? -1 : 1
+
+        case sort_by
+        when :id
+          a.id <=> b.id
+        when :created_at, :updated_at
+          b.attributes[sort_by] <=> a.attributes[sort_by]
+        end * sort_direction
+      end
+
+      all(library)
+        .filter(&by_search)
+        .filter(&by_published)
+        .sort(&by_field)
+    end
+
+    def count(library)
+      all(library).size
+    end
+  end
+end

data/lib/robin_cms/sluggable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  module Sluggable
+    def make_slug(str, pattern = nil)
+      title = str.gsub(/\s/, "-").gsub(/[^\.\w-]/, "").downcase
+
+      return title unless pattern
+
+      now = Time.now
+
+      # If the pattern starts with a colon and is without quotes in the yaml
+      # file, Ruby will interpret it as a symbol when it parses the file.
+      # Convert it to a string to be safe.
+      pattern.to_s
+        .gsub(":year", now.strftime("%Y"))
+        .gsub(":month", now.strftime("%m"))
+        .gsub(":day", now.strftime("%d"))
+        .gsub(":title", title)
+    end
+  end
+end

data/lib/robin_cms/static_item.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RobinCMS
+  class StaticItem
+    attr_reader :library
+
+    def initialize(library, filename, tempfile = nil)
+      @library = library
+      @filename = filename
+      @tempfile = tempfile
+    end
+
+    def save!
+      if File.exist?(filepath)
+        raise ItemExistsError, "An item with the same name already exists"
+      end
+
+      image_field = @library[:fields].find { |f| f[:type] == "image" }
+      dimensions = image_field && image_field[:dimensions]
+      filetype = image_field && image_field[:filetype]
+
+      resize_image!(dimensions) if dimensions
+      format_image!(filetype) if filetype
+
+      FileUtils.mkdir_p(File.dirname(filepath))
+      FileUtils.cp(@tempfile, filepath)
+    end
+
+    def delete!
+      File.delete(filepath)
+    end
+
+    def filepath
+      File.join(@library[:static_location], File.basename(@filename))
+    end
+
+    class << self
+      include Sluggable
+
+      def create!(library, filename, tempfile)
+        sluggified_filename = make_slug(filename)
+        new(library, sluggified_filename, tempfile).tap do |item|
+          item.save!
+        end
+      end
+
+      def find_one(library, filename)
+        path = File.join(library[:static_location], File.basename(filename))
+
+        return unless File.exist?(path)
+
+        new(library, filename)
+      end
+
+      def delete_if_exists!(library, filename)
+        find_one(library, filename)&.delete!
+      end
+    end
+
+    private
+
+    def resize_image!(dimensions)
+      # The mogrify command edits images in place. For more info, see
+      # mogrify(1).
+
+      system("mogrify -resize #{dimensions} #{@tempfile.to_path}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not resize image #{@tempfile.to_path}"
+      end
+    end
+
+    def format_image!(filetype)
+      system("mogrify -format #{filetype} #{@tempfile.to_path}")
+      if $?.exitstatus != 0
+        raise ConversionError, "Could not format image #{@tempfile.to_path}"
+      end
+
+      # The name of the converted file will be the same as the original but
+      # with a new file extension.
+      converted = @tempfile.to_path.sub(/#{File.extname(@tempfile)}$/, ".#{filetype}")
+
+      # Mogrify's format command creates a new file with the new extension.
+      # Copy the contents of this file to the tempfile, then delete the newly
+      # created file.
+      IO.copy_stream(converted, @tempfile.to_path)
+      File.delete(converted)
+
+      # Update the file extension of the uploaded file.
+      @filename.sub!(/#{File.extname(@filename)}$/, ".#{filetype}")
+    end
+  end
+end

data/lib/robin_cms/version.rb

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

data/lib/robin_cms/views/change_password.erb

@@ -0,0 +1,22 @@
+<header class="card">
+  <h2>Change password</h2>
+</header>
+<form class="card" name="change-password" method="post">
+  <div class="field">
+    <label for="old-password">Old password</label>
+    <input id="old-password" type="password" name="old_password" required />
+  </div>
+  <div class="field">
+    <label for="new-password">New password</label>
+    <input id="new-password" type="password" name="new_password" required />
+  </div>
+  <div class="field">
+    <label for="confirm-password">Confirm password</label>
+    <input id="confirm-password" type="password" name="confirm_password" required />
+  </div>
+  <%= erb :flash %>
+  <footer class="controls --align-right">
+    <a href="/admin">Back</a>
+    <button type="submit">Update</button>
+  </footer>
+</form>