yarii-editor 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34c51bc7203286b8032640275ff95921fc41049cc3ff8ca29ff84d5bff173991
+  data.tar.gz: 50a57ca81c3a912511d624d16cc9a22615894dde667e06aba40efc218b29f9ae
+SHA512:
+  metadata.gz: 06ada7816fdf2329e3b527bc88ad72172d8a1a447a46912831559478a612ecfaea44f840eea2ba684e3aaec22872b8d77b3312a7f01392d1230c65d8d7102dbd
+  data.tar.gz: be4c7f725ed23e589056ad1b32d33d724eda35adf6fbf94e3cbc6cb40d05bfc3d31bda37c4a3a4b9beecb3389bfbfb73c5433211ef833af1bb04087f958d3ad3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Whitefusion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Yarii Editor Engine
+
+Short description and motivation. Etc.
+
+## Usage
+
+How to use my plugin.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yarii-editor'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install yarii-editor
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Yariieditor'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/concerns/yarii_editor/controller_authorization.rb

@@ -0,0 +1,22 @@
+module YariiEditor
+  module ControllerAuthorization
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :check_if_yarii_is_authorized
+      
+      rescue_from YariiEditor::NotAuthorizedError, with: :handle_yarii_authorization_failure
+    end
+
+    def check_if_yarii_is_authorized
+      yarii_user = YariiEditor::CurrentUser.from_controller(self)
+      unless yarii_user&.can_access_yarii?
+        raise YariiEditor::NotAuthorizedError
+      end
+    end
+    
+    def handle_yarii_authorization_failure
+      render plain: "503 Not Authorized", status: 503
+    end
+  end
+end

data/app/controllers/concerns/yarii_editor/repository_pullable.rb

@@ -0,0 +1,11 @@
+module YariiEditor
+  module RepositoryPullable
+    extend ActiveSupport::Concern
+
+    def pull_if_needed
+      if current_site.repository.needs_pull?
+        current_site.repository.pull
+      end
+    end
+  end
+end

data/app/controllers/yarii_editor/application_controller.rb

@@ -0,0 +1,22 @@
+module YariiEditor
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    include YariiEditor::ControllerAuthorization
+    include YariiEditor::RepositoryPullable
+
+    before_action :set_content_model_base_path
+
+    def set_content_model_base_path
+      if session[:current_yarii_site]
+        CurrentSite.setup(Yarii::Site.find(session[:current_yarii_site]))
+      else
+        CurrentSite.setup
+      end
+    end
+
+    def current_site
+      CurrentSite.site
+    end
+    helper_method :current_site
+  end
+end

data/app/controllers/yarii_editor/dashboard_controller.rb

@@ -0,0 +1,17 @@
+module YariiEditor
+  class DashboardController < ApplicationController
+    before_action :pull_if_needed, except: [:list]
+
+    def index
+      @custom_lists = []
+    end
+
+    def list
+      model_details = current_site.content_models[params[:model_type]]
+
+      list = render_to_string(formats: [:html], partial: 'yarii_editor/dashboard/inner_list', locals: {model_type: params[:model_type], model_details: model_details})
+
+      render html: list
+    end
+  end
+end

data/app/controllers/yarii_editor/documents_controller.rb

@@ -0,0 +1,147 @@
+module YariiEditor
+  class DocumentsController < ApplicationController
+    before_action :pull_if_needed, only: [:create, :update, :destroy]
+
+    def new
+      @doc_heading = "New #{model_title}"
+      if params[:copy_from_template]
+        template_file_path = content_model.sanitize_filepath(File.join(current_site.git_repo_path, ".yarii", "templates", params[:copy_from_template]))
+        template_doc = content_model.new(file_path: template_file_path)
+        template_doc.load_file_from_path
+        @doc = template_doc.dup
+        @doc.file_path = nil
+      else
+        @doc = content_model.new
+      end
+      @doc.published = true # default to adding to public publishing
+      if @doc.respond_to? :setup_default_values
+        @doc.setup_default_values(self, params)
+      end
+      render 'modal', layout: nil
+    end
+
+    def create
+      @doc = content_model.new(secure_params)
+      @doc.date = DateTime.current.iso8601
+      if @doc.respond_to? :process_controller_params
+        # Allow the content model to massage incoming data, if necessary
+        @doc.process_controller_params(self, params)
+      end
+      @doc.save
+
+      render json: {status: 'ok', document_html: rendered_card}
+    end
+
+    def edit
+      @doc_heading = "Edit #{model_title}"
+      if params[:key_path]
+        @doc = content_model.find(params[:id], params[:key_path])
+      else
+        @doc = content_model.find(params[:id])
+      end
+      if @doc.respond_to?(:published) and @doc.published.nil?
+        @doc.published = true
+      end
+      if @doc.respond_to? :setup_default_values
+        @doc.setup_default_values(self, params)
+      end
+      render 'modal', layout: nil
+    end
+    
+    def update
+      if params[:key_path]
+        @doc = content_model.find(params[:id], params[:key_path])
+      else
+        @doc = content_model.find(params[:id])
+      end
+      @doc.assign_attributes(secure_params)
+      if @doc.respond_to? :process_controller_params
+        # Allow the content model to massage incoming data, if necessary
+        @doc.process_controller_params(self, params)
+      end
+      @doc.save
+
+      render json: {status: 'ok', document_html: rendered_card} 
+    end
+
+    def destroy
+      if params[:key_path]
+        @doc = content_model.find(params[:id], params[:key_path])
+      else
+        @doc = content_model.find(params[:id])
+      end
+      @doc.destroy
+
+      render json: {status: 'ok'}
+    end
+
+    protected
+    
+    def content_model
+      current_site.content_models[params[:content_model]][:class_name].constantize
+    end
+
+    def model_title
+      model_details = current_site.content_models[params[:content_model]]
+      model_title = model_details.fetch(:title, model_details[:class_name].titleize)
+    end
+
+    def rendered_card
+      render_to_string(formats: [:html], partial: 'yarii_editor/dashboard/card', locals: {model_class: content_model, model: @doc, content_model_type: params[:content_model]})
+    end
+
+    def secure_params
+      content_model_param = params[:content_model].to_sym
+      variable_names = content_model.variable_names + [:content]
+
+      variable_names = variable_names.map do |variable|
+        if params[content_model_param][variable.to_sym].is_a? Array
+          # scrub empty values
+          params[content_model_param][variable.to_sym] = params[content_model_param][variable.to_sym].select do |value|
+            value.present?
+          end
+          # permit the array variable
+          { variable => [] }
+        else
+          variable
+        end
+      end
+
+      detect_integer = ->(str) {
+        begin
+          !!Integer(str)
+        rescue ArgumentError, TypeError
+          false
+        end
+      }
+      variable_names.each do |variable|
+        value = variable.is_a?(Hash) ?
+          params[content_model_param][variable.keys.first.to_sym] :
+          params[content_model_param][variable.to_sym]
+
+        if value.is_a?(String)
+          if value.strip.blank?
+            # Scrub blank string values
+            params[content_model_param][variable.to_sym] = nil
+          elsif value.strip.match(/^false|true$/)
+            # Convert to real boolean values
+            params[content_model_param][variable.to_sym] = params[content_model_param][variable.to_sym].strip == 'true'
+          elsif detect_integer.call(value)
+            # Incoming strings that are simply numbers should be treated as such
+            params[content_model_param][variable.to_sym] = value.to_i 
+          end
+        end
+      end
+
+      # Markdown editor adds carriage returns for some reason. Take them out!
+      if params[content_model_param][:content]
+        params[content_model_param][:content] = params[content_model_param][:content].gsub(/\r/, '')
+      end
+      if params[content_model_param][:link_excerpt]
+        params[content_model_param][:link_excerpt] = params[content_model_param][:link_excerpt].gsub(/\r/, '')
+      end
+
+      params.require(content_model_param).permit(*variable_names)
+    end
+  end
+end

data/app/controllers/yarii_editor/publish_controller.rb

@@ -0,0 +1,24 @@
+module YariiEditor
+  class PublishController < ApplicationController
+    def remote_is_up_to_date
+      # NOTE: the Jekyll site config needs to include .well-known in the list of
+      # folders to build! Otherwise this won't work!
+      render json: {updated: current_site.remote_is_up_to_date?}
+    end
+
+    def menu
+      render partial: "yarii_editor/shared/publishing_menu", formats: [:html]
+    end
+
+    def commit
+      render layout: nil
+    end
+
+    def push_commit
+      current_site.commit!(message: params[:commit_message])
+      current_site.push
+
+      render json: {status: 'ok'}
+    end
+  end
+end

data/app/helpers/yarii_editor/application_helper.rb

@@ -0,0 +1,9 @@
+module YariiEditor
+  module ApplicationHelper
+    include ::Webpacker::Helper
+
+    def current_webpacker_instance
+      YariiEditor.webpacker
+    end
+  end
+end

data/app/helpers/yarii_editor/document_helper.rb

@@ -0,0 +1,15 @@
+module YariiEditor
+  module DocumentHelper
+    def status_of_document(document)
+      if document.will_be_published?
+        if CurrentSite.site.repository.git.diff('HEAD', '--cached').path(document.file_path).stats[:total][:files] == 1
+          :queued
+        else
+          :published
+        end
+      else
+        return :draft
+      end
+    end
+  end
+end

data/app/helpers/yarii_editor/editor_helper.rb

@@ -0,0 +1,19 @@
+module YariiEditor
+  module EditorHelper
+    def add_field(type, props)
+      render "yarii_editor/editor/#{type}", props
+    end
+
+    def name_from_variable(props)
+      model_name = params[:content_model]
+      "#{model_name}[#{props[:variable]}]" || "unknown#{(1..10000).to_a.sample}"
+    end
+
+    def value_from_variable(props)
+      variable = props[:variable]
+      if variable && @doc
+        @doc.send(variable)
+      end
+    end
+  end
+end

data/app/javascript/controllers/building_controller.js

@@ -0,0 +1,28 @@
+import { Controller } from "stimulus"
+import axios from "axios"
+import { axiosPostable } from "../lib/utils"
+
+export default class extends Controller {
+  initialize() {
+    this.axios = axiosPostable(axios)
+  }
+  
+  connect() {
+    this.checkingInterval = setInterval(this.checkBuildingStatus.bind(this), 5000)
+  }
+
+  async checkBuildingStatus() {
+    try {
+      let response = await this.axios.get(this.data.get('path'))
+      if (response.data.updated) {
+        this.element.classList.remove('is-warning')
+        this.element.classList.add('is-success')
+        this.element.innerHTML = 'Public Website Updated!'
+        clearInterval(this.checkingInterval)
+        setTimeout(() => { this.element.remove() }, 8000)
+      }
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}

data/app/javascript/controllers/card_controller.js

@@ -0,0 +1,49 @@
+import { Controller } from "stimulus"
+import axios from "axios"
+import { axiosPostable } from "../lib/utils"
+
+export default class extends Controller {
+  initialize() {
+    this.axios = axiosPostable(axios)
+  }
+
+  async edit(event) {
+    event.preventDefault()
+    const editPath = event.currentTarget.href
+
+    try {
+      const response = await this.axios.get(editPath, {headers: {'Accept': 'text/html'}})
+      document.querySelector('#editor-modal-wrapper').innerHTML = response.data
+      document.querySelector('#editor-modal input').focus()
+    } catch (error) {
+      console.log(error)
+    }
+  }
+
+  async destroy(event) {
+    event.preventDefault()
+    const deletePath = event.currentTarget.href
+    const cardId = this.element.id
+
+    if (confirm("Are you sure you wish to delete this item?")) {
+      this.element.classList.add('dimmed')
+      try {
+        await this.axios.delete(deletePath)
+        document.getElementById(cardId).remove()
+        this.refreshPublishingMenu()
+      } catch (error) {
+        console.log(error)
+      }
+    }
+  }
+
+  async refreshPublishingMenu() {
+    try {
+      let response = null
+      response = await this.axios.get(this.data.get('publishing-menu-path'))
+      document.getElementById('publishing-menu').innerHTML = response.data
+    } catch (error) {
+      console.log(error)
+    }
+  }
+}