tramway 0.1.0 → 0.1.1

data/app/helpers/tramway/application_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tramway::ApplicationHelper
+  include FontAwesome5::Rails::IconHelper
+  include SmartButtons
+  include Tramway::AuthManagement
+
+  helpers = Dir["#{Tramway.root}/app/helpers/tramway/*_helper.rb"]
+  helpers.each do |helper|
+    module_name = helper.split('/')[-2..].join('/')[0..-4].camelize.constantize
+
+    include module_name unless Tramway::ApplicationHelper
+  end
+
+  def object_type(object)
+    object_class_name = if object.class.ancestors.include? ::Tramway::ApplicationDecorator
+                          object.class.model_class.name
+                        else
+                          object.class.name
+                        end
+    if Tramway.available_models_for(@application_engine || @application.name).map(&:to_s).include?(object_class_name)
+      :record
+    else
+      :singleton
+    end
+  end
+end

data/app/helpers/tramway/cases_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tramway::CasesHelper
+  def plural(word)
+    if I18n.locale == :ru
+      russian_plural word
+    elsif word.respond_to?(:model_name)
+      word.model_name.human.pluralize(I18n.locale)
+    else
+      word.human.pluralize(I18n.locale)
+    end
+  end
+end

data/app/helpers/tramway/copy_to_clipboard_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Tramway::CopyToClipboardHelper
+  def copy_to_clipboard(id)
+    button_tag class: 'btn btn-info clipboard-btn',
+      data: { clipboard_action: 'copy', clipboard_target: "##{id}" },
+      style: 'margin-left: 15px' do
+      fa_icon 'copy'
+    end
+  end
+end

data/app/helpers/tramway/focus_generator_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ::Tramway
+  module FocusGeneratorHelper
+    # FIXME: create independent focus generator
+    def focus_selector(index)
+      "table:nth-child(2)>tbody>tr:nth-child(#{index - 1})"
+    end
+  end
+end

data/app/helpers/tramway/frontend_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tramway::FrontendHelper
+  def react_params(form, action, method)
+    form.properties.each_with_object({ action: react_params_url(form, action), method: method,
+                                       authenticity_token: form_authenticity_token }) do |property, hash|
+      case property[1]
+      when :association
+        hash.merge!(
+          property[0] => {
+            collection: build_collection_for_association(form, property[0])
+          }
+        )
+      end
+    end.merge model: form.model.attributes
+  end
+
+  def react_params_url(form, action)
+    case action
+    when :create
+      Tramway::Engine.routes.url_helpers.records_path(model: form.model.class)
+    else
+      Tramway::Engine.routes.url_helpers.record_path(form.model.id, model: form.model.class)
+    end
+  end
+end

data/app/helpers/tramway/inputs/associations_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Tramway::Inputs::AssociationsHelper
+  def build_collection_for_association(form_object, property)
+    full_class_name_association = form_object.class.full_class_name_association(property)
+    check_valid_association full_class_name_association
+    full_class_name_association.send("#{current_user.role}_scope", current_user.id).map do |obj|
+      decorator_class(full_class_name_association).decorate obj
+    end.sort_by do |association|
+      association.name || "#{association.class.name} ##{association.id}"
+    end
+  end
+
+  def build_value_for_association(form_object, property, value)
+    form_object.send(property) || form_object.model.send("#{property}_id") || value
+  end
+
+  def check_valid_association(full_class_name_association)
+    unless full_class_name_association
+      Tramway::Error.raise_error(
+        :tramway, :inputs_helpers, :association_params, :defined_with_property_method, property: property
+      )
+    end
+    return unless full_class_name_association.is_a? Array
+
+    Tramway::Error.raise_error(
+      :tramway, :inputs_helpers, :association_params, :used_polymorphic_association, property: property
+    )
+  end
+end

data/app/helpers/tramway/inputs/polymorphic_associations_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Tramway::Inputs::PolymorphicAssociationsHelper
+  def build_collection_for_polymorphic_association(form_object, property)
+    object_names = full_class_names(form_object, property).map do |class_name|
+      class_name.send("#{current_user.role}_scope", current_user.id).map do |obj|
+        decorator_class(class_name).decorate obj
+      end
+    end.flatten
+    object_names.sort_by { |obj| obj.name.to_s }
+  end
+
+  def build_value_for_polymorphic_association(form_object, property, value)
+    if form_object.send(property).present?
+      "#{form_object.send(property).class.to_s.underscore}_#{form_object.send(property).id}"
+    elsif value[:type].present? && value[:id].present?
+      "#{value[:type]&.underscore}_#{value[:id]}"
+    end
+  end
+
+  def full_class_names(form_object, property)
+    form_object.model.class.send("#{property}_type").values.map(&:constantize)
+  end
+end

data/app/helpers/tramway/inputs_helper.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Tramway::InputsHelper
+  include Tramway::Inputs::AssociationsHelper
+  include Tramway::Inputs::PolymorphicAssociationsHelper
+
+  def association_params(form_object:, property:, value:, object:, options: {})
+    full_class_name_association = form_object.class.full_class_name_association(property)
+
+    value = current_user&.id if full_class_name_association.to_s == 'Tramway::User'
+
+    build_input_attributes(object: object, property: property, options: options,
+      value: build_value_for_association(form_object, property, value),
+      collection: build_collection_for_association(form_object, property),
+      include_blank: true,
+      selected: form_object.model.send("#{property}_id") || value)
+  end
+
+  def polymorphic_association_params(object:, form_object:, property:, value:, options: {})
+    build_input_attributes object: object, property: property,
+      selected: build_value_for_polymorphic_association(form_object, property, value),
+      value: build_value_for_polymorphic_association(form_object, property, value),
+      collection: build_collection_for_polymorphic_association(form_object, property),
+      options: options.merge(
+        as: :select,
+        include_blank: true,
+        label_method: ->(obj) { "#{obj.class.model_name.human} | #{obj.name}" },
+        value_method: lambda { |obj|
+          "#{obj.class.to_s.underscore.sub(/_decorator$/, '')}_#{obj.id}"
+        }
+      )
+  end
+
+  def build_input_attributes(**options)
+    {
+      label: false,
+      input_html: {
+        name: "#{options[:object]}[#{options[:property]}]",
+        id: "#{options[:object]}_#{options[:property]}",
+        value: options[:value]
+      },
+      selected: options[:selected],
+      collection: options[:collection]
+    }.merge options[:options]
+  end
+
+  def value_from_params(model_class:, property:, type:)
+    case type
+    when :polymorphic_association, 'polymorphic_association'
+      {
+        id: params.dig(model_class.to_s.underscore, property.to_s),
+        type: params.dig(model_class.to_s.underscore, "#{property}_type")
+      }
+    else
+      params.dig(model_class.to_s.underscore, property.to_s)
+    end
+  end
+
+  def default_params(property:, object:, form_object:, value:, options: {})
+    {
+      label: false,
+      input_html: {
+        name: "#{object}[#{property}]",
+        id: "#{object}_#{property}",
+        value: (form_object.send(property) || form_object.model.send(property) || value)
+      },
+      selected: (form_object.model.send(property) || value)
+    }.merge options
+  end
+
+  def simple_params(**options)
+    builded_options = { as: options[:type], label: false,
+                        input_html: {
+                          name: "#{options[:object]}[#{options[:property]}]",
+                          id: "#{options[:object]}_#{options[:property]}",
+                          value: build_simple_value(
+                            *options.values_at(:form_object, :property, :value),
+                            options.dig(:options, :input_html, :value)
+                          )
+                        } }
+    merge_with_user_options builded_options, options
+  end
+
+  def build_simple_value(form_object, property, value, input_html_value)
+    value_to_add = input_html_value || value
+    value_to_add || form_object.send(property)
+  end
+
+  def merge_with_user_options(builded_options, options)
+    if options[:options].present?
+      options[:options][:input_html]&.delete(:value)
+      builded_options.merge!(options) || {}
+    end
+    builded_options
+  end
+end

data/app/helpers/tramway/model_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Tramway::ModelHelper
+  def tramway_model?(model_class)
+    model_class.ancestors.include? Tramway::ApplicationRecord
+  end
+end

data/app/helpers/tramway/navbar_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Tramway::NavbarHelper
+  def customized_admin_navbar_given?
+    customized_admin_navbar.present?
+  end
+
+  def customized_admin_navbar
+    ::Tramway.customized_admin_navbar
+  end
+end

data/app/helpers/tramway/records_helper.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Tramway::RecordsHelper
+  # FIXME: replace to module
+  def current_model_record_path(*args, **options)
+    record_path args, options.merge(model: params[:model])
+  end
+
+  def edit_current_model_record_path(*args, **options)
+    edit_record_path args, options.merge(model: params[:model])
+  end
+
+  def new_current_model_record_path(*args, **options)
+    new_record_path args, options.merge(model: params[:model])
+  end
+
+  def current_model_records_path(*args, **options)
+    records_path args, options.merge(model: params[:model])
+  end
+
+  def public_path(record)
+    record.public_path || try("#{record.class.name.underscore.gsub('/', '_')}_path", record)
+  end
+
+  def model_class
+    params[:model].constantize
+  end
+
+  def decorator_class(model_name = nil)
+    "#{model_name || model_class}Decorator".constantize
+  end
+
+  def to_path(constant)
+    constant.name.underscore.gsub '/', '_'
+  end
+
+  def search_tab_title(count)
+    "#{t('helpers.scope.found')} / #{count}"
+  end
+
+  def searchable_model?(model_class)
+    model_class.methods.include? :full_text_search
+  end
+
+  def build_options_for_select(name, collection)
+    selected_value = params[:list_filters].present? ? params[:list_filters][name] : nil
+    options_for_select(collection, selected_value)
+  end
+
+  def index_path_of_model(model_class, tab, filter)
+    if tab
+      records_path model: model_class, filter: filter, scope: tab
+    else
+      records_path model: model_class, filter: filter
+    end
+  end
+
+  def collection_human_name(model_name:, collection_name:)
+    if t("default.collections.#{collection_name}").include?('<span')
+      t("collections.#{model_name}.#{collection_name}").pluralize(:ru)
+    else
+      t("default.collections.#{collection_name}")
+    end
+  end
+
+  def tab_title(model_class, tab, count, _state_method = :state)
+    model = model_class.name.underscore
+    name = collection_human_name model_name: model, collection_name: tab
+    "#{name} / #{count}"
+  end
+
+  def active_tab(tab, index)
+    return :active if params[:scope].nil? && index.zero?
+    return :active if params[:search].nil? && params[:scope].to_s == tab.to_s
+  end
+
+  def new_associated_record_path(object:, association:, as:)
+    unless association.options[:class_name].present?
+      raise "You should set `class_name` for #{association.name} association"
+    end
+
+    new_record_path(**new_record_path_options(object, association, as))
+  end
+
+  def new_record_path_options(object, association, as)
+    hash = {
+      model: association.class_name,
+      redirect: current_model_record_path(object.model)
+    }
+
+    if association.options[:as].present? # polymorphic? conditiion
+      hash.merge! options_for_polymorphic_link object, association
+    else
+      hash.merge! options_for_isomorphic_link object, association, as
+    end
+
+    hash
+  end
+
+  def options_for_polymorphic_link(object, association)
+    {
+      association.options[:class_name].underscore => {
+        association.options[:as] => object.id,
+        association.type => object.class.model_name
+      }
+    }
+  end
+
+  def options_for_isomorphic_link(object, association, as)
+    {
+      association.options[:class_name].underscore => {
+        as || object.model.class.name.underscore.gsub('/', '_') => object.id
+      }
+    }
+  end
+
+  def there_any_filters?(model_class)
+    decorator_class(model_class).list_filters&.any?
+  end
+end

data/app/helpers/tramway/russian_cases_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tramway::RussianCasesHelper
+  def case_word(model_name, case_name)
+    word_case = I18n.t("cases.#{model_name.name.underscore}.#{case_name}")
+    return word_case if word_case.present?
+
+    raise "There is not #{case_name} implementation for \"#{model_name}\""
+  end
+
+  def genitive(word)
+    case_word word, :genitive
+  end
+
+  def instrumental(word)
+    case_word word, :instrumental
+  end
+
+  def dative(word)
+    case_word word, :dative
+  end
+
+  def russian_plural(word)
+    case_word word, :plural
+  end
+end

data/app/helpers/tramway/singleton_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tramway::SingletonHelper
+  # FIXME: replace to module
+  def current_model_singleton_path(*args, **options)
+    singleton_path args, options.merge(model: params[:model])
+  end
+
+  def edit_current_model_singleton_path(*args, **options)
+    edit_singleton_path args, options.merge(model: params[:model])
+  end
+end

data/app/helpers/tramway/state_machine_buttons_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Tramway::StateMachineButtonsHelper
+  def state_events_buttons(object, **options)
+    options.each do |(key, value)|
+      define_singleton_method(key) { value }
+    end
+    content_tag(:div, class: 'btn-group-vertical') do
+      transitions(object, state_method, options[:without]).each do |event|
+        button(
+          object,
+          event: event[:event],
+          model_name: object.class.model_name.name.underscore,
+          form_options: button_options,
+          **options
+        )
+      end
+    end
+  end
+
+  private
+
+  def excepted_actions(without)
+    return unless without
+
+    without.is_a?(Array) ? without.map(&:to_sym) : [without.to_sym]
+  end
+
+  def transitions(object, state_method, without)
+    object.model.aasm(state_method).permitted_transitions.reject do |t|
+      excepted_actions(without).present? && excepted_actions(without).include?(t[:event])
+    end
+  end
+
+  def button(object, **options)
+    event = options[:event]
+
+    concat(
+      patch_button(patch_button_options(object, event, options)) do
+        model = object.model
+        class_name = model.class.name.underscore
+        actual_event = model.aasm(options[:state_method]).events.select { |ev| ev.name == event }.first.name
+        I18n.t("state_machines.#{class_name}.#{options[:state_method]}.events.#{actual_event}")
+      end
+    )
+  end
+
+  def patch_button_options(object, event, options)
+    attributes = { aasm_event: event }
+    css_class = "btn btn-sm btn-xs btn-#{object.public_send("#{options[:state_method]}_button_color", event)}"
+
+    {
+      record: object.model,
+      attributes: attributes,
+      model_name: options[:model_name],
+      button_options: { class: css_class },
+      form_options: options[:form_options],
+      url: Tramway::Engine.routes.url_helpers.record_path(object.id, options[:parameters])
+    }
+  end
+end

data/app/helpers/tramway/title_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Tramway::TitleHelper
+  def title(page_title = default_title)
+    @application ||= Tramway.application&.model_class&.first || Tramway.application
+    if @application.present?
+      title_text = "#{page_title} | #{@application.try(:title) || @application.public_name}"
+      content_for(:title) { title_text }
+    else
+      Tramway::Error.raise_error(:tramway, :title_helper, :title, :you_should_set_tramway_core_application)
+    end
+  end
+
+  def default_title
+    t('.title')
+  end
+
+  def page_title(action, model_name)
+    if I18n.locale == :ru
+      "#{t("helpers.actions.#{action}")} #{genitive(model_name)}"
+    else
+      "#{t("helpers.actions.#{action}")} #{model_name.model_name.human.downcase}"
+    end
+  end
+end

data/app/inputs/date_picker_input.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class DatePickerInput < SimpleForm::Inputs::StringInput
+end

data/app/inputs/multiple_file_input.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class MultipleFileInput < SimpleForm::Inputs::FileInput
+  def input(wrapper_options)
+    super(wrapper_options.merge! multiple: true)
+  end
+end

data/app/models/tramway/application_record.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'carrierwave/orm/activerecord' if defined?(CarrierWave::Mount)
+
+class Tramway::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  audited
+  extend ::Enumerize
+  include AASM
+  acts_as_paranoid
+
+  scope :created_by_user, lambda { |user_id|
+    joins(:audits).where('audits.action = \'create\' AND audits.user_id = ?', user_id)
+  }
+  scope :admin_scope, ->(_arg) { all }
+
+  include ::PgSearch::Model
+
+  def creator
+    creation_event = audits.where(action: :create).first
+    creation_event.user if creation_event.user_id.present?
+  end
+
+  # FIXME: detect inhertited locales
+  class << self
+    def human_attribute_name(attribute_name, *_args)
+      excepted_attributes = %w[created_at updated_at]
+      if attribute_name.to_s.in? excepted_attributes
+        I18n.t "activerecord.attributes.tramway/application_record.#{attribute_name}"
+      else
+        super attribute_name
+      end
+    end
+
+    def search_by(*attributes, **associations)
+      pg_search_scope :full_text_search,
+        against: attributes,
+        associated_against: associations,
+        using: %i[tsearch trigram]
+    end
+
+    def uploader(attribute_name, uploader_name, **options)
+      mount_uploader attribute_name, "#{uploader_name.to_s.camelize}Uploader".constantize
+      @versions = options[:versions] if uploader_name == :photo
+      @extensions = options[:extensions]
+    end
+
+    def photo_versions
+      @versions
+    end
+
+    def file_extensions
+      @extensions
+    end
+
+    def state_machines_names
+      AASM::StateMachineStore.fetch(self).machine_names
+    end
+  end
+end

data/app/models/tramway/user.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Tramway::User < ::Tramway::ApplicationRecord
+  has_secure_password
+
+  if defined? Tramway::Conference
+    has_many :social_networks, as: :record,
+      class_name: 'Tramway::Profiles::SocialNetwork'
+  end
+
+  scope :admins, -> { where role: :admin }
+  scope :simple_users, -> { where role: :user }
+
+  enumerize :role, in: %i[user admin], default: :admin
+
+  def admin?
+    role.admin?
+  end
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end

data/app/uploaders/application_uploader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'carrierwave'
+
+class ApplicationUploader < CarrierWave::Uploader::Base
+  storage :file
+
+  def store_dir
+    "system/uploads/#{model.class.model_name.to_s.underscore}/#{mounted_as}/#{id_directory}"
+  end
+
+  private
+
+  def id_directory
+    if model.respond_to?(:uuid)
+      model.reload unless model.uuid.present?
+      model.uuid
+    else
+      model.id
+    end
+  end
+end

data/app/uploaders/file_uploader.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class FileUploader < ApplicationUploader
+end

data/app/uploaders/ico_uploader.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class IcoUploader < ApplicationUploader
+  def extension_allowlist
+    model.class.file_extensions || %w[ico]
+  end
+end

data/app/uploaders/image_defaults.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ImageDefaults
+  include CarrierWave::MiniMagick
+
+  def default_url
+    "/images/fallback/#{model.class.model_name.to_s.underscore}/" <<
+      [mounted_as, version_name].compact.join('_') << '.gif'
+  end
+
+  def extension_allowlist
+    model.class.file_extensions || %w[jpg jpeg gif png]
+  end
+end