tramway 0.1.2 → 0.1.3

data/app/controllers/tramway/concerns/auth_management.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Tramway::Concerns::AuthManagement
-  def sign_in(user)
-    session[:tramway_user_id] = user.id
-  end
-
-  def sign_out
-    session[:tramway_user_id] = nil
-  end
-
-  def signed_in?
-    current_user
-  end
-
-  def authenticate_user!
-    redirect_to Tramway::Engine.routes.url_helpers.new_session_path if !session_path? && !signed_in?
-  end
-
-  def current_user
-    user = Tramway::User.find_by id: session[:tramway_user_id]
-    return false unless user
-
-    Tramway::UserDecorator.decorate user
-  end
-end

data/app/controllers/tramway/concerns/filtering.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Tramway::Concerns::Filtering
-  def list_filtering(records)
-    params[:list_filters]&.each do |filter, _value|
-      case decorator_class.list_filters[filter.to_sym][:type]
-      when :select
-        records = list_filtering_select records, filter
-      when :dates
-        records = list_filtering_dates records, filter
-      end
-    end
-
-    records
-  end
-
-  def list_filtering_select(records, filter)
-    value.present? ? decorator_class.list_filters[filter.to_sym][:query].call(records, value) : records
-  end
-
-  def list_filtering_dates(records, filter)
-    begin_date = date_filter :begin, filter
-    end_date = date_filter :end, filter
-    if begin_date.present? && end_date.present? && value.present?
-      decorator_class.list_filters[filter.to_sym][:query].call(records, begin_date, end_date)
-    else
-      records
-    end
-  end
-
-  def date_filter(type, filter)
-    params[:list_filters][filter.to_sym]["#{type}_date".to_sym]
-  end
-
-  def filtering(records)
-    if params[:filter].present?
-      params[:filter] = JSON.parse params[:filter] if params[:filter].is_a? String
-      records.ransack(params[:filter]).result(distinct: true)
-    else
-      records
-    end
-  end
-end

data/app/controllers/tramway/export/application_controller.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Tramway::Export::ApplicationController < Tramway::ApplicationController
-  before_action :authenticate_admin!
-end

data/app/controllers/tramway/has_and_belongs_to_many_records_controller.rb

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

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# FIXME: configurate load_path
-load "#{Tramway.root}/app/controllers/tramway/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::Concerns::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

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-# FIXME: configurate load_path
-load "#{Tramway.root}/app/controllers/tramway/concerns/auth_management.rb"
-
-class Tramway::WelcomeController < Tramway::ApplicationController
-  skip_before_action :check_available!
-
-  # FIXME: should be included in Tramway::ApplicationController
-  include Tramway::Concerns::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

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

@@ -1,124 +0,0 @@
-# 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 == :versions
-    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

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

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

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

@@ -1,97 +0,0 @@
-# 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
-
-  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:, 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:
-      )
-    end
-    concat download_button(filename:, 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