bunto-admin 0.6.0

data/lib/bunto-admin/file_helper.rb

@@ -0,0 +1,66 @@
+module BuntoAdmin
+  module FileHelper
+
+    # The file the user requested in the URL
+    def requested_file
+      find_by_path(path)
+    end
+
+    # The file ultimately written to disk
+    # This may be the requested file, or in the case of a rename will be read
+    # from the new path that was actually written to disk
+    def written_file
+      find_by_path(write_path)
+    end
+
+    # Write a file to disk with the given content
+    def write_file(path, content)
+      Bunto.logger.debug "WRITING:", path
+      path = sanitized_path(path)
+      FileUtils.mkdir_p File.dirname(path)
+      File.open(path, "wb") do |file|
+        file.write(content)
+      end
+      site.process
+    end
+
+    # Delete the file at the given path
+    def delete_file(path)
+      Bunto.logger.debug "DELETING:", path
+      FileUtils.rm_f sanitized_path(path)
+      site.process
+    end
+
+    private
+
+    def ensure_requested_file
+      ensure_file(requested_file)
+    end
+
+    def ensure_written_file
+      ensure_file(written_file)
+    end
+
+    def find_by_path(path)
+      files = case namespace
+              when "collections"
+                collection.docs
+              when "data"
+                DataFile.all
+              when "pages", "static_files"
+                site.public_send(namespace.to_sym)
+              else
+                []
+              end
+      files.find { |f| sanitized_path(f.path) == path }
+    end
+
+    def ensure_file(file)
+      render_404 if file.nil?
+    end
+
+    def ensure_directory
+      render_404 unless Dir.exist?(directory_path)
+    end
+  end
+end

data/lib/bunto-admin/page_without_a_file.rb

@@ -0,0 +1,7 @@
+module BuntoAdmin
+  class PageWithoutAFile < Bunto::Page
+    def read_yaml(*)
+      @data ||= {}
+    end
+  end
+end

data/lib/bunto-admin/path_helper.rb

@@ -0,0 +1,74 @@
+module BuntoAdmin
+  module PathHelper
+    def sanitized_path(path)
+      path = path_without_site_source(path)
+      Bunto.sanitized_path BuntoAdmin.site.source, path
+    end
+
+    # Returns the basename + extension for the requested file
+    def filename
+      params["ext"] ||= "yml" if namespace == "data"
+      "#{params["path"]}.#{params["ext"]}"
+    end
+
+    # Returns the sanitized path relative to the site source
+    def sanitized_relative_path(path)
+      path_without_site_source sanitized_path(path)
+    end
+
+    # Returns the sanitized absolute path to the requested object
+    def absolute_path
+      sanitized_path File.join(directory_path, filename)
+    end
+    alias_method :path, :absolute_path
+
+    # Returns the sanitized relative path to the requested object
+    def relative_path
+      sanitized_relative_path absolute_path
+    end
+
+    # Returns the sanitized absolute path to write the requested object
+    def write_path
+      if renamed?
+        sanitized_path request_payload["path"]
+      else
+        path
+      end
+    end
+    alias_method :request_path, :write_path
+
+    # Returns the sanitized relative path to write the requested object
+    def relative_write_path
+      sanitized_relative_path write_path
+    end
+
+    # Is this request renaming a file?
+    def renamed?
+      return false unless request_payload["path"]
+      ensure_leading_slash(request_payload["path"]) != relative_path
+    end
+
+    private
+
+    # Returns the path to the requested file's containing directory
+    def directory_path
+      case namespace
+      when "collections"
+        sanitized_path File.join(collection.relative_directory, params["splat"].first)
+      when "data"
+        sanitized_path File.join(DataFile.data_dir, params["splat"].first)
+      else
+        sanitized_path params["splat"].first
+      end
+    end
+
+    def ensure_leading_slash(input)
+      return input if input.nil? || input.empty? || input.start_with?("/")
+      "/#{input}"
+    end
+
+    def path_without_site_source(path)
+      path.to_s.gsub(%r!\A#{Regexp.escape(BuntoAdmin.site.source)}!, "")
+    end
+  end
+end

data/lib/bunto-admin/server.rb

@@ -0,0 +1,100 @@
+module BuntoAdmin
+  class Server < Sinatra::Base
+    ROUTES = %w(collections configuration data pages static_files).freeze
+    include BuntoAdmin::PathHelper
+    include BuntoAdmin::FileHelper
+
+    register Sinatra::Namespace
+
+    configure :development do
+      register Sinatra::Reloader
+      enable :logging
+    end
+
+    configure :development, :test do
+      require "sinatra/cross_origin"
+      register Sinatra::CrossOrigin
+      enable  :cross_origin
+      disable :allow_credentials
+      set :allow_methods, %i[delete get options post put]
+    end
+
+    get "/" do
+      json ROUTES.map { |r| ["#{r}_api", URI.join(base_url, "/_api/", r)] }.to_h
+    end
+
+    # CORS preflight
+    options "*" do
+      render_404 unless settings.development? || settings.test?
+      status 204
+    end
+
+    private
+
+    def site
+      BuntoAdmin.site
+    end
+
+    def render_404
+      status 404
+      content_type :json
+      halt
+    end
+
+    def request_payload
+      @request_payload ||= if request_body.to_s.empty?
+                             {}
+                           else
+                             JSON.parse(request_body)
+                           end
+    end
+
+    def base_url
+      "#{request.scheme}://#{request.host_with_port}"
+    end
+
+    def front_matter
+      request_payload["front_matter"]
+    end
+
+    def document_body
+      body = if front_matter && !front_matter.empty?
+               YAML.dump(restored_front_matter).strip
+                 .gsub(": 'null'", ": null") # restore null values
+             else
+               "---"
+             end
+      body << "\n---\n\n"
+      body << request_payload["raw_content"].to_s
+    end
+    alias page_body document_body
+
+    private
+
+    def request_body
+      @request_body ||= begin
+        request.body.rewind
+        request.body.read
+      end
+    end
+
+    def namespace
+      namespace = request.path_info.split("/")[1].to_s.downcase
+      namespace if ROUTES.include?(namespace)
+    end
+
+    # verbose 'null' values in front matter
+    def restored_front_matter
+      front_matter.map do |key, value|
+        value = "null" if value.nil?
+        [key, value]
+      end.to_h
+    end
+  end
+end
+
+require "bunto-admin/server/collection"
+require "bunto-admin/server/configuration"
+require "bunto-admin/server/data"
+require "bunto-admin/server/page"
+require "bunto-admin/server/static_file"

data/lib/bunto-admin/server/collection.rb

@@ -0,0 +1,82 @@
+module BuntoAdmin
+  class Server < Sinatra::Base
+    namespace "/collections" do
+      get do
+        json(site.collections.map { |c| c[1].to_api })
+      end
+
+      get "/:collection_id" do
+        ensure_collection
+        json collection.to_api
+      end
+
+      get "/:collection_id/*?/?:path.:ext" do
+        ensure_requested_file
+        json requested_file.to_api(:include_content => true)
+      end
+
+      get "/:collection_id/entries/?*" do
+        ensure_directory
+        json entries.map(&:to_api)
+      end
+
+      put "/:collection_id/*?/?:path.:ext" do
+        ensure_collection
+
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, document_body
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/:collection_id/*?/?:path.:ext" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def collection
+        collection = site.collections.find { |l, _c| l == params["collection_id"] }
+        collection[1] if collection
+      end
+
+      def document_id
+        path = "#{params["splat"].first}/#{filename}"
+        path.gsub(%r!(\d{4})/(\d{2})/(\d{2})/(.*)!, '\1-\2-\3-\4')
+      end
+
+      def directory_docs
+        collection.docs.find_all { |d| File.dirname(d.path) == directory_path }
+      end
+
+      def ensure_collection
+        render_404 if collection.nil?
+      end
+
+      def ensure_directory
+        ensure_collection
+        render_404 unless Dir.exist?(directory_path)
+      end
+
+      def entries
+        args = {
+          :base         => site.source,
+          :content_type => params["collection_id"],
+          :splat        => params["splat"].first,
+        }
+        # get the directories inside the requested directory
+        directory = BuntoAdmin::Directory.new(directory_path, args)
+        directories = directory.directories
+        # merge directories with the documents at the same level
+        directories.concat(directory_docs.sort_by(&:date).reverse)
+      end
+    end
+  end
+end

data/lib/bunto-admin/server/configuration.rb

@@ -0,0 +1,57 @@
+module BuntoAdmin
+  class Server < Sinatra::Base
+    namespace "/configuration" do
+      get do
+        json({
+          :content     => parsed_configuration,
+          :raw_content => raw_configuration,
+        })
+      end
+
+      put do
+        write_file(configuration_path, configuration_body)
+        json request_payload
+      end
+
+      private
+
+      def overrides
+        {
+          "source" => sanitized_path("/"),
+        }
+      end
+
+      # Computed configuration, with updates and defaults
+      def configuration
+        @configuration ||= Bunto.configuration(overrides)
+      end
+
+      # Configuration data, as read by Bunto
+      def parsed_configuration
+        configuration.read_config_file(configuration_path)
+      end
+
+      # Raw configuration content, as it sits on disk
+      def raw_configuration
+        File.read(
+          configuration_path,
+          Bunto::Utils.merged_file_read_opts(site, {})
+        )
+      end
+
+      # Returns the path to the *first* config file discovered
+      def configuration_path
+        sanitized_path configuration.config_files(overrides).first
+      end
+
+      # The user's uploaded configuration for updates
+      # Instead of extracting `raw_content` directly from the `request_payload`,
+      #   assign the data to a new variable and then extract the `raw_content`
+      #   from it to circumvent CORS violation in `development` mode.
+      def configuration_body
+        payload = request_payload
+        payload["raw_content"]
+      end
+    end
+  end
+end

data/lib/bunto-admin/server/data.rb

@@ -0,0 +1,82 @@
+module BuntoAdmin
+  class Server < Sinatra::Base
+    # supported extensions, in order of preference, for now, no .csv
+    EXTENSIONS = %w(yml json).freeze
+
+    namespace "/data" do
+      get "/*?/?:path.:ext" do
+        ensure_requested_file
+        json requested_file.to_api(:include_content => true)
+      end
+
+      get "/?*" do
+        ensure_directory
+        json entries.map(&:to_api)
+      end
+
+      put "/*?/?:path.:ext" do
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, data_file_body
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/*?/?:path.:ext" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      # returns relative path of root level directories that contain data files
+      def directory_paths
+        DataFile.all.map { |p| File.dirname(p.relative_path).split("/")[0] }.uniq
+      end
+
+      def directory_pages
+        DataFile.all.find_all do |p|
+          sanitized_path(File.dirname(p.path)) == directory_path
+        end
+      end
+
+      def entries
+        args = {
+          :base         => sanitized_path(DataFile.data_dir),
+          :content_type => "data",
+          :splat        => splats.first,
+        }
+        # get all directories inside the requested directory
+        directory = BuntoAdmin::Directory.new(directory_path, args)
+        directories = directory.directories
+
+        # exclude root level directories which do not have data files
+        if splats.first.empty?
+          directories = directories.select do |d|
+            directory_paths.include? d.name.to_s
+          end
+        end
+
+        # merge directories with the pages at the same level
+        directories.concat(directory_pages)
+      end
+
+      def data_file_body
+        if !request_payload["raw_content"].to_s.empty?
+          request_payload["raw_content"]
+        elsif !request_payload["content"].to_s.empty?
+          YAML.dump(request_payload["content"]).sub(%r!\A---\n!, "")
+        end
+      end
+
+      def splats
+        params["splat"] || ["/"]
+      end
+    end
+  end
+end