tramway 0.1.0 → 0.1.1

data/app/controllers/tramway/has_and_belongs_to_many_records_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Tramway::HasAndBelongsToManyRecordsController < Tramway::ApplicationController
+  def create
+    base_object = model_class.find params[:object_id]
+    @record_form = form_class.new base_object
+    @sending_params = params[params[:model_class].underscore] || params[form_class.associated_as]
+    redirect_to path
+  end
+
+  def destroy
+    base_object = model_class.find params[:object_id]
+    @record_form = params[:form].constantize.new base_object
+    redirect_to path
+  end
+
+  private
+
+  def path
+    params[:redirect].present? ? params[:redirect] : record_path(base_object, model: base_object.class)
+  end
+
+  def form_class
+    params[:form].constantize
+  end
+end

data/app/controllers/tramway/records_controller.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class Tramway::RecordsController < Tramway::ApplicationController
+  def index
+    records = model_class.order(id: :desc).send scope
+    records = full_text_search records
+    records = filtering records
+    records = list_filtering records
+    records = records.public_send current_user_role_scope, current_user.id
+    @records = decorator_class.decorate records.page params[:page]
+  end
+
+  def show
+    @record = decorator_class.decorate model_class.find params[:id]
+  end
+
+  def new
+    @record_form = admin_form_class.new model_class.new
+  end
+
+  def create
+    @record_form = admin_form_class.new model_class.new
+    if @record_form.submit params[attributes_key]
+      redirect_to params[:redirect].present? ? params[:redirect] : record_path(@record_form.model)
+    else
+      render :new
+    end
+  end
+
+  def edit
+    @record_form = admin_form_class.new model_class.find params[:id]
+  end
+
+  def update
+    @record_form = admin_form_class.new model_class.find params[:id]
+    if state_event.present?
+      if record_state_event?
+        record_make_state_event!
+        default_redirect
+      end
+    elsif @record_form.submit params[attributes_key]
+      default_redirect
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    record = model_class.find params[:id]
+    record.destroy
+    redirect_to params[:redirect].present? ? params[:redirect] : records_path
+  end
+
+  private
+
+  def default_redirect
+    redirect_to params[:redirect].present? ? params[:redirect] : record_path(@record_form.model)
+  end
+
+  def record_state_event?
+    @record_form.model.public_send("may_#{state_event}?")
+  end
+
+  def record_make_state_event!
+    @record_form.model.send("#{state_event}!")
+  end
+
+  def state_event
+    params[attributes_key][:aasm_event]
+  end
+
+  def scope
+    params[:scope].present? ? params[:scope] : :all
+  end
+
+  def full_text_search(records)
+    params[:search].present? ? records.full_text_search(params[:search]) : records
+  end
+
+  def attributes_key
+    old_key_name = model_class.to_s.underscore
+    actual_key_name = :record
+
+    params[old_key_name].present? ? old_key_name : actual_key_name
+  end
+end

data/app/controllers/tramway/sessions_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# FIXME: configurate load_path
+load "#{Tramway.root}/app/controllers/concerns/auth_management.rb"
+
+class Tramway::SessionsController < Tramway::ApplicationController
+  before_action :redirect_if_signed_in, except: :destroy
+
+  # FIXME: should be included in Tramway::ApplicationController
+  include Tramway::AuthManagement
+
+  def new
+    @session_form = Tramway::SessionForm.new Tramway::User.new
+  end
+
+  def create
+    @session_form = Tramway::SessionForm.new record
+
+    if @session_form.validate params[:user]
+      sign_in @session_form.model
+      redirect_to root_path
+    else
+      render :new
+    end
+  end
+
+  def destroy
+    root_path = Tramway::Engine.routes.url_helpers.root_path
+    sign_out
+
+    redirect_to params[:redirect] || root_path
+  end
+
+  private
+
+  def redirect_if_signed_in
+    if params[:model].present? && signed_in? && request.env['PATH_INFO'] != Tramway.root_path_for(current_user.class)
+      redirect_to Tramway.root_path_for(current_user.class)
+    end
+  end
+
+  def record
+    @record ||= params[:model].constantize.find_by email: params[:user][:email]
+  end
+
+  def root_path
+    Tramway::Engine.routes.url_helpers.root_path[0..-2]
+  end
+end

data/app/controllers/tramway/singletons_controller.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Tramway
+  class SingletonsController < ApplicationController
+    def show
+      if model_class.first.present?
+        @singleton = decorator_class.decorate model_class.first
+      else
+        @singleton_form = admin_form_class.new model_class.new
+        render :new
+        nil
+      end
+    end
+
+    def edit
+      @singleton_form = admin_form_class.new model_class.first
+    end
+
+    def create
+      @singleton_form = admin_form_class.new model_class.new
+      if @singleton_form.submit params[:singleton]
+        redirect_to params[:redirect] || singleton_path(model: params[:model])
+      else
+        render :edit
+      end
+    end
+
+    def update
+      @singleton_form = admin_form_class.new model_class.first
+      if @singleton_form.submit params[:singleton]
+        redirect_to params[:redirect] || singleton_path(model: params[:model])
+      else
+        render :edit
+      end
+    end
+  end
+
+  private
+
+  # FIXME: replace to module
+  def singleton_path(*args, **options)
+    super args, options.merge(model: params[:model])
+  end
+
+  def edit_singleton_path(*args, **options)
+    super args, options.merge(model: params[:model])
+  end
+end

data/app/controllers/tramway/welcome_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# FIXME: configurate load_path
+load "#{Tramway.root}/app/controllers/concerns/auth_management.rb"
+
+class Tramway::WelcomeController < Tramway::ApplicationController
+  skip_before_action :check_available!
+
+  # FIXME: should be included in Tramway::ApplicationController
+  include Tramway::AuthManagement
+
+  before_action :authenticate_user!
+
+  def index
+    instance_exec(&::Tramway.welcome_page_actions) if ::Tramway.welcome_page_actions.present?
+  end
+end

data/app/decorators/tramway/application_decorated_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Tramway::ApplicationDecoratedCollection < Array
+  def initialize(array, original_array)
+    @original_array = original_array
+    super(array)
+  end
+
+  attr_reader :original_array
+
+  delegate :total_pages, to: :original_array
+  delegate :total_count, to: :original_array
+  delegate :current_page, to: :original_array
+  delegate :limit_value, to: :original_array
+end

data/app/decorators/tramway/application_decorator.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'tramway/error'
+require 'tramway/class_name_helpers'
+
+class Tramway::ApplicationDecorator
+  include ActionView::Helpers
+  include ActionView::Context
+  include FontAwesome5::Rails::IconHelper
+  include Tramway::CopyToClipboardHelper
+  include Tramway::Associations::ObjectHelper
+  include Tramway::Attributes::ViewHelper
+  include Tramway::Concerns::TableBuilder
+  include Tramway::ClassNameHelpers
+
+  def initialize(object)
+    @object = object
+  end
+
+  def name
+    object.try(:name) || object.try(:title) || title
+  end
+
+  def title
+    Tramway::Error.raise_error(
+      :tramway, :application_decorator, :title, :please_implement_title,
+      class_name: self.class, object_class: object.class
+    )
+  end
+
+  def present?
+    object.present?
+  end
+
+  def render(view, **locals)
+    view_name = view.split('/').map.with_index do |dir, index|
+      if index == view.split('/').length - 1
+        "_#{dir}"
+      else
+        dir
+      end
+    end.join('/')
+    Haml::Engine.new(File.read("#{Rails.root}/app/views/#{view_name}.html.haml")).render(self, locals)
+  end
+
+  def listed_state_machines
+    nil
+  end
+
+  delegate :id, to: :object
+
+  class << self
+    include Tramway::Associations::ClassHelper
+    include Tramway::Delegating::ClassHelper
+    include Tramway::Default::ValuesHelper
+
+    def decorate(object_or_array)
+      is_activerecord_relation = object_or_array.class.superclass == ActiveRecord::Relation
+      is_activerecord_association_relation = object_or_array.class.to_s.include?('ActiveRecord_AssociationRelation')
+      if is_activerecord_relation || is_activerecord_association_relation
+        decorated_array = object_or_array.map do |obj|
+          new obj
+        end
+        Tramway::ApplicationDecoratedCollection.new decorated_array, object_or_array
+      else
+        new object_or_array
+      end
+    end
+
+    def model_class
+      to_s.sub(/Decorator$/, '').constantize
+    end
+
+    def model_name
+      model_class.try(:model_name)
+    end
+  end
+
+  def link
+    if object.try :file
+      object.file.url
+    else
+      Tramway::Error.raise_error :tramway, :application_decorator, :link, :method_link_uses_file_attribute
+    end
+  end
+
+  def additional_buttons
+    { show: [], index: [] }
+  end
+
+  def public_path; end
+
+  def model
+    object
+  end
+
+  def associations(associations_type)
+    object.class.reflect_on_all_associations(associations_type).map do |association|
+      association unless association.name == :audits
+    end.compact
+  end
+
+  include Tramway::Concerns::AttributesDecoratorHelper
+
+  RESERVED_WORDS = ['fields'].freeze
+
+  def attributes
+    object.attributes.reduce({}) do |hash, attribute|
+      if attribute[0].in? RESERVED_WORDS
+        Tramway::Error.raise_error(
+          :tramway, :application_decorator, :attributes, :method_is_reserved_word,
+          attribute_name: attribute[0], class_name: self.class.name
+        )
+      end
+      hash.merge! attribute[0] => build_viewable_value(object, attribute)
+    end
+  end
+
+  protected
+
+  attr_reader :object
+
+  def association_class_name; end
+end

data/app/decorators/tramway/associations/class_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Tramway::Associations::ClassHelper
+  def decorate_association(association_name, decorator: nil, as: nil, state_machines: [])
+    @@decorated_associations ||= []
+    @@decorated_associations << association_name
+
+    define_main_association_method association_name, decorator
+
+    define_method "#{association_name}_as" do
+      as
+    end
+
+    define_method "#{association_name}_state_machines" do
+      state_machines
+    end
+
+    define_method "add_#{association_name}_form" do
+      add_association_form_class_name(object, association_name).new object
+    end
+  end
+
+  def decorate_associations(*association_names)
+    association_names.each do |association_name|
+      decorate_association association_name
+    end
+  end
+
+  def define_main_association_method(association_name, decorator)
+    define_method association_name do
+      association = object.class.reflect_on_association(association_name)
+      type = association_type(association)
+      return if association_has_one_without_object(object, association_name, type)
+
+      check_association object, association_name, association
+      decorator_class_name = decorator || decorator_class_name(class_name(association))
+      case type
+      when :has_many, :has_and_belongs_to_many
+        associations_collection(object, association_name, decorator_class_name)
+      when :belongs_to, :has_one
+        decorator_class_name.decorate(association_object(object, association_name))
+      end
+    end
+  end
+end

data/app/decorators/tramway/associations/object_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Tramway::Associations::ObjectHelper
+  def class_name(association)
+    if association.polymorphic?
+      object.send(association.name).class
+    else
+      unless association.options[:class_name]
+        Tramway::Error.raise_error(
+          :tramway, :associations, :object_helper, :please_specify_association_name,
+          association_name: association.name, object_class: object.class,
+          association_class_name: association.name.to_s.singularize.camelize
+        )
+      end
+      association.options[:class_name]
+    end
+  end
+
+  def check_association(object, association_name, association)
+    return unless association.nil?
+
+    Tramway::Error.raise_error(
+      :tramway, :associations, :class_helper, :model_does_not_have_association,
+      object_class: object.class, association_name: association_name
+    )
+  end
+
+  def association_type(association)
+    association.class.to_s.split('::').last.sub(/Reflection$/, '').underscore.to_sym
+  end
+
+  def associations_collection(object, association_name, decorator_class_name)
+    object.send(association_name).map do |association_object|
+      decorator_class_name.decorate association_object
+    end
+  end
+
+  def add_association_form_class_name(object, association_name)
+    form_class = "Admin::#{object.class.to_s.pluralize}::Add#{association_name.to_s.camelize.singularize}Form"
+
+    begin
+      form_class.constantize
+    rescue StandardError
+      Tramway::Error.raise_error(
+        :tramway, :associations, :object_helper, :habtm_add_class_not_defined,
+        class: form_class, association_name: association_name
+      )
+    end
+  end
+
+  def association_has_one_without_object(object, association_name, association_type)
+    association_type == :has_one && object.send(association_name).nil?
+  end
+
+  def association_object(object, association_name)
+    object.send association_name
+  end
+end

data/app/decorators/tramway/attributes/view_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Tramway::Attributes::ViewHelper
+  def build_viewable_value(object, attribute)
+    value = try(attribute[0]) ? send(attribute[0]) : object.send(attribute[0])
+    return state_machine_view(object, attribute[0]) if state_machine? object, attribute[0]
+
+    view_by_value object, value, attribute
+  end
+
+  def state_machine?(object, attribute_name)
+    attribute_name.to_s.in? object.class.state_machines_names.map(&:to_s)
+  end
+
+  def view_by_value(object, value, attribute)
+    if value.class.in? [ActiveSupport::TimeWithZone, DateTime, Time]
+      datetime_view(attribute[1])
+    elsif value.instance_of?(PhotoUploader)
+      image_view(object.send(attribute[0]))
+    elsif value.instance_of?(FileUploader)
+      file_view(object.send(attribute[0]))
+    elsif value.is_a? Enumerize::Value
+      enumerize_view(value)
+    elsif value.is_a? Hash
+      yaml_view(value)
+    else
+      value
+    end
+  end
+end

data/app/decorators/tramway/concerns/attributes_decorator_helper.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Tramway::Concerns::AttributesDecoratorHelper
+  def date_view(value)
+    I18n.l value.to_date if value
+  end
+
+  def datetime_view(value)
+    I18n.l value if value
+  end
+
+  def state_machine_view(object, attribute_name)
+    state = object.send(attribute_name)
+    I18n.t("state_machines.#{object.class.model_name.to_s.underscore}.#{attribute_name}.states.#{state}")
+  rescue StandardError
+    object.aasm.human_state
+  end
+
+  BASE64_REGEXP = %r{^(?:[a-zA-Z0-9+/]{4})*(?:|(?:[a-zA-Z0-9+/]{3}=)|
+                                            (?:[a-zA-Z0-9+/]{2}==)|(?:[a-zA-Z0-9+/]{1}===))$}x.freeze
+
+  def image_view(original, thumb: nil, filename: nil)
+    return unless original.present?
+
+    filename ||= build_filename(original)
+    content_tag(:div) do
+      build_div_content src_original(original), src_thumb(original, thumb), filename || build_filename(original)
+    end
+  end
+
+  def file_view(original, filename: nil)
+    return unless original.present?
+
+    filename ||= build_filename(original)
+    content_tag(:div) do
+      concat filename
+      concat ' '
+      concat download_button(filename: filename, original: original) if filename
+    end
+  end
+
+  def enumerize_view(value)
+    value.text
+  end
+
+  def yaml_view(value)
+    content_tag(:pre) { value.to_yaml }
+  end
+
+  private
+
+  def src_thumb(original, thumb)
+    thumb ||= original.is_a?(CarrierWave::Uploader::Base) ? original.small : nil
+    if thumb.is_a?(CarrierWave::Uploader::Base)
+      thumb.url
+    elsif thumb&.match(BASE64_REGEXP)
+      "data:image/jpeg;base64,#{thumb}"
+    else
+      thumb
+    end
+  end
+
+  def src_original(original)
+    case original
+    when CarrierWave::Uploader::Base
+      original.url
+    when BASE64_REGEXP
+      "data:image/jpeg;base64,#{original}"
+    else
+      original
+    end
+  end
+
+  def build_filename(original)
+    original.is_a?(CarrierWave::Uploader::Base) ? original.path&.split('/')&.last : nil
+  end
+
+  def build_div_content(original, thumb, filename)
+    begin
+      concat image_tag src_thumb(original, thumb) || src_original(original)
+    rescue NoMethodError => e
+      Tramway::Error.raise_error(
+        :tramway, :concerns, :attributes_decorator_helper, :you_should_mount_photo_uploader,
+        message: e.message, attribute_name: attribute_name
+      )
+    end
+    concat download_button(filename: filename, original: original) if filename
+  end
+
+  def download_button(filename:, original:)
+    link_to(fa_icon(:download), src_original(original), class: 'btn btn-success', download: filename)
+  end
+
+  def yes_no(boolean_attr)
+    boolean_attr.to_s == 'true' ? I18n.t('helpers.yes') : I18n.t('helpers.no')
+  end
+end

data/app/decorators/tramway/concerns/table_builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Tramway::Concerns::TableBuilder
+  def table(**options, &block)
+    content_tag(:table, class: 'table table-bordered table-striped', **options) do
+      yield if block
+    end
+  end
+
+  def thead(**options, &block)
+    content_tag(:thead, **options) do
+      yield if block
+    end
+  end
+
+  def th(**options, &block)
+    content_tag(:th, **options) do
+      yield if block
+    end
+  end
+
+  def td(**options, &block)
+    content_tag(:td, **options) do
+      yield if block
+    end
+  end
+
+  def tr(**options, &block)
+    content_tag(:tr, **options) do
+      yield if block
+    end
+  end
+end

data/app/decorators/tramway/default/values_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tramway::Default::ValuesHelper
+  def collections
+    [:all]
+  end
+
+  def list_attributes
+    []
+  end
+
+  def show_attributes
+    []
+  end
+
+  def show_associations
+    []
+  end
+
+  def list_filters
+    {}
+  end
+end

data/app/decorators/tramway/delegating/class_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Tramway::Delegating::ClassHelper
+  def delegate_attributes(*attributes)
+    attributes.each do |attr|
+      delegate attr, to: :object
+    end
+  end
+end