vapid 0.1.0

data/lib/vapid/controllers/admin_controller.rb

@@ -0,0 +1,282 @@
+# rubocop:disable Metrics/BlockLength
+module Vapid
+  module Controllers
+    # Admin routes
+    module AdminController
+      extend Sinatra::Extension
+
+      # Custom form builder for records
+      class RecordFormBuilder < Padrino::Helpers::FormBuilder::AbstractFormBuilder
+        def vp_field(name, type, value = "")
+          @directive = Directives[type]
+          @name = name
+          @value = value
+
+          label(name) +
+            template.content_tag(:div) do
+              form_field + preview + destroy
+            end
+        end
+
+        private
+
+          def form_field
+            @directive.form_field(template, "record[content][#{@name}]", @value)
+          end
+
+          def preview
+            return unless @value.present? && @directive.previewable?
+
+            template.content_tag(:div, class: "preview") do
+              @directive.new(@name).render(@value)[:inner_html].html_safe
+            end
+          end
+
+          def destroy
+            return unless @value.present? && @directive.destroyable?
+
+            template.content_tag(:div, class: "ui checkbox destroy") do
+              template.check_box_tag("_destroy[#{@name}]") + "Delete #{@name}"
+            end
+          end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, MethodLength
+      def self.registered(app)
+        # rubocop:disable Lint/NestedMethodDefinition
+        app.helpers do
+          def installed!
+            if ActiveRecord::Migrator.current_version.zero? || !Models::User.any?
+              redirect "/admin/install" unless admin_action == "install"
+              false
+            else
+              redirect "/admin" if admin_action == "install"
+              true
+            end
+          end
+
+          def authenticated!
+            if !current_user
+              redirect "/admin/login" unless %w(login logout).include?(admin_action)
+              false
+            else
+              true
+            end
+          end
+
+          def admin_action
+            request.path_info.split("/")[2]
+          end
+
+          def render_admin_template(template)
+            render_view template, layout: :admin
+          end
+
+          def render_auth_template(template)
+            render_view template, layout: :admin_form
+          end
+
+          def admin_partial(template, options = {}, &block)
+            partial "admin/#{template}", options, &block
+          end
+
+          def record_form_for(name, *args, &block)
+            options = args.extract_options!
+            args << options.merge(builder: RecordFormBuilder)
+            form_for(name, *args, &block)
+          end
+
+          def group_or_records_path(group)
+            path = if group.records.empty?
+              "/new"
+            elsif group.repeating?
+              ""
+            else
+              "/#{group.records.first.id}/edit"
+            end
+
+            "/admin/groups/#{group.id}/records#{path}"
+          end
+
+          def flash_class(level)
+            case level
+            when :success then "ui positive message"
+            when :error then "ui negative message"
+            when :notice then "ui warning message"
+            end
+          end
+
+          def current_user
+            @current_user ||= Vapid::Models::User.find_by(id: session[:user_id])
+          end
+
+          def all_groups
+            Models::Group.with_fields
+          end
+
+          def current_group
+            Models::Group.find_by!(id: params[:group_id]) if params[:group_id]
+          end
+
+          def current_record
+            Models::Record.joins(:group).find_by(id: params[:id]) if params[:id]
+          end
+
+          def livereload
+            FileUtils.touch(settings.reload) if settings.development?
+          end
+
+          def run_builder
+            CLI.new.invoke(:build)
+          end
+        end
+        # rubocop:enable Lint/NestedMethodDefinition
+
+        app.before("/admin/?*") do
+          @groups = all_groups if installed! && authenticated!
+        end
+
+        app.namespace "/admin/?" do
+          # TODO: Namespace before filters are currently broken on Sinatra 2.0
+          # before do
+          #   @groups = all_groups if installed! && authenticated!
+          #   @group = current_group
+          #   @record = current_record
+          # end
+
+          get do
+            render_admin_template "admin/overview/index"
+          end
+
+          get "/login/?" do
+            @user = Models::User.new
+            render_auth_template "admin/login"
+          end
+
+          post "/login/?" do
+            user = Models::User.authenticate(params[:vapid_models_user][:email], params[:vapid_models_user][:password])
+
+            if user
+              session[:user_id] = user.id
+              redirect "/admin"
+            else
+              flash[:error] = "Could not log in"
+              redirect back
+            end
+          end
+
+          get "/logout/?" do
+            session.delete(:user_id)
+            flash[:success] = "Successfully logged out"
+            redirect "/admin/login"
+          end
+
+          get "/install/?" do
+            @code = Settings.install_code
+            render_auth_template "/admin/install"
+          end
+
+          post "/install/?" do
+            Models.migrate!
+
+            user = Models::User.new(email: params[:email], password: params[:password])
+            @code = Settings.install_code
+
+            # TODO: Should display contextually-relevant error message
+            if (@code.nil? || @code.casecmp(params[:code]) == 0) && user.save
+              run_builder
+              session[:user_id] = user.id
+              flash[:success] = "Successfully created admin account"
+              redirect "/admin"
+            else
+              flash.now[:error] = "Could not create admin account"
+              render_auth_template "/admin/install"
+            end
+          end
+
+          get "/build/?" do
+            run_builder
+            flash[:success] = "Site build complete"
+            redirect "/admin"
+          end
+
+          get "/groups/:group_id/records/?" do
+            @group = current_group
+            @user = Vapid::Models::User.new
+
+            render_admin_template "admin/records/index"
+          end
+
+          post "/groups/:group_id/records/?" do
+            @group = current_group
+            @record = @group.records.build(params[:record])
+
+            if @record.save
+              flash[:success] = "Record created"
+              livereload
+            else
+              flash[:error] = "Problem creating record"
+            end
+            redirect group_or_records_path(@group)
+          end
+
+          get "/groups/:group_id/records/new/?" do
+            @group = current_group
+            @record = @group.records.build
+
+            render_admin_template "admin/records/new"
+          end
+
+          post "/groups/:group_id/records/:id/?" do
+            @group = current_group
+            @record = current_record
+
+            params[:record]["content"].each do |key, val|
+              if val.is_a?(Hash) && val[:tempfile]
+                FileUtils.mkdir_p(settings.project_uploads)
+                File.open File.join(settings.project_uploads, val[:filename]), "wb" do |file|
+                  file.write val[:tempfile].read
+                end
+                val = "/uploads/#{val[:filename]}"
+              end
+              @record.content[key] = val
+            end
+
+            params[:_destroy] && params[:_destroy].each do |key, _val|
+              @record.content[key] = nil
+            end
+
+            if @record.save
+              flash[:success] = "Record updated"
+              livereload
+            else
+              flash.now[:error] = "Problem updating record"
+            end
+            redirect group_or_records_path(@group)
+          end
+
+          delete "/groups/:group_id/records/:id/?" do
+            @group = current_group
+            @record = current_record
+
+            if @record.destroy
+              flash[:success] = "Record deleted"
+              livereload
+            else
+              flash[:error] = "Problem deleting record"
+            end
+            redirect group_or_records_path(@group)
+          end
+
+          get "/groups/:group_id/records/:id/edit/?" do
+            @group = current_group
+            @record = current_record
+
+            render_admin_template "admin/records/edit"
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, MethodLength
+    end
+  end
+end

data/lib/vapid/controllers/project_controller.rb

@@ -0,0 +1,41 @@
+module Vapid
+  module Controllers
+    # Project routes
+    module ProjectController
+      extend Sinatra::Extension
+
+      # rubocop:disable Metrics/AbcSize, MethodLength
+      def self.registered(app)
+        app.configure do
+          app.set :layouts, File.join(app.settings.project_views, "layouts")
+        end
+
+        # rubocop:disable Lint/NestedMethodDefinition
+        app.helpers do
+          def dynamic_layout(path)
+            path_layout = path.split("/")[1]
+            if path_layout && Dir.glob(File.join(settings.layouts, "#{path_layout}.*")).any?
+              "layouts/#{path_layout}"
+            else
+              :default
+            end
+          end
+
+          def render_or_index(path)
+            render path, views: settings.project_views, layout: dynamic_layout(path)
+          rescue
+            render "#{path.chomp('/')}/index", views: settings.project_views, layout: dynamic_layout(path)
+          end
+        end
+        # rubocop:enable Lint/NestedMethodDefinition
+
+        app.get "*" do
+          path = params[:splat].first.to_s
+          html = render_or_index(path)
+          Template.new(html).render
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, MethodLength
+    end
+  end
+end

data/lib/vapid/db/migrate/20170202182310_create_groups.rb

@@ -0,0 +1,12 @@
+# Create groups table
+class CreateGroups < ActiveRecord::Migration[5.0]
+  def change
+    create_table :groups do |t|
+      t.string :name
+      t.string :fields, default: "{}"
+      t.boolean :repeating, default: false
+
+      t.timestamps
+    end
+  end
+end

data/lib/vapid/db/migrate/20170202183017_create_records.rb

@@ -0,0 +1,11 @@
+# Create records table
+class CreateRecords < ActiveRecord::Migration[5.0]
+  def change
+    create_table :records do |t|
+      t.string :content, default: "{}"
+      t.references :group, foreign_key: true
+
+      t.timestamps
+    end
+  end
+end

data/lib/vapid/db/migrate/20170202185150_create_users.rb

@@ -0,0 +1,11 @@
+# Create users table
+class CreateUsers < ActiveRecord::Migration[5.0]
+  def change
+    create_table :users do |t|
+      t.string :email
+      t.string :password_digest
+
+      t.timestamps
+    end
+  end
+end

data/lib/vapid/directive.rb

@@ -0,0 +1,168 @@
+require "loofah"
+require "oembed"
+
+# TODO: Not sure we need this just for the convenience of content_tag, etc.
+require "sinatra"
+require "padrino-helpers"
+
+module Vapid
+  # Base class for directives
+  class Directive
+    include Padrino::Helpers::TagHelpers
+
+    attr_reader :subject
+
+    # Allow iframe in sanitizer
+    # @todo Let individual directives request tags/attributes
+    Loofah::HTML5::WhiteList::ALLOWED_ELEMENTS_WITH_LIBXML2.merge %w(iframe)
+    Loofah::HTML5::WhiteList::ALLOWED_ATTRIBUTES.merge %w(frameborder scrolling allowfullscreen)
+
+    class << self
+      # Whether the directive writes content to the database.
+      #
+      # @return [Boolean]
+      def modifies_content?
+        respond_to?(:form_field)
+      end
+
+      # Whether the directive previews the content.
+      #
+      # @return [Boolean]
+      def previewable?
+        preview
+      end
+
+      # Whether the directive can be destroyed (usually via a checkbox).
+      #
+      # @return [Boolean]
+      def destroyable?
+        destroy
+      end
+
+      private
+
+        attr_accessor :filters, :preview, :destroy
+
+        def renders(content_type, &block)
+          define_input_modifier "render_#{content_type}", &block
+        end
+
+        def form(preview: false, destroy: false, &block)
+          self.preview = preview
+          self.destroy = destroy
+
+          (class << self; self; end).instance_eval do
+            define_method :form_field do |template, name, value|
+              template.instance_exec name, value, &block
+            end
+          end
+        end
+
+        def filter(name, &block)
+          @filters ||= {}
+          @filters[name] = block
+        end
+
+        def before_render(&block)
+          define_input_modifier :callback_before_render, &block
+        end
+
+        def inherited(subclass)
+          # Auto-register directives
+          # @todo Shouldn't do this
+          Vapid.register_directive subclass.name.split("::").last.downcase, subclass
+        end
+
+        def define_input_modifier(name, &block)
+          define_method name do
+            if block_given?
+              instance_exec @input, &block
+            else
+              @input
+            end
+          end
+          private name
+        end
+    end
+
+    def initialize(expression)
+      parse_expression(expression)
+    end
+
+    # Renders content
+    # @param input [String]
+    # @return [Object] a Nokogiri-friendly hash of modifiers,
+    #   or the original input value
+    def render(input = nil)
+      @input = input
+
+      run_before_callback
+      apply_filters
+
+      render_all
+    end
+
+    private
+
+      # rubocop:disable Style/EmptyLineBetweenDefs
+      def render_text; end
+      def render_html; end
+      def render_styles; end
+      def render_attributes; end
+      # rubocop:enable Style/EmptyLineBetweenDefs
+
+      def render_all
+        {
+          content:      render_text,
+          inner_html:   sanitize(render_html),
+          styles:       render_styles,
+          attributes:   render_attributes,
+          placeholder:  placeholder?
+        }.reject { |_k, v| v.blank? }
+      end
+
+      def run_before_callback
+        return unless respond_to?(:callback_before_render, true)
+        @input = callback_before_render
+      end
+
+      def apply_filters
+        @input = @args.reduce(@input) do |input, (name, args)|
+          begin
+            filter = self.class.send(:filters)[name.to_sym]
+            instance_exec input, *args, &filter
+          rescue
+            input
+          end
+        end
+      end
+
+      def parse_expression(expression)
+        parts = expression.split("|")
+        @subject = parts.shift
+        @args = parts.map do |arg|
+          arg_args = arg.split(":", 2).map { |a| clean_arg(a) }
+          arg_name = arg_args.shift
+          [arg_name, arg_args]
+        end
+      end
+
+      def clean_arg(arg)
+        quoted = %w('' "").include? "#{arg[0]}#{arg[-1]}"
+        quoted ? arg[1..-2] : arg
+      end
+
+      def sanitize(input)
+        return if input.blank?
+        Loofah.fragment(input).scrub!(:strip).to_s
+      end
+
+      def placeholder?
+        @input.blank? && self.class.modifies_content?
+      end
+
+      def block_is_template?(_block)
+        false
+      end
+  end
+end