tramway 0.1.2 → 0.1.3

data/app/helpers/tramway/actions_helper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Tramway::ActionsHelper
-  def create_is_available?(model_class)
-    Tramway.action_is_available?(
-      nil,
-      project: (@application_engine || @application.name),
-      model_name: model_class,
-      role: current_user.role,
-      action: :create
-    )
-  end
-
-  def update_is_available?(object)
-    Tramway.action_is_available?(
-      object,
-      project: (@application_engine || @application.name),
-      model_name: object.model.class.name,
-      role: current_user.role,
-      action: :update
-    )
-  end
-
-  def destroy_is_available?(object)
-    Tramway.action_is_available?(
-      object,
-      project: (@application_engine || @application.name),
-      model_name: object.model.class.name,
-      role: current_user.role,
-      action: :destroy
-    )
-  end
-
-  # delete_button is in smart-buttons gem
-
-  def edit_button(url:, button_options:, &block)
-    link_to(url, **button_options, &block)
-  end
-
-  def habtm_destroy_is_available?(association_object, main_object)
-    main_model_name = main_object.model.class.to_s.underscore.pluralize
-
-    Tramway.forms&.include?("#{main_model_name}/remove_#{association_object.model.class.to_s.underscore}")
-  end
-end

data/app/helpers/tramway/additional_buttons_builder.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Tramway::AdditionalButtonsBuilder
-  def build_button(button)
-    options = button[:options] || {}
-    style = 'margin-right: 8px'
-    concat(link_to(button[:url], method: button[:method], class: "btn btn-#{button[:color]} btn-xs", style:,
-                                 **options) do
-             button[:inner]&.call
-           end)
-  end
-end

data/app/helpers/tramway/application_helper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Tramway::ApplicationHelper
-  include FontAwesome5::Rails::IconHelper
-  include SmartButtons
-  include Tramway::Concerns::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

@@ -1,13 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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:,
-                                       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

@@ -1,30 +0,0 @@
-# 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:
-      )
-    end
-    return unless full_class_name_association.is_a? Array
-
-    Tramway::Error.raise_error(
-      :tramway, :inputs_helpers, :association_params, :used_polymorphic_association, property:
-    )
-  end
-end

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

@@ -1,24 +0,0 @@
-# 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

@@ -1,96 +0,0 @@
-# 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:, property:, 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:, 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

@@ -1,7 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,120 +0,0 @@
-# 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:, scope: tab
-    else
-      records_path model: model_class, 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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:,
-      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

@@ -1,25 +0,0 @@
-# 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

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

data/app/inputs/multiple_file_input.rb

@@ -1,7 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'carrierwave/orm/activerecord' if defined?(CarrierWave::Mount)
-
-class Tramway::ApplicationRecord < ActiveRecord::Base
-  primary_abstract_class
-
-  self.abstract_class = true
-  has_paper_trail
-  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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-class Tramway::User < Tramway::ApplicationRecord
-  has_secure_password
-
-  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