robin_cms 0.1.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68c3b702cf90bbb615ebeea6303a3f12e4e5da64b3360b295a198b9347ea11bb
-  data.tar.gz: d266f45a2863ee190014bcd3174f0413fb70a5f745aaef74780f0a9ca7d6b3eb
+  metadata.gz: 26f13be1b3e97bce69e705daf56e969916467591b7c30b2877c2ce29e07e62d3
+  data.tar.gz: 7f34fbee635184285025e757e3c52ef8e25467255ed4a90647203bbfcd656756
 SHA512:
-  metadata.gz: 12d3f8064c84a26a3e3899ca964e411609ca03de3c193466aab157530d1022ffa0ae45237545260ad9a35377e07ff5cb09325c00c682cfd790247c1879b6dde4
-  data.tar.gz: d73739c5b1b1c83b4fc7f3d80363353318a0b69164fba07ad784a738d8e5c23c8cea6c73c1d55542279c6a38929dc65ffc673870669781cf9df2a631cb21bebd
+  metadata.gz: a420e205f0f06d34817b5cb1424f513051cddb7a665dcddb9d707c091088969e7031bef154542347691fe109a612f58741c229f622380281e4289a2bcfa1a268
+  data.tar.gz: 7d1e1bbd2b23d02c02a7dcca004c35015663bb2ece865f7d4ebfabbcd96e2897bc95bd758bd64145cb70d5ef2f7819717d195417f7121254080773b1f70a9f43

data/README.md

@@ -72,7 +72,8 @@ standalone CMS for any Static Site Generator, you can embed it in a dynamic
 Sinatra app, or you can use it as a Jekyll plugin. If you're already using
 Jekyll as your SSG, this is the simplest approach.
 
-See the [documentation](./docs/index.adoc) for further information on usage.
+See the [documentation](https://robincms.org/docs.html) for further information
+on usage.
 
 ## Configuring
 
@@ -100,8 +101,8 @@ schema for your content. An example YAML file looks like this:
           - { label: Title, id: title, type: input }
           - { label: Author, id: author_name, type: input }
 
-See the [docs](./docs/index.adoc) for more details on configuration. You can
-also find some examples [here](./examples).
+See the [docs](https://robincms.org/docs.html) for more details on
+configuration. You can also find some examples [here](./examples).
 
 ## Testing
 
@@ -109,6 +110,10 @@ Unit test are written in RSpec. To run them:
 
     rake test
 
+## Screenshot
+
+![Robin CMS screenshot](./assets/screenshot.png)
+
 ## Roadmap
 
 * [ ] Support markdown content

data/lib/robin_cms/cms.rb

@@ -37,7 +37,7 @@ module RobinCMS
     end
 
     get "/" do
-      redirect to(root_url)
+      redirect to(home)
     end
 
     get "/login" do
@@ -47,7 +47,7 @@ module RobinCMS
     post "/login" do
       authenticate!(params[:username], params[:password])
       session[:auth_user] = params[:username]
-      redirect to(root_url)
+      redirect to(home)
     rescue AuthenticationError
       flash[:error] = "Incorrect username or password"
       redirect to("/login")
@@ -90,6 +90,11 @@ module RobinCMS
         published: params[:published],
         q: params[:q]
       )
+
+      if @library.singular?
+        redirect to("/libraries/#{params[:kind]}/item/0")
+      end
+
       erb :library
     end
 
@@ -154,6 +159,21 @@ module RobinCMS
       redirect to("/libraries/#{params[:kind]}")
     end
 
+    # Handle uploading attachments from the trix editor. Responds with the path
+    # of the uploaded file in JSON format.
+    post "/libraries/:kind/attachment" do
+      static_path = @library.create_static(
+        params[:key],
+        params[:file][:tempfile].to_path
+      )
+
+      { :url => "/" + static_path }.to_json
+    end
+
+    post "/libraries/:kind/attachment/delete" do
+      @library.delete_static(params[:key])
+    end
+
     post "/publish" do
       system(@config[:build_command])
       if $?.exitstatus == 0
@@ -162,27 +182,21 @@ module RobinCMS
         flash[:error_dialog] = "There was an error publishing the site."
       end
 
-      redirect to(root_url)
+      redirect to(home)
     end
 
-    not_found do
-      # This is a hack for showing previews of images uploaded in libraries.
-      # It is needed because until you publish the site, the image is not
-      # copied to the site output, and therefore requests for the file will
-      # return a 404. Note that if using it as a Jekyll plugin, this is not
-      # needed as the files will be served by Jekyll's dev server.
-
-      # Need to use `PATH_INFO` for the same reason we need to use the `url`
-      # and `to` helpers - we want the request URI relative to the path that
-      # the app is mounted at i.e. the virtual location.
-      uri = env["PATH_INFO"]
-
-      library = @config[:libraries].find do |c|
-        uri.start_with?("/#{c[:static_location]}")
-      end
+    # Explicitly serve static files for previewing in the CMS. This is
+    # necessary because until you publish the site, static files are not copied
+    # to the site output, and therefore requests for the file will return a
+    # 404. Note that if using it as a Jekyll plugin, this is not needed as the
+    # files will be served by Jekyll's dev server.
+    #
+    # This route needs to be defined last since it catches a wide range of URLs.
+    get "/:static_location/:key" do
+      static_locations = @config[:libraries].map { |l| l[:static_location] }.uniq
 
-      if library
-        send_file(File.join(library[:static_location], File.basename(uri)))
+      if static_locations.include?(params[:static_location])
+        send_file(File.join(params[:static_location], params[:key]))
       else
         pass
       end

data/lib/robin_cms/configuration.rb

@@ -10,9 +10,10 @@ module RobinCMS
 
     COLLECTION_DEFAULTS = {
       type: "collection",
-      location: ".",
-      static_location: "assets",
+      location: "_posts",
+      static_location: "uploads",
       filetype: "html",
+      pattern: ":year-:month-:day-:title",
       description: "",
       can_create: true,
       can_delete: true,
@@ -21,8 +22,8 @@ module RobinCMS
 
     DATA_DEFAULTS = {
       type: "data",
-      location: ".",
-      static_location: "assets",
+      location: "_data",
+      static_location: "uploads",
       filetype: "yml",
       description: "",
       can_create: true,
@@ -30,6 +31,17 @@ module RobinCMS
       fields: []
     }.freeze
 
+    SINGULAR_DEFAULTS = {
+      type: "singular",
+      location: "_data",
+      static_location: "uploads",
+      filetype: "yml",
+      description: "",
+      can_create: false,
+      can_delete: false,
+      fields: []
+    }.freeze
+
     FIELD_DEFAULTS = {
       type: "text",
       default: nil,
@@ -54,11 +66,10 @@ module RobinCMS
       type: "hidden"
     }].freeze
 
-    AUTOMATIC_DRAFT_FIELDS = [{
+    AUTOMATIC_COLLECTION_FIELDS = [{
       label: "Published",
       id: "published",
       type: "select",
-      default: false,
       options: [{
         label: "Draft",
         value: false
@@ -72,6 +83,14 @@ module RobinCMS
       order: 2
     }].freeze
 
+    AUTOMATIC_SINGULAR_FIELDS = [{
+      label: "Title",
+      id: "title",
+      type: "hidden",
+      required: true,
+      order: 1
+    }]
+
     AUTOMATIC_IMAGE_FIELDS = [{
       id: "image_src",
       type: "hidden"
@@ -94,9 +113,13 @@ module RobinCMS
         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)
+      schema = ConfigurationSchema.schema
+      errors = JSON::Validator.fully_validate(schema, data)
+
+      unless errors.empty?
+        puts errors
+        raise ValidationError, "There is an error in your configuration file"
+      end
 
       config = from_h(DEFAULTS).merge_config(data).merge_automatic_fields
       config.validate!
@@ -115,15 +138,24 @@ module RobinCMS
       library[:type].nil? || library[:type] == "collection"
     end
 
-    def has_image?(library)
-      library[:fields].find { |f| f[:type] == "image" }
+    def data?(library)
+      library[:type] == "data"
+    end
+
+    def singular?(library)
+      library[:type] == "singular"
     end
 
     def merge_config(config)
       merge(config, {
         libraries: config[:libraries].map do |library|
-          library_defaults =
-            collection?(library) ? COLLECTION_DEFAULTS : DATA_DEFAULTS
+          library_defaults = if collection?(library)
+            COLLECTION_DEFAULTS
+          elsif data?(library)
+            DATA_DEFAULTS
+          elsif singular?(library)
+            SINGULAR_DEFAULTS
+          end
 
           library_defaults.merge(library, {
             fields: library[:fields].map do |field|
@@ -141,11 +173,22 @@ module RobinCMS
         library[:fields].append(*AUTOMATIC_FIELDS)
 
         if collection?(library)
-          library[:fields].append(*AUTOMATIC_DRAFT_FIELDS)
+          library[:fields].append(*AUTOMATIC_COLLECTION_FIELDS)
+        end
+
+        # Replace the automatic title field with a hidden one. The title is not
+        # used for singular fields, but every item is required to have one, so
+        # hide it in the UI.
+        if singular?(library)
+          # Using prepend ensures this one stays when we call uniq! below.
+          library[:fields].prepend(*AUTOMATIC_SINGULAR_FIELDS)
         end
 
-        if has_image?(library)
-          library[:fields].append(*AUTOMATIC_IMAGE_FIELDS)
+        # Ensure the automatic image fields are inserted directly after the
+        # declared image field.
+        image_index = library[:fields].find_index { |f| f[:type] == "image" }
+        if image_index
+          library[:fields].insert(image_index + 1, *AUTOMATIC_IMAGE_FIELDS)
         end
 
         library[:fields].uniq! { |f| f[:id] }
@@ -156,6 +199,8 @@ module RobinCMS
 
     # This method provides custom validation which can't be expressed (or is
     # too difficult to express) using the Json Schema standard.
+    #
+    # TODO: validate that options are given if the field type is select.
     def validate!
       self[:libraries].each do |library|
         next if library[:fields].nil?

data/lib/robin_cms/configuration_schema.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal => true
+
+module RobinCMS
+  module ConfigurationSchema
+    def self.field_schema(kind)
+      field_types = [
+        "text",
+        "date",
+        "hidden",
+        "number",
+        "color",
+        "email",
+        "url",
+        "select",
+        "image"
+      ]
+
+      if kind == "collection"
+        field_types << "richtext"
+        field_types << "array"
+      end
+
+      {
+        "type" => "object",
+        "required" => ["id", "label"],
+        "properties" => {
+          "id" => { "type" => "string" },
+          "label" => { "type" => "string" },
+          "type" => { "type" => "string", "enum" => field_types },
+          "default" => { "type" => "string" },
+          "required" => { "type" => "boolean" },
+          "readonly" => { "type" => "boolean" },
+          "option" => {
+            "type" => "array",
+            "items" => {
+              "type" => "object",
+              "required" => ["label", "value"],
+              "properties" => {
+                "label" => { "type" => "string" },
+                "value" => { "type" => "string" }
+              }
+            }
+          },
+          "dimensions" => { "type" => "string", "pattern" => "^[0-9]+x[0-9]+$" },
+          "filetype" => { "type" => "string", "enum" => ["png", "jpg"] },
+          "description" => { "type" => "string" },
+          "order" => { "type" => "number" }
+        }
+      }
+    end
+
+    def self.library_schema(kind)
+      filetypes = case kind
+      when "collection"
+        ["html"]
+      when "data", "singular"
+        ["yml"]
+      end
+
+      {
+        "type" => "object",
+        "required" => ["id", "label", "label_singular"],
+        "properties" => {
+          "id" => { "type" => "string" },
+          "type" => { "type" => "string", "const" => kind },
+          "filetype" => { "type" => "string", "enum" => filetypes },
+          "label" => { "type" => "string" },
+          "label_singular" => { "type" => "string" },
+          "location" => { "type" => "string" },
+          "static_location" => { "type" => "string" },
+          "description" => { "type" => "string" },
+          "can_create" => { "type" => "boolean" },
+          "can_delete" => { "type" => "boolean" },
+          "pattern" => { "type" => "string" },
+          "display_name_pattern" => { "type" => "string" },
+          "fields" => { "type" => "array", "items" => field_schema(kind) }
+        }
+      }
+    end
+
+    def self.schema
+      {
+        "$schema" => "http://json-schema.org/draft-06/schema#",
+        "title" => "RobinCMS configuration schema",
+        "type" => "object",
+        "required" => ["url", "libraries"],
+        "properties" => {
+          "title" => { "type" => "string" },
+          "url" => { "type" => "string" },
+          "build_command" => { "type" => "string" },
+          "accent_color" => {
+            "type" => "string",
+            "pattern" => '^\\#{1}[a-fA-F0-9]{6}'
+          },
+          "libraries" => {
+            "type" => "array",
+            "items" => {
+              "anyOf" => [
+                library_schema("collection"),
+                library_schema("data"),
+                library_schema("singular")
+              ]
+            }
+          }
+        }
+      }
+    end
+  end
+end

data/lib/robin_cms/data_library.rb

@@ -14,10 +14,11 @@ module RobinCMS
     def all
       return [] unless File.exist?(filepath)
 
-      items = YAML.load_file(filepath, symbolize_names: true)
+      items = YAML.load_file(filepath, symbolize_names: true, permitted_classes: [Date])
 
       return [] unless items
 
+      # Use the index of the item as it's id.
       items.each_with_index.map do |attrs, i|
         Item.new(i, attrs, **@schema)
       end
@@ -29,11 +30,17 @@ module RobinCMS
 
       item.update_timestamps!
 
+      # The item's id is it's index in the YAML array. If the id is nil, we are
+      # creating a new item; append it to the end of the array. If the id is
+      # not nil, we are editing an item; swap out the item at the index
+      # corresponding to it's id.
       all_items = YAML.load_file(filepath) || []
       if item.id.nil?
-        all_items.append(item.frontmatter)
+        # Data items don't have a published state.
+        all_items.append(item.frontmatter(ignore_published: true))
       else
-        all_items[item.id.to_i] = item.frontmatter
+        # As above.
+        all_items[item.id.to_i] = item.frontmatter(ignore_published: true)
       end
 
       serialized = YAML.dump(all_items, stringify_names: true)

data/lib/robin_cms/helpers.rb

@@ -37,44 +37,64 @@ module RobinCMS
       URI.decode_www_form(request.query_string).to_h
     end
 
+    def home
+      "/libraries/#{@config[:libraries].first[:id]}"
+    end
+
+    def path(addr)
+      url(addr, absolute = false)
+    end
+
     def root_url
-      url("/libraries/#{@config[:libraries].first[:id]}")
+      path("/")
+    end
+
+    def home_url
+      path(home)
     end
 
     def profile_url
-      url("/profile")
+      path("/profile")
     end
 
     def logout_url
-      url("/logout")
+      path("/logout")
     end
 
     def change_password_url
-      url("/change-password")
+      path("/change-password")
     end
 
     def library_url(library)
-      url("/libraries/#{library[:id]}")
+      path("/libraries/#{library[:id]}")
     end
 
     def library_item_url(library, item = nil)
       if item
-        url("/libraries/#{library[:id]}/item/#{item.id}")
+        path("/libraries/#{library[:id]}/item/#{item.id}")
       else
-        url("/libraries/#{library[:id]}/item")
+        path("/libraries/#{library[:id]}/item")
       end
     end
 
     def delete_library_item_url(library, item)
-      url("/libraries/#{library[:id]}/item/#{item.id}/delete")
+      path("/libraries/#{library[:id]}/item/#{item.id}/delete")
+    end
+
+    def library_attachment_url(library)
+      path("/libraries/#{library[:id]}/attachment")
+    end
+
+    def delete_library_attachment_url(library)
+      path("/libraries/#{library[:id]}/attachment/delete")
     end
 
     def item_image_url(item)
-      url(item.image_src)
+      path(item.image_src)
     end
 
     def publish_url
-      url("/publish")
+      path("/publish")
     end
 
     def current_page?(library)
@@ -90,6 +110,22 @@ module RobinCMS
       "__#{prefix}_#{id}"
     end
 
+    # The attachments for Trix need to be served from the admin site root
+    # (usually "/admin") in order for the catch-all route handler to be able
+    # to serve them.
+    #
+    # TODO: You can set a "preview URL" for Trix (see
+    # https://github.com/basecamp/trix#previewing-attached-files). But I
+    # couldn't get it to work.
+    def escape_for_trix(value)
+      value = value
+        .sub(""href":"/uploads", ""href":"#{root_url}uploads")
+        .sub(""url":"/uploads", ""url":"#{root_url}uploads")
+        .sub("href=\"/uploads", "href=\"#{root_url}uploads")
+        .sub("url=\"/uploads", "url=\"#{root_url}uploads")
+      CGI::escapeHTML(value)
+    end
+
     def flash
       @flash ||= Flash.new(session ? session[:flash] : {})
     end

data/lib/robin_cms/item.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
 module RobinCMS
-  class Item
-    attr_reader :id, :attributes, :schema
+  # The in-memory data model for all items.
+  #
+  # The Item objects model the domain, while the Library objects model disk
+  # IO/persistence. Since the distinction between Data and Collection items is
+  # purely a distinction of how they are written to disk, this is abstracted
+  # entirely by the Library objects and therefore Item's don't care what type
+  # they are.
+  #
+  # There are two boundaries for serialization/deserialization of items. One is
+  # to/from the file used to store the data on disk. This happens in the
+  # find_one, all, and write methods of the Library classes. The other is
+  # to/from the html representation of the item. This happens in the
+  # attributes= and field_value_or_default methods in this class.
+  class Item attr_reader :id, :attributes, :schema
 
     DATETIME_FORMAT = "%Y-%m-%d"
 
@@ -17,15 +29,49 @@ module RobinCMS
       @id = id
       @schema = schema
 
-      # Be sure to use the setter here so the keys get converted to symbols.
+      # Be sure to use the setter here.
       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"
+      # Parse array fields.
+      @schema[:fields].each do |f|
+        next unless f[:type] == "array"
+
+        field_id = f[:id].to_sym
+        if @attributes[field_id] && !@attributes[field_id].is_a?(Array)
+          @attributes[field_id] = @attributes[field_id].split(",").map(&:strip)
+        end
+      end
+
+      # Parse published status. The logic here is a bit weird, but basically an
+      # item without a 'published' key is considered published. Draft times are
+      # marked with 'published: false'. This is in line with how it works in
+      # Jekyll.
+      if blank?
+        @attributes[:published] = false # New items always default to draft.
+      elsif attributes.has_key?(:published)
+        @attributes[:published] = attributes[:published].to_s != "false"
+      else
+        @attributes[:published] = true
+      end
+    end
+
+    def field_value_or_default(field_id)
+      field = @schema[:fields].find { |f| f[:id] == field_id }
+      value = @attributes[field[:id].to_sym]
+
+      # Explicitly check for nil here because a field might have a value of
+      # false.
+      value = field[:default] if value.nil?
+
+      case field[:type]
+      when "array"
+        value&.join(",")
+      else
+        value.to_s
       end
     end
 
@@ -34,11 +80,11 @@ module RobinCMS
     end
 
     def published?
-      if @attributes.has_key?(:published)
-        @attributes[:published]
-      else
-        true
-      end
+      @attributes[:published]
+    end
+
+    def blank?
+      @id.nil?
     end
 
     def published_label
@@ -73,8 +119,8 @@ module RobinCMS
     def display_name
       return @attributes[:title] unless @schema[:display_name_pattern]
 
-      @schema[:display_name_pattern].clone.tap do |name|
-        @attributes.each { |key, value| name.gsub!(":#{key}", value) }
+      @schema[:display_name_pattern].dup.tap do |name|
+        @attributes.each { |key, value| name.gsub!(":#{key}", value.to_s) }
       end
     end
 
@@ -86,12 +132,17 @@ module RobinCMS
       @attributes[:image_alt]
     end
 
+    def can_delete?
+      @id && @schema[:can_delete]
+    end
+
     # Get the frontmatter as a hash with stringified keys.
-    def frontmatter
+    def frontmatter(ignore_published: false)
       frontmatter = @attributes.clone
       FRONTMATTER_IGNORE_KEYS.each { |key| frontmatter.delete(key) }
 
-      if published?
+      # See comment in the attributes= method.
+      if ignore_published || published?
         frontmatter.delete(:published)
       else
         frontmatter[:published] = false
@@ -103,15 +154,5 @@ module RobinCMS
       # to support earlier versions of Ruby.
       frontmatter.to_h.transform_keys(&:to_s)
     end
-
-    def field_value_or_default(field_id)
-      field = @schema[:fields].find { |f| f[:id] == field_id }
-      value = @attributes[field[:id].to_sym] || field[:default]
-      value.to_s
-    end
-
-    def can_delete?
-      @id && @schema[:can_delete]
-    end
   end
 end