redde 0.1.18 → 0.3.0

data/app/controllers/admin/base_controller.rb

@@ -0,0 +1,81 @@
+class Admin::BaseController < ActionController::Base
+  layout 'admin'
+  before_action :authenticate_manager!
+  include Redde::AdminHelper
+  include Redde::IndexHelper
+
+  def welcome
+  end
+
+  def index
+    instance_variable_set("@#{collection}", scope)
+    return render 'tree' if column_names.include?('ancestry')
+  end
+
+  def new
+    instance_variable_set("@#{record}", model_name.new)
+    render 'edit'
+  end
+
+  def create
+    instance_variable_set("@#{record}", model_name.new(params[record.to_sym].permit!))
+    redirect_or_edit(instance_variable_get("@#{record}"), instance_variable_get("@#{record}").save)
+  end
+
+  def edit
+    instance_variable_set("@#{record}", model_name.find(params[:id]))
+  end
+
+  def update
+    instance_variable_set("@#{record}", model_name.find(params[:id]))
+    redirect_or_edit(instance_variable_get("@#{record}"), instance_variable_get("@#{record}").update(params[record.to_sym].permit!))
+  end
+
+  def destroy
+    instance_variable_set("@#{record}", model_name.find(params[:id]))
+    instance_variable_get("@#{record}").destroy
+    redirect_to send("admin_#{collection}_path"), notice: "#{model_name.model_name.human} удалена."
+  end
+
+  def sort
+    if column_names.include?('ancestry')
+      model_name.sort(params[:list])
+    else
+      params[:pos].each_with_index do |id, idx|
+        p = model_name.find(id)
+        p.update(position: idx)
+      end
+    end
+    render nothing: true
+  end
+
+  private
+
+  def scope
+    return model_name.roots.order(:position) if column_names.include?('ancestry')
+    scope = model_name
+    scope = scope.order('position') if column_names.include?('position')
+    scope.all.page(params[:page])
+  end
+
+  def redirect_or_edit(obj, saved, notice = nil, custom_url = nil)
+    return render 'edit' unless saved
+    yield if block_given?
+    redirect_to url_for_obj(obj, custom_url), notice: notice_for(obj, notice)
+  end
+
+  def notice_for(obj, notice = nil)
+    notice ||= default_notice
+    "#{obj.class.model_name.human} #{notice}."
+  end
+
+  def default_notice
+    'сохранена'
+  end
+
+  def url_for_obj(obj, custom_url = nil)
+    return custom_url if custom_url.present?
+    return [:edit, :admin, obj] if params[:commit] == 'Применить'
+    [:admin, obj.class.model_name.plural.to_sym]
+  end
+end

data/{lib/generators/redde/layout/templates/controllers → app/controllers/admin}/managers_controller.rb

@@ -1,35 +1,39 @@
 class Admin::ManagersController < Admin::BaseController
   def index
-    @managers = Manager.all
+    @managers = scope.all
   end
 
   def new
-    @manager = Manager.new
+    @manager = scope.new
     render 'edit'
   end
 
   def create
-    @manager = Manager.new(manager_params)
+    @manager = scope.new(manager_params)
     redirect_or_edit(@manager, @manager.save)
   end
 
   def edit
-    @manager = Manager.find(params[:id])
+    @manager = scope.find(params[:id])
   end
 
   def update
-    @manager = Manager.find(params[:id])
+    @manager = scope.find(params[:id])
     redirect_or_edit(@manager, @manager.update(manager_params))
   end
 
   def destroy
-    @manager = Manager.find(params[:id])
+    @manager = scope.find(params[:id])
     @manager.destroy if current_manager.id != @manager.id
     redirect_to [:admin, :managers], alert: 'Администратор удален'
   end
 
   private
 
+  def scope
+    Manager
+  end
+
   def manager_params
     params[:manager].permit!
   end

data/app/controllers/admin/redde_photos_controller.rb

@@ -0,0 +1,31 @@
+class Admin::ReddePhotosController < ActionController::Base
+  def sort
+    params[:photo].each_with_index do |id, idx|
+      p = Redde::Photo.find(id)
+      p.update(position: idx)
+    end
+    render nothing: true
+  end
+
+  def create
+    parent = photo_params[:imageable_type].constantize.find(photo_params[:imageable_id])
+    @photo = parent.photos.build(photo_params)
+    if @photo.save
+      render(partial: 'photo', object: @photo)
+    else
+      render nothing: true, status: 422
+    end
+  end
+
+  def destroy
+    @photo = Redde::Photo.find(params[:id])
+    @photo.destroy
+    render 'admin/redde_photos/destroy'
+  end
+
+  private
+
+  def photo_params
+    params.require(:redde_photo).permit!
+  end
+end

data/app/controllers/admin/system_commands_controller.rb

@@ -0,0 +1,11 @@
+class Admin::SystemCommandsController < Admin::BaseController
+  def index
+  end
+
+  def update
+    return redirect_to [:admin, :system_commands], alert: 'Необходимо указать команду' unless params[:id].present?
+    return redirect_to [:admin, :system_commands], notice: 'Недопустимый тип команды' unless Redde::SystemCommand::ALLOWED_ACTIONS.include?(params[:id].to_s)
+    Redde::SystemCommand.execute(params[:id])
+    redirect_to [:admin, :system_commands], notice: 'Команда отправлена'
+  end
+end

data/app/form_builders/redde_form_builder.rb

@@ -0,0 +1,106 @@
+class ReddeFormBuilder < ActionView::Helpers::FormBuilder
+  delegate :render, :content_tag, :tag, :link_to, :concat, :capture, to: :@template
+  # delegate :debug, :render, :content_tag, :tag, :link_to, :concat, :capture, to: :@template
+
+  def redde_field(name, *args)
+    label(name)
+    case object.class.columns.detect { |column| column.name == name.to_s }.type
+    when :text then redde_text_area(name, *args)
+    when :boolean then redde_check_box(name, *args)
+    when :time then redde_date_time(name, *args)
+    else
+      redde_text_field(name, *args)
+    end
+  end
+
+  def redde_select(name, choices, opts = {}, *args)
+    options = args.extract_options!
+    options[:class] = assign_class(['sel', 'redde-form__sel'], options[:class])
+    wrap(name, select(name, choices, opts, options.except(:wrap, :cell)), options)
+  end
+
+  def redde_date_time(name, *args)
+    options = args.extract_options!
+    content_tag :tr, class: options[:wrapper_class] do
+      content_tag(:td, smart_label(name), class: 'redde-form__cell _lbl') + content_tag(:td, datetime_select(name, options))
+    end
+  end
+
+  def redde_check_box(name, *args)
+    options = args.extract_options!
+    content_tag :tr, class: options[:wrapper_class] do
+      concat tag :td
+      concat content_tag :td, check_box(name, options) + " " + smart_label(name),  class: 'redde-form__cell'
+    end
+  end
+
+  def redde_text_field(name, *args)
+    options = args.extract_options!
+    options[:class] = assign_class(['inp', 'redde-form__inp'], options[:class])
+    wrap(name, text_field(name, options), options)
+  end
+
+  def redde_text_area(name, *args)
+    options = args.extract_options!
+    content_tag :tr, class: options[:wrapper_class] do
+      content_tag :td, colspan: 2 do
+        smart_label(name) + tag(:br) + text_area(name, options)
+      end
+    end
+  end
+
+  def redde_submit(text, opts)
+    css_class = ['sbm']
+    css_class << opts[:class] if opts[:class].present?
+    css_class << '_save' if text == 'Сохранить'
+    button(text, class: css_class, value: text, name: :commit)
+  end
+
+  def redde_submits *args, &block
+    content_tag :div, class: 'redde-form__actions' do
+      concat redde_submit('Сохранить', class: 'redde-form__sbm')
+      concat redde_submit('Применить', class: 'redde-form__sbm')
+      concat capture(&block) if block_given?
+    end
+  end
+
+  def error_messages(attrs = {})
+    if object.errors.full_messages.any?
+      render 'admin/redde/validate', { f: self, attrs: attrs }
+    end
+  end
+
+  def wrap(name = nil, *args, &block)
+    options = args.extract_options!
+    content = block_given? ? capture(&block) : args[0]
+    content_tag( :tr, content_tag( :td, smart_label(name), class: ['redde-form__cell', '_label', options[:cell]].flatten.compact ) + content_tag( :td, content, class: ['redde-form__cell', options[:cell]] ), class: ['redde-form__row', ('_error' if object.errors[name].any?), options[:wrap]].flatten.compact )
+  end
+
+  def fieldset(name, *args, &block)
+    options = args.extract_options!
+    content_tag(:tbody, class: options[:class]) do
+      concat content_tag(:tr, content_tag(:th, name, colspan: 2, class: 'redde-form__thead'))
+      concat capture(&block)
+    end
+  end
+
+  private
+
+  def assign_class(base, added)
+    base = [base] if base.is_a? String
+    if added.present?
+      base << added if added.is_a? String
+      base += added if added.is_a? Array
+    end
+    base
+  end
+
+  def smart_label(name)
+    required = object.class.validators_on(name).any? { |v| v.is_a? ActiveModel::Validations::PresenceValidator }
+    label(name, nil, class: ["redde-form__label",  ("_required" if required)])
+  end
+
+  def objectify_options(options)
+    super.except(:wrap, :cell)
+  end
+end

data/app/helpers/redde/admin_helper.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+module Redde::AdminHelper
+  def command_link(name, action, confirm = nil)
+    options = { method: :put }
+    options[:data] = { confirm: confirm } if confirm.present?
+    link_to name, admin_system_command_path(action), options
+  end
+
+  def sidebar_link(title, path = [], additional_names = [])
+    additional_names = [additional_names] unless additional_names.is_a?(Array)
+    active_names = additional_names + [path.try(:last) || '']
+    active_names.map!(&:to_s)
+    classes = ['sidebar__link']
+    classes << '_active' if active_names.include?(controller_name)
+    link_to title, path, class: classes
+  end
+
+  def photoable(parent)
+    render('admin/redde_photos/photos', parent: parent)
+  end
+
+  def tsingular(model)
+    model.model_name.human
+  end
+
+  def taccusative(model_name)
+    t("activerecord.models.#{model_name}.acc")
+  end
+
+  def tplural(model)
+    model.model_name.human(count: 'other')
+  end
+end

data/app/helpers/redde/form_helper.rb

@@ -0,0 +1,59 @@
+module Redde::FormHelper
+  # Override the default ActiveRecordHelper behaviour of wrapping the input.
+  # This gets taken care of semantically by adding an error class to the wrapper tag
+  # containing the input.
+  #
+  FIELD_ERROR_PROC = proc do |html_tag, instance_tag|
+    html_tag
+  end
+
+  def redde_form_for(object, options = {}, &block)
+    options = make_options(options)
+    options[:builder] ||= ReddeFormBuilder
+
+    with_clean_form_field_error_proc do
+      form_for(object, options) do |f|
+        concat f.error_messages
+        concat content_tag(:table, capture(f, &block), class: 'redde-form__tbl')
+        concat f.redde_submits
+      end
+    end
+
+  end
+
+  def redde_fields_for(record_name, record_object = nil, options = {}, &block)
+    options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
+    options[:builder] ||= ReddeFormBuilder
+
+    with_clean_form_field_error_proc do
+      fields_for(record_name, record_object, options, &block)
+    end
+  end
+
+  private
+
+  def make_options(options)
+    return options.merge(html: { class: 'redde-form' }) unless options.key?(:html)
+    unless options[:html].key?(:class)
+      options[:html][:class] = 'redde-form'
+      return options
+    end
+    if options[:html][:class].is_a? String
+      options[:html][:class] += ' redde-form'
+    elsif options[:html][:class].is_a? Array
+      options[:html][:class] << 'redde-form'
+    end
+    options
+  end
+
+  def with_clean_form_field_error_proc
+    default_field_error_proc = ::ActionView::Base.field_error_proc
+    begin
+      ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
+      yield
+    ensure
+      ::ActionView::Base.field_error_proc = default_field_error_proc
+    end
+  end
+
+end

data/app/helpers/redde/index_helper.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+module Redde::IndexHelper
+  IGNORED_COLUMNS = %w(ancestry position created_at updated_at id)
+  def title_for(item)
+    return item.title if column_names.include?('title')
+    return item.name if column_names.include('name')
+    model_name.columns.select { |i| i.type == :string }.first
+  end
+
+  def collection
+    controller_name
+  end
+
+  def record
+    controller_name.singularize
+  end
+
+  def model_name
+    record.camelize.constantize
+  end
+
+  def column_names
+    model_name
+      .column_names
+      .reject { |c| excluded_column_names.include?(c) }
+      .sort { |a, b| sort_priority(a) <=> sort_priority(b) }
+  end
+
+  def form_column_names
+    column_names.select { |i| !IGNORED_COLUMNS.include?(i) }
+  end
+
+  def sort_priority(column_name)
+    case column_name
+    when 'position' then 1
+    when 'visible' then 2
+    when 'name' then 3
+    when 'title' then 3
+    else 5
+    end
+  end
+
+  def excluded_column_names
+    %w(id created_at updated_at)
+  end
+
+  def list_table_options
+    {}.tap do |options|
+      if column_names.include? 'position'
+        options['class'] = 'sortable'
+        options['data-sortable'] = true
+      end
+    end
+  end
+
+  def sort_table_options(item)
+    {}.tap do |options|
+      options[:id] = "pos_#{item.id}" if column_names.include?('position')
+    end
+  end
+end

data/{lib/redde/concerns/layout.rb → app/models/concerns/redde/layouts.rb}

@@ -1,4 +1,4 @@
-module Redde::Layout
+module Redde::Layouts
   extend ActiveSupport::Concern
 
   included do

data/app/models/concerns/redde/photoable.rb

@@ -0,0 +1,5 @@
+module Redde::Photoable
+  extend ActiveSupport::Concern
+
+
+end

data/{lib/redde/concerns → app/models/concerns/redde}/sluggable.rb

@@ -1,10 +1,13 @@
-require 'redde/url_generator'
-
 module Redde::Sluggable
   extend ActiveSupport::Concern
 
   included do
-    validates :slug, format: { with: /\A[A-z0-9_-]*\z/i, message: 'имеет неверный формат, разрешены английские символы, знак подчеркивания "_" и дефис "-"'}, presence: true
+    validates :slug,
+              format: {
+                with: /\A[A-z0-9_-]*\z/i,
+                message: 'имеет неверный формат, разрешены английские символы, знак подчеркивания "_" и дефис "-"'
+              },
+              presence: true
     before_validation :set_slug
   end
 

data/app/models/concerns/redde/tree_sortable.rb

@@ -0,0 +1,40 @@
+module Redde::TreeSortable
+  def sort(list)
+    Sorter.new(list, self).sort
+  end
+
+  class Sorter
+    attr_accessor :list, :klass
+    def initialize(list, klass)
+      @list = list
+      @klass = klass
+    end
+
+    def sort
+      tree.each do |parent, cats|
+        i = 1
+        if parent == 'root'
+          pid = nil
+        else
+          pid = klass.find(parent).id
+        end
+        cats.each do |cat|
+          klass.find(cat).update(parent_id: pid, position: i)
+          i += 1
+        end
+      end
+    end
+
+    def tree
+      temp = {}
+      list.each do |key, value|
+        if temp[value]
+          temp[value] << key
+        else
+          temp[value] = [key]
+        end
+      end
+      temp
+    end
+  end
+end

data/{lib/redde/concerns → app/models/concerns/redde}/with_photo.rb

@@ -1,24 +1,24 @@
 module Redde::WithPhoto
   extend ActiveSupport::Concern
 
-  QUERY = 'imageable_id = :id AND imageable_type = :type OR token in (:tokens)'
+  QUERY = 'imageable_id = :id AND imageable_type = :type OR token in (:tokens)'.freeze
 
   included do
     attr_accessor :photo_tokens
-    has_many :photos, dependent: :destroy, as: :imageable
+    has_many :photos, class_name: 'Redde::Photo', dependent: :destroy, as: :imageable
     after_create :assign_photos
   end
 
   def all_photos
-    Photo.where(QUERY, id: self.id, type: self.class.name, tokens: tokens)
+    Redde::Photo.where(QUERY, id: id, type: self.class.name, tokens: tokens)
   end
 
   def assign_photos
-    Photo.where(token: tokens).update_all(imageable_attributes)
+    Redde::Photo.where(token: tokens).update_all(imageable_attributes)
   end
 
   def imageable_attributes
-    { imageable_id: self.id, imageable_type: self.class.name, token: nil }
+    { imageable_id: id, imageable_type: self.class.name, token: nil }
   end
 
   def tokens

data/app/models/redde/photo.rb

@@ -0,0 +1,16 @@
+class Redde::Photo < ActiveRecord::Base
+  mount_uploader :src, PhotoUploader
+  self.table_name = 'redde_photos'
+
+  belongs_to :imageable, polymorphic: true
+  default_scope { order(:position) }
+  before_save :set_token, unless: :persisted_link?
+
+  def set_token
+    self.token = SecureRandom.uuid unless token.present?
+  end
+
+  def persisted_link?
+    imageable_type.present? && imageable_id.present?
+  end
+end

data/app/models/redde/system_command.rb

@@ -0,0 +1,43 @@
+class Redde::SystemCommand
+  attr_accessor :action
+
+  ALLOWED_ACTIONS = %w(cache unicorn sidekiq reboot).freeze
+
+  def self.execute(action)
+    new(action).process
+  end
+
+  def initialize(action)
+    @action = action
+    Logger.new('log/commands.log').info "Received #{action} command"
+    fail "Unsopported command #{action}. Allowed commands: #{ALLOWED_ACTIONS.join(', ')}" unless ALLOWED_ACTIONS.include?(action.to_s)
+  end
+
+  def process
+    send(action)
+  end
+
+  private
+
+  def cache
+    `sudo service memcached restart`
+  end
+
+  def unicorn
+    `sudo service #{project_name} restart`
+  end
+
+  def sidekiq
+    system("sudo kill `cat #{Rails.root}/tmp/pids/sidekiq.pid` &&
+      cd #{Rails.root} &&
+      RAILS_ENV=#{Rails.env} bundle exec sidekiq -C config/sidekiq.yml -L log/sidekiq.log -d")
+  end
+
+  def reboot
+    `sudo reboot`
+  end
+
+  def project_name
+    Rails.root.to_s.gsub('/current', '').split('/').last
+  end
+end

data/{lib → app/models}/redde/url_generator.rb

@@ -11,9 +11,13 @@ class Redde::UrlGenerator
   end
 
   def translitted_name
-    Russian.translit(name).gsub(' ', '-')
-      .gsub(/[^\x00-\x7F]+/, '').gsub(/[^\w_ \-]+/i, '')
-      .gsub(/[ \-]+/i, '-').gsub(/^\-|\-$/i, '')
+    Russian
+      .translit(name)
+      .tr(' ', '-')
+      .gsub(/[^\x00-\x7F]+/, '')
+      .gsub(/[^\w_ \-]+/i, '')
+      .gsub(/[ \-]+/i, '-')
+      .gsub(/^\-|\-$/i, '')
   end
 
   def formatted_name

data/{lib/generators/redde/photo/templates/uploader.rb → app/uploaders/photo_uploader.rb}

@@ -1,8 +1,8 @@
+# encoding: utf-8
+
 class PhotoUploader < CarrierWave::Uploader::Base
   # Include RMagick or MiniMagick support:
-  include CarrierWave::RMagick
-  # include CarrierWave::MiniMagick
-
+  include CarrierWave::MiniMagick
   # Choose what kind of storage to use for this uploader:
   storage :file
   # storage :fog
@@ -44,7 +44,7 @@ class PhotoUploader < CarrierWave::Uploader::Base
   # end
 
   version :admin do
-    process resize_and_pad: [119, 119, :transparent, ::Magick::CenterGravity]
+    process resize_and_pad: [119, 119, :transparent]
   end
 
   # Override the filename of the uploaded files:

data/app/views/admin/base/_tree_item.html.haml

@@ -0,0 +1,10 @@
+%li.sort-tree__item(data-sort-tree-item){id: "list_#{item.id}"}
+  .sort-tree__wrap(data-sort-tree-tolerance)
+    = link_to title_for(item), [:edit, :admin, item], class: 'sort-tree__link'
+    - if item.is_childless?
+      = surround '(', ')' do
+        = link_to 'На сайт', '/', target: '_blank'
+    .sort-tree__controls
+      = link_to 'Удал', [:admin, item], class: 'a_del sort-tree__btn', data: { confirm: 'Точно удалить?' }, method: 'delete'
+  - if item.has_children?
+    %ol= render partial: 'tree_item', collection: item.children.order(:position), as: :item

data/app/views/admin/base/edit.html.haml

@@ -0,0 +1,21 @@
+- item = instance_variable_get("@#{record}")
+- content_for :page_header do
+  .page-header__title
+    - if item.new_record?
+      Добавить #{taccusative(record)}
+    - else
+      Редактировать #{taccusative(record)}
+  = link_to 'Назад', { action: :index }, class: 'btn page-header__btn'
+
+= photoable(item) if item.class.reflect_on_association(:photos)
+
+= redde_form_for [:admin, item] do |f|
+  - form_column_names.each do |column|
+    = f.redde_field column.to_sym
+  - if column_names.include?('ancestry')
+    = f.redde_select :parent_id, options_from_collection_for_select(f.object.class.all, :id, :title, f.object.parent_id), { include_blank: '- Выбрать -' }
+  -# %div= render 'redditor/admin/page', { f: f } if @article.methods.include?(:page)
+
+  -# проверить и написать правильное условие
+  -# f.object.class.reflect_on_association(:seo)
+  =# render 'admin/seos/block', { f: f } if f.object.methods.include?(:seo)