inner_plan 0.1.0

data/app/components/inner_plan/tasks/show_menu_component.rb

@@ -0,0 +1,30 @@
+module InnerPlan::Tasks
+  class ShowMenuComponent < Phlex::HTML
+    include Phlex::Rails::Helpers::LinkTo
+
+    def initialize(task)
+      @task = task
+    end
+
+    def template
+      div(class: "dropdown") {
+        button(class: "btn btn-link text-reset p-0 opacity-50", data_bs_toggle: "dropdown") {
+          render(Phlex::Icons::Tabler::DotsCircleHorizontal.new(width: 35, height: 35))
+        }
+
+        ul(class: "dropdown-menu dropdown-menu-end") {
+          li {
+            link_to(helpers.edit_task_path(@task), class: 'dropdown-item d-flex align-items-center gap-2', data: { turbo_frame: :_top }) {
+              render(Phlex::Icons::Tabler::Pencil.new(width: 18, height: 18, class: 'text-secondary'))
+              span { "Edit task" }
+            }
+          }
+        }
+      }
+    end
+
+    private
+
+    attr_reader :task
+  end
+end

data/app/components/inner_plan/tasks/show_view.rb

@@ -0,0 +1,76 @@
+module InnerPlan::Tasks
+  class ShowView < ApplicationView
+    include Phlex::Rails::Helpers::ClassNames
+    include Phlex::Rails::Helpers::LinkTo
+    include Phlex::Rails::Helpers::Routes
+
+    attr_reader :task
+
+    def initialize(task:)
+      @task = task
+    end
+
+    def template
+      header(class: "mb-3") do
+        render(InnerPlan::BreadcrumbsComponent.new) do |c|
+          c.with_breadcrumb do
+            link_to "Home", helpers.root_path, class: "text-reset", data: { turbo_frame: :_top }
+          end
+
+          if @task.list.list.present?
+            c.with_breadcrumb do
+              link_to @task.list.list.title, @task.list.list, class: "text-reset"
+            end
+            c.with_breadcrumb do
+              link_to @task.list.title, helpers.group_path(@task.list), class: "text-reset"
+            end
+          else
+            c.with_breadcrumb do
+              link_to @task.list.title, @task.list, class: "text-reset"
+            end
+          end
+
+          c.with_breadcrumb(active: true) { "Task ##{@task.id}" }
+        end
+      end
+
+      div(class: "d-flex mb-2") do
+        div(class: "text-end me-2") do
+          div(style: "display:block;margin-top:-0.25rem;margin-left:-0.8rem") do
+            render(
+              InnerPlan::Tasks::CompletedTogglerComponent.new(
+                @task,
+                context: :tasks_show,
+                size: 39
+              )
+            )
+          end
+        end
+        div(class: "w-100") do
+          h1(class: "h3") do
+            link_to @task.title,
+                    helpers.edit_task_path(@task, focus: :title),
+                    class: "text-reset text-decoration-none"
+          end
+        end
+        div(class: "text-end") do
+          render(InnerPlan::Tasks::ShowMenuComponent.new(@task))
+        end
+      end
+
+      InnerPlan.configuration.task_show_view_rows.each do |row|
+        render InnerPlan::Tasks::Form::RowComponent.new do |component|
+          row.content.each do |item|
+            component.with_column(span: item.options[:span]) do
+              render(item.content.call(context: self))
+            end
+          end
+        end
+      end
+    end
+
+    def description
+      InnerPlan::Tasks::DescriptionRenderer.call(task: @task)[:description]
+    end
+  end
+end

data/app/components/inner_plan/user_with_avatar_component.rb

@@ -0,0 +1,17 @@
+module InnerPlan
+  class UserWithAvatarComponent < Phlex::HTML
+    include Phlex::Rails::Helpers::ImageTag
+
+    def initialize(user, avatar_size: 20)
+      @user = user
+      @avatar_size = avatar_size
+    end
+
+    def template
+      image_tag(@user.inner_plan_avatar_url, size: @avatar_size,
+                                             class: 'rounded-circle me-1',
+                                             style: 'margin-top:-0.1rem')
+      plain @user.inner_plan_to_s
+    end
+  end
+end

data/app/concepts/inner_plan/list/operation/index.rb

@@ -0,0 +1,11 @@
+module InnerPlan::List::Operation
+  class Index < Trailblazer::Operation
+    step :find_models
+
+    private
+
+    def find_models(ctx, **)
+      ctx[:models] = InnerPlan::List.ordered_by_position.root
+    end
+  end
+end

data/app/concepts/inner_plan/task/operation/complete.rb

@@ -0,0 +1,12 @@
+module InnerPlan::Task::Operation
+  class Complete < Trailblazer::Operation
+    step Model::Find(InnerPlan::Task, find_by: :id)
+    step :mark_as_complete
+
+    private
+
+    def mark_as_complete(ctx, model:, **)
+      model.complete!
+    end
+  end
+end

data/app/concepts/inner_plan/task/operation/create.rb

@@ -0,0 +1,46 @@
+module InnerPlan::Task::Operation
+  class Create < Trailblazer::Operation
+    step :find_list
+    step :initialize_model
+    step :assign_list
+    step :assign_user
+    step :assign_position
+    left :validate_model
+    step :save_model
+
+    private
+
+    def find_list(ctx, list_id:, **)
+      ctx[:list] = InnerPlan::List.find(list_id)
+    end
+
+    def initialize_model(ctx, params:, **)
+      model = InnerPlan::Task.new
+      model.title = params[:title]
+      model.description = params[:description]
+      model.due_on = params[:due_on]
+
+      ctx[:model] = model
+    end
+
+    def assign_list(ctx, list:, model:, **)
+      model.list = list
+    end
+
+    def assign_position(ctx, model:, **)
+      model.position = :last
+    end
+
+    def assign_user(ctx, current_user:, model:, **)
+      model.user = current_user
+    end
+
+    def validate_model(ctx, model:, **)
+      model.validate
+    end
+
+    def save_model(_ctx, model:, **)
+      model.save
+    end
+  end
+end

data/app/concepts/inner_plan/task/operation/reopen.rb

@@ -0,0 +1,12 @@
+module InnerPlan::Task::Operation
+  class Reopen < Trailblazer::Operation
+    step Model::Find(InnerPlan::Task, find_by: :id)
+    step :reopen
+
+    private
+
+    def reopen(ctx, model:, **)
+      model.reopen!
+    end
+  end
+end

data/app/concepts/inner_plan/task/operation/update.rb

@@ -0,0 +1,25 @@
+module InnerPlan::Task::Operation
+  class Update < Trailblazer::Operation
+    step Model::Find(InnerPlan::Task, find_by: :id)
+    step :assign_attributes
+    left :validate_model
+    step :update_model
+
+    private
+
+    def assign_attributes(ctx, model:, params:, **)
+      model.title = params[:title]
+      model.description = params[:description]
+      model.due_on = params[:due_on]
+      true
+    end
+
+    def validate_model(ctx, model:, **)
+      model.validate
+    end
+
+    def update_model(ctx, model:, **)
+      model.save
+    end
+  end
+end

data/app/concepts/inner_plan/task/operation/update_position.rb

@@ -0,0 +1,25 @@
+module InnerPlan::Task::Operation
+  class UpdatePosition < Trailblazer::Operation
+    step Model::Find(InnerPlan::Task, find_by: :id)
+    step :assign_position
+    step :assign_list
+    step :save
+
+    private
+
+    def assign_position(ctx, params:, model:, **)
+      model.position = { before: params.dig(:task, :position, :before) }
+    end
+
+    def assign_list(ctx, params:, model:, **)
+      list_id = params.dig(:task, :list_id)
+      return true unless list_id
+
+      model.list = InnerPlan::List.find(list_id)
+    end
+
+    def save(ctx, model:, **)
+      model.save
+    end
+  end
+end

data/app/controllers/inner_plan/application_controller.rb

@@ -0,0 +1,12 @@
+module InnerPlan
+  class ApplicationController < ActionController::Base
+    helper_method :current_inner_plan_user
+
+    private
+
+    def current_inner_plan_user
+      @current_inner_plan_user ||=
+        public_send(InnerPlan.configuration.current_user_method)
+    end
+  end
+end

data/app/controllers/inner_plan/groups_controller.rb

@@ -0,0 +1,59 @@
+module InnerPlan
+  class GroupsController < ApplicationController
+    def show
+      @group = InnerPlan::List.sub.find(params[:id])
+      render InnerPlan::Groups::ShowView.new(group: @group)
+    end
+
+    def edit
+      @group = InnerPlan::List.sub.find(params[:id])
+      render InnerPlan::Groups::EditView.new(group: @group)
+    end
+
+    def update
+      @group = InnerPlan::List.sub.find(params[:id])
+
+      if @group.update(group_params)
+        redirect_to group_path(@group)
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def new
+      @list = InnerPlan::List.root.find(params[:list_id])
+      @group = @list.lists.new(params[:id])
+      render InnerPlan::Groups::NewView.new(group: @group)
+    end
+
+    def create
+      @group = InnerPlan::List.new(group_params)
+      @group.list = InnerPlan::List.root.find(params[:list_id])
+      @group.user = current_inner_plan_user
+      @group.position = :last
+
+      if @group.save
+        redirect_to @group.list
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update_position
+      @group = InnerPlan::List.sub.find(params[:id])
+      @group.position = { before: update_positions_params[:position][:before] }
+      @group.list = InnerPlan::List.root.find(update_positions_params[:list_id]) if update_positions_params[:list_id]
+      @group.save!
+    end
+
+    private
+
+    def group_params
+      params.require(:list).permit(:title, :description)
+    end
+
+    def update_positions_params
+      params.require(:list).permit(:list_id, :position, position: :before)
+    end
+  end
+end

data/app/controllers/inner_plan/lists_controller.rb

@@ -0,0 +1,59 @@
+module InnerPlan
+  class ListsController < ApplicationController
+    def index
+      @lists = InnerPlan::List::Operation::Index.call[:models]
+      render InnerPlan::Lists::IndexView.new(lists: @lists)
+    end
+
+    def show
+      @list = InnerPlan::List.root.find(params[:id])
+      render InnerPlan::Lists::ShowView.new(list: @list)
+    end
+
+    def new
+      @list = InnerPlan::List.new
+      render InnerPlan::Lists::NewView.new(list: @list)
+    end
+
+    def create
+      @list = InnerPlan::List.new(list_params)
+      @list.user = current_inner_plan_user
+
+      if @list.save
+        redirect_to lists_path
+      else
+        render InnerPlan::Lists::NewView.new(list: @list), status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      @list = InnerPlan::List.root.find(params[:id])
+      render InnerPlan::Lists::EditView.new(list: @list)
+    end
+
+    def update
+      @list = InnerPlan::List.root.find(params[:id])
+      if @list.update(list_params)
+        redirect_to list_path(@list)
+      else
+        render InnerPlan::Lists::EditView.new(list: @list)
+      end
+    end
+
+    def update_position
+      @list = InnerPlan::List.root.find(params[:id])
+      @list.position = { before: update_positions_params[:position][:before] }
+      @list.save!
+    end
+
+    private
+
+    def list_params
+      params.require(:list).permit(:title, :description)
+    end
+
+    def update_positions_params
+      params.require(:list).permit(:position, position: :before)
+    end
+  end
+end

data/app/controllers/inner_plan/tasks_controller.rb

@@ -0,0 +1,73 @@
+module InnerPlan
+  class TasksController < ApplicationController
+    def index
+      @lists = InnerPlan::List::Operation::Index.call
+    end
+
+    def new
+      @task = InnerPlan::Task.new
+      @list = InnerPlan::List.find(params[:list_id])
+    end
+
+    def show
+      @task = InnerPlan::Task.find(params[:id])
+      render InnerPlan::Tasks::ShowView.new(task: @task)
+    end
+
+    def create
+      result = InnerPlan::Task::Operation::Create.call(
+        list_id: params[:list_id],
+        current_user: current_inner_plan_user,
+        params: params.fetch(:task, {})
+      )
+      @task, @list = result[:model], result[:list]
+
+      if result.success?
+        @new_task = InnerPlan::Task.new
+      else
+        render :create_failure, status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      @task = InnerPlan::Task.find(params[:id])
+      render InnerPlan::Tasks::EditView.new(task: @task, focus: params[:focus])
+    end
+
+    def update
+      result = InnerPlan::Task::Operation::Update.call(
+        params: params.fetch(:task, {}).merge(id: params[:id])
+      )
+      @task = result[:model]
+
+      if result.success?
+        redirect_to task_path(@task)
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def update_position
+      result = InnerPlan::Task::Operation::UpdatePosition.call(params: params)
+      @task = result[:model]
+    end
+
+    def complete
+      result = InnerPlan::Task::Operation::Complete.call(params: params)
+      @task = result[:model]
+
+      respond_to do |format|
+        format.turbo_stream
+      end
+    end
+
+    def reopen
+      result = InnerPlan::Task::Operation::Reopen.call(params: params)
+      @task = result[:model]
+
+      respond_to do |format|
+        format.turbo_stream { render :complete }
+      end
+    end
+  end
+end

data/app/helpers/inner_plan/application_helper.rb

@@ -0,0 +1,4 @@
+module InnerPlan
+  module ApplicationHelper
+  end
+end

data/app/javascript/inner_plan/application.js

@@ -0,0 +1,15 @@
+import { Application } from "@hotwired/stimulus"
+import * as bootstrap from 'bootstrap'
+
+import ListsController from "controllers/lists_controller"
+import GroupsController from "controllers/groups_controller"
+import TasksController from "controllers/tasks_controller"
+import TaskInlineFormController from "controllers/task_inline_form_controller"
+
+// Stimulus
+window.Stimulus = Application.start()
+
+Stimulus.register("lists", ListsController)
+Stimulus.register("groups", GroupsController)
+Stimulus.register("tasks", TasksController)
+Stimulus.register("task-inline-form", TaskInlineFormController)

data/app/javascript/inner_plan/controllers/groups_controller.js

@@ -0,0 +1,47 @@
+import { Controller } from "@hotwired/stimulus";
+import Sortable from "sortablejs"
+import { patch } from "@rails/request.js"
+
+export default class extends Controller {
+  static values = {
+    listId: Number
+  };
+
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      handle: '.group-handle',
+      group: 'group',
+      onUpdate: this.onUpdate.bind(this),
+      onAdd: this.onAdd.bind(this),
+    })
+  }
+
+  destroy() {
+    this.sortable.destroy();
+  }
+
+  onAdd({ item }) {
+    const nextGroupEl = item.nextElementSibling;
+    const nextGroupId = nextGroupEl ? nextGroupEl.dataset.id : null
+
+    patch(item.dataset.updateUrl, {
+      body: {
+        list: {
+          list_id: this.listIdValue,
+          position: { before: nextGroupId }
+        }
+      }
+    })
+  }
+
+  onUpdate({ item }) {
+    const nextGroupEl = item.nextElementSibling;
+    const nextGroupId = nextGroupEl ? nextGroupEl.dataset.id : null
+
+    patch(item.dataset.updateUrl, {
+      body: {
+        list: { position: { before: nextGroupId } }
+      }
+    })
+  }
+}

data/app/javascript/inner_plan/controllers/lists_controller.js

@@ -0,0 +1,30 @@
+import { Controller } from "@hotwired/stimulus";
+import Sortable from "sortablejs"
+import { patch } from "@rails/request.js"
+
+export default class extends Controller {
+  static targets = ['list'];
+
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      handle: '.list-handle',
+      group: 'list',
+      onUpdate: this.onUpdate.bind(this)
+    })
+  }
+
+  destroy() {
+    this.sortable.destroy();
+  }
+
+  onUpdate({ item }) {
+    const nextListEl = item.nextElementSibling;
+    const nextListId = nextListEl ? nextListEl.dataset.id : null
+
+    patch(item.dataset.updateUrl, {
+      body: {
+        list: { position: { before: nextListId } }
+      }
+    })
+  }
+}

data/app/javascript/inner_plan/controllers/task_inline_form_controller.js

@@ -0,0 +1,40 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ['form', 'toggler', 'defaultInput']
+
+  static values = {
+    formVisible: {
+      type: Boolean,
+      default: false
+    }
+  }
+
+  formVisibleValueChanged(value) {
+    if (value) {
+      this.showForm()
+    } else {
+      this.hideForm()
+    }
+  }
+
+  escPressed() {
+    this.formVisibleValue = false
+  }
+
+  togglerClicked(e) {
+    e.preventDefault()
+    this.formVisibleValue = true
+  }
+
+  showForm() {
+    this.formTarget.classList.remove('d-none')
+    this.togglerTarget.classList.add('d-none')
+    this.defaultInputTarget.focus()
+  }
+
+  hideForm() {
+    this.formTarget.classList.add('d-none')
+    this.togglerTarget.classList.remove('d-none')
+  }
+}

data/app/javascript/inner_plan/controllers/tasks_controller.js

@@ -0,0 +1,47 @@
+import { Controller } from "@hotwired/stimulus";
+import Sortable from "sortablejs"
+import { patch } from "@rails/request.js"
+
+export default class extends Controller {
+  static values = {
+    listId: Number
+  };
+
+  connect() {
+    this.sortable = Sortable.create(this.element, {
+      handle: '.task-handle',
+      group: 'task',
+      onUpdate: this.onUpdate.bind(this),
+      onAdd: this.onAdd.bind(this),
+    })
+  }
+
+  destroy() {
+    this.sortable.destroy();
+  }
+
+  onAdd({ item }) {
+    const nextTaskEl = item.nextElementSibling;
+    const nextTaskId = nextTaskEl ? nextTaskEl.dataset.id : null
+
+    patch(item.dataset.updateUrl, {
+      body: {
+        task: {
+          list_id: this.listIdValue,
+          position: { before: nextTaskId }
+        }
+      }
+    })
+  }
+
+  onUpdate({ item }) {
+    const nextTaskEl = item.nextElementSibling;
+    const nextTaskId = nextTaskEl ? nextTaskEl.dataset.id : null
+
+    patch(item.dataset.updateUrl, {
+      body: {
+        task: { position: { before: nextTaskId } }
+      }
+    })
+  }
+}

data/app/jobs/inner_plan/application_job.rb

@@ -0,0 +1,4 @@
+module InnerPlan
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/inner_plan/application_mailer.rb

@@ -0,0 +1,6 @@
+module InnerPlan
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/inner_plan/application_record.rb

@@ -0,0 +1,5 @@
+module InnerPlan
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end