coalla-cms 0.5.1.9 → 0.6.0.9

data/app/helpers/twitter_builder_helper.rb

@@ -1,253 +0,0 @@
-#encoding: utf-8
-module TwitterBuilderHelper
-
-  ALIGN_CLASSES = {left: 't-left', center: 't-center', right: 't-right'}
-
-  class ColumnDefinition
-    attr_accessor :title, :cols, :col_class, :value_extractor, :align
-
-    def value(item, context = self)
-      self.value_extractor.call(item)
-    end
-
-  end
-
-  class ActionsColumnDefinition < ColumnDefinition
-
-    def initialize
-      self.title = I18n.t('admin.common.actions')
-      @actions = []
-    end
-
-    def cols
-      @cols || @actions.size % 2 + @actions.size / 2
-    end
-
-    def col_class
-      "col-xs-#{cols}"
-    end
-
-    def cols=(value)
-      @cols = value
-    end
-
-    def value(item, context = self)
-      @actions.collect do |action|
-        options = action.second
-        if options[:if]
-          context.instance_exec(item, &action.first) if options[:if].call(item)
-        else
-          context.instance_exec(item, &action.first)
-        end
-      end.compact.join(' ').html_safe
-    end
-
-    def action(method, options = {})
-      @actions << case method
-                    when :edit
-                      [->(item) { edit_link(send("edit_admin_#{item.class.name.underscore.sub('/', '_')}_path", item)) }, options]
-                    when :delete
-                      [->(item) { delete_link([:admin, item]) }, options]
-                    when Proc
-                      [method, options]
-                    else
-                      raise "unsupported method: #{method.inspect}"
-                  end
-    end
-
-  end
-
-  class TableBuilder
-
-    def initialize(parent, model_class)
-      @parent, @model_class = parent, model_class
-      @columns = []
-      @actions_column = ActionsColumnDefinition.new
-      @action_column_on_left = false
-      @table_helpers = TableHelpers.for(@model_class, @parent)
-    end
-
-    def content collection, &block
-      @collection = collection
-      block.call(self) if block_given?
-      create_content
-    end
-
-    # Метод добавляет столбец к таблице
-    def column(method, options = {})
-      helper = @table_helpers[method]
-      cd = ColumnDefinition.new
-      cd.title = options[:title] || I18n.t("activerecord.attributes.#{@model_class.model_name.singular}.#{method}")
-      cd.cols = options[:cols]
-      cd.col_class = options[:class]
-      cd.value_extractor = ->(item) { helper.format_value(item, options[:format]) }
-      cd.align = options[:align] || helper.respond_to?(:align) && "t-#{helper.align}"
-      @columns << cd
-    end
-
-    # Метод позволяет передать блок, который должен вычислять класс для строки. В этот блок передается объект,
-    # по которому данная строка рендерится. Таким образом, можно управлять, например, цветом строки в зависимости
-    # от состояния объекта (статусы заказов и прочее).
-    def row_class lmb
-      @row_class = lmb
-    end
-
-    # Метод добавляет кнопку в столбец действий
-    def action(value, options = {})
-      add_action(value, options)
-    end
-
-    # Метод добавляет кнопку редактирования сущности в столбец действий
-    def edit(options = {})
-      add_action(:edit, options)
-    end
-
-    # Метод добавляет кнопку удаления сущности в столбец действий
-    def delete(options = {})
-      add_action(:delete, options)
-    end
-
-    # Метод добавляет кнопки добавления и удаления сущностей в столбец действий
-    def edit_and_delete(options = {})
-      self.edit(options)
-      self.delete(options)
-    end
-
-    private
-
-    def add_action(value, options)
-      @action_column_on_left = true if @columns.empty?
-      @actions_column.action(value, options)
-    end
-
-    def all_columns
-      @action_column_on_left ? [@actions_column] + @columns : @columns + [@actions_column]
-    end
-
-    def create_content
-      @parent.render(partial: '/admin/common/table_template', locals: {definitions: all_columns, items: @collection, row_class: @row_class})
-    end
-  end
-
-  def twitter_form_for(name, *args, &block)
-    options = args.extract_options!
-    form_for(name, *(args << options.deep_merge(builder: TwitterFormBuilder, html: {class: 'form-horizontal'})), &block)
-  end
-
-  def field_set title = nil, &block
-    content = capture(self, &block)
-    content = content_tag(:legend, title) + content if title
-    content_tag :fieldset, content
-  end
-
-  def actions &block
-    content = capture(self, &block)
-    content_tag :div, content, class: 'well'
-  end
-
-  def standard_actions(form)
-    fixed_actions { form.save + form.apply + form.cancel }
-  end
-
-  def fixed_actions &block
-    panel_tag = actions(&block)
-    content_tag :div, panel_tag, class: 'action-bar'
-  end
-
-  def flash_warning_messages
-    r = if flash[:admin_warning]
-          "<div class='row'>
-            <div class='col-md-8 col-md-offset-2'>
-              <div class='alert alert-danger'>
-                <button data-dismiss='alert' class='close' type='button'>&times;</button>
-                <p>#{h(flash[:admin_warning])}</p>
-              </div>
-            </div>
-          </div>"
-        end
-    r && r.html_safe
-  end
-
-  def flash_alert_messages
-    r = if flash[:alert]
-          "<div class='row'>
-            <div class='col-md-8 col-md-offset-2'>
-              <div class='alert alert-danger'>
-                <button data-dismiss='alert' class='close' type='button'>&times;</button>
-                <p>#{h(flash[:alert])}</p>
-              </div>
-            </div>
-          </div>"
-        end
-    r && r.html_safe
-  end
-
-  def flash_success_messages
-    r = if flash[:admin_success]
-          "<div class='row'>
-            <div class='col-md-8 col-md-offset-2'>
-              <div class='alert alert-success'>
-                <button data-dismiss='alert' class='close' type='button'>&times;</button>
-                <p>#{h(flash[:admin_success])}</p>
-              </div>
-            </div>
-          </div>"
-        end
-    r && r.html_safe
-  end
-
-  def flash_messages
-    [flash_warning_messages, flash_success_messages].compact.join.html_safe
-  end
-
-  def create_link path
-    content = "<i class='glyphicon glyphicon-plus'></i>&nbsp;&nbsp;#{I18n.t('admin.common.new')}".html_safe
-    link_to content, path, class: 'btn btn-success'
-  end
-
-  def sort_link path
-    content = "<i class='glyphicon glyphicon-random'></i>&nbsp;&nbsp;#{I18n.t('admin.common.sort')}".html_safe
-    link_to content, path, class: 'btn btn-primary'
-  end
-
-  def edit_link path
-    content = "<i class='glyphicon glyphicon-pencil'></i>".html_safe
-    link_to content, path, class: 'btn btn-default btn-xs', title: I18n.t('admin.common.edit')
-  end
-
-  def delete_link path
-    content = "<i class='glyphicon glyphicon-trash'></i>".html_safe
-    link_to content, path, data: {confirm: I18n.t('admin.common.sure')}, method: :delete, class: 'btn btn-danger btn-xs', title: I18n.t('admin.common.delete')
-  end
-
-  def cancel_action path, name = I18n.t('admin.common.cancel')
-    link_to name, path, class: 'btn btn-default'
-  end
-
-  def back_action name = I18n.t('admin.common.return'), path = back_uri
-    link_to name, path, class: 'btn btn-default'
-  end
-
-  def table_for a_class
-    TableBuilder.new(self, a_class)
-  end
-
-  def th_class(column)
-    klass = []
-    klass << "col-xs-#{column.cols}" if column.cols
-    klass << ALIGN_CLASSES[column.align] if column.align
-    klass.join(' ')
-  end
-
-  def tr_class(row_class, item)
-    row_class && row_class.call(item)
-  end
-
-  def td_class(column)
-    klass = []
-    klass << column.col_class
-    klass << ALIGN_CLASSES[column.align] if column.align
-    klass.join(' ')
-  end
-
-end

data/app/helpers/twitter_form_builder.rb

@@ -1,202 +0,0 @@
-#encoding: utf-8
-class TwitterFormBuilder < ActionView::Helpers::FormBuilder
-  include ActionView::Helpers::FormTagHelper
-
-  COLS_CLASS = 'col-md-8'
-
-  def errors
-    return nil unless @object.errors.any?
-
-    messages = @object.errors.full_messages.collect do |msg|
-      "<p>#{ERB::Util.h(msg)}</p>".html_safe
-    end
-
-    content_tag(:div,
-                content_tag(:div,
-                            content_tag(:div,
-                                        content_tag(:button, '&times;'.html_safe, class: 'close', type: 'button', :'data-dismiss' => 'alert') + messages.join('').html_safe,
-                                        class: 'alert alert-danger'),
-                            class: 'col-md-8 col-md-offset-2'),
-                class: 'row')
-  end
-
-  def static_text(method, options = {})
-    row method, content_tag(:p, static_text_formatter.format(method), class: 'form-control-static'), options
-  end
-
-  # Displays multi-line static text in form
-  def static_memo_text(method, options = {})
-    row method, simple_format(@object.send(method), class: 'form-control-static'), options
-  end
-
-  def string method, options = {}
-    row method, text_field(method, with_default_options(options)), options
-  end
-
-  def combobox method, choices, options = {}, html_options = {}
-    row method, select(method, choices, options, with_default_options(html_options)), div_class: options.delete(:div_class) || 'col-md-6'
-  end
-
-  def enum(method, options = {}, html_options = {})
-    combobox method, object.class.send(method.to_s.pluralize).collect { |s| [s[0].humanize, s[0]] }, options, html_options
-  end
-
-  def enumerize(method, options = {}, html_options = {})
-    combobox method, object.class.send(method).values.collect { |s| [s.text, s] }, options, html_options
-  end
-
-  def list_all_combobox(association_name, options = {}, html_options = {})
-    collection_class = object.class.reflect_on_association(association_name).klass
-    combobox("#{association_name}_id", collection_class.all.sort_by(&:name).map { |element| [element.name, element.id] }, {include_blank: true}.merge(options), html_options)
-  end
-
-  def textarea method, options = {}
-    row method, text_area(method, with_default_options(options)), options
-  end
-
-  def checkbox method, options = {}
-    row method, content_tag(:div, check_box(method, options), class: 'checkbox'), options
-  end
-
-  def wysiwyg method, options = {}
-    textarea method, with_default_options(merge_classes(options, 'wymeditor'))
-  end
-
-  def ckeditor(method, options = {})
-    row method, cktext_area(method, with_default_options(options))
-  end
-
-  def password method, options = {}
-    row method, password_field(method, with_default_options(options)), options
-  end
-
-  def date method, options = {}
-    string(method, merge_options({data: {'calendar-date' => true}, div_class: 'col-md-2'}, options))
-  end
-
-  def datetime(method, options = {})
-    value = object.try(method).try(:strftime, '%Y-%m-%d %H:%M')
-    string(method, merge_options({data: {'calendar-datetime' => true}, div_class: 'col-md-3', value: value}, options))
-  end
-
-  def time(method, options = {})
-    value = object.try(method).try(:strftime, '%H:%M')
-    string(method, merge_options({data: {'calendar-time' => true}, div_class: 'col-md-2', value: value}, options))
-  end
-
-  def save text = I18n.t('admin.common.save')
-    submit text, name: :save, class: 'btn btn-success wymupdate'
-  end
-
-  def apply text = I18n.t('admin.common.apply')
-    submit text, name: :apply, class: 'btn btn-default wymupdate'
-  end
-
-  def cancel
-    @template.back_action
-  end
-
-  # Editing has_many collection
-  # parameters: association - name of has_many association
-  # association should be defined as accepts_nested_attributes with allow_destroy = true in model
-  # You should create partial with name #{association)_fields
-  def nested_fields_for(association)
-    @template.render 'admin/common/nested_fields_for', f: self, section_name: @object.class.human_attribute_name(association), collection: association
-  end
-
-  def image_upload method, options = {}
-    version = options[:version]
-
-    uri = if version.present?
-            @object.send("#{method}_url", version)
-          else
-            @object.send("#{method}_url")
-          end
-
-    if options[:size]
-      url = uri || 'placeholder'
-    else
-      url = uri
-    end
-
-    upload_uri = options[:upload_path]
-    unless upload_uri
-      upload_uri = @template.admin_upload_image_path(image_class: @object.class.name.underscore, field: method)
-    end
-    @template.render partial: '/admin/common/image_upload_template', locals: {
-        f: self, url: url, size: options[:size],
-        version: version || '',
-        title: options[:title] || '',
-        text: options[:text],
-        field: method, upload_uri: upload_uri,
-        container: options[:parent_id] || upload_container_id(method),
-        options: options.delete(:options) || {},
-        image_style: options.delete(:image_style) || ''
-    }
-  end
-
-  def file_upload method
-    @template.render partial: '/admin/common/file_upload_template', locals: {
-        f: self,
-        field: method
-    }
-  end
-
-  def multi_field(relation_name, options = {})
-    reflection = self.object.class.reflections[relation_name] || self.object.class.reflections[relation_name.to_s]
-    options = {search_field_name: :name,
-               show_all_on_focus: false,
-               use_cache: true,
-               relation_model_name: reflection.klass.model_name.singular}.merge!(options)
-    options[:source] ||= @template.admin_autocomplete_path(options[:relation_model_name], options[:search_field_name])
-    string "#{relation_name}_tokens", title: self.object.class.human_attribute_name(relation_name),
-           data: {
-               multi_field: true,
-               source: options[:source],
-               pre: self.object.send("#{relation_name}_json", options[:search_field_name]),
-               show_all_on_focus: options[:show_all_on_focus],
-               use_cache: options[:use_cache],
-               object_url_name: options[:object_url_name]}
-  end
-
-  def row(method, controls, options = {})
-    label_class = options[:label_class] || 'control-label col-md-4 col-lg-2'
-    label_tag = label(method, options[:title], class: label_class) unless options[:hide_label]
-    options[:div_class] ||= COLS_CLASS
-    div_tag = content_tag :div, controls.html_safe, class: options[:div_class]
-    content_tag :div, "#{label_tag}#{div_tag}".html_safe, class: 'form-group'
-  end
-
-  private
-
-  def upload_container_id(method)
-    fake_method = "#{method}_upload"
-    ActionView::Helpers::Tags::Base.new(@object_name, fake_method, @template).send(:tag_id)
-  end
-
-  def with_default_options(options)
-    merge_classes(options, 'form-control')
-    options
-  end
-
-  def merge_classes(options, *clazz)
-    classes = [options[:class]].compact
-    classes.push(*clazz)
-    options[:class] = classes.uniq.join(' ')
-    options
-  end
-
-  def merge_options(default_options, options)
-    return default_options if options.blank?
-    new_options = default_options.merge(options)
-    if default_options.has_key?(:data) && options.has_key?(:data)
-      new_options[:data] = default_options[:data].merge(options[:data])
-    end
-    new_options
-  end
-
-  def static_text_formatter
-    @static_text_formatter ||= StaticTextFormatter.new(@object)
-  end
-
-end

data/app/uploaders/file_uploader.rb

@@ -1,10 +0,0 @@
-class FileUploader < CarrierWave::Uploader::Base
-
-  storage :file
-
-  def store_dir
-    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
-  end
-
-
-end

data/app/uploaders/generic_image_uploader.rb

@@ -1,74 +0,0 @@
-#encoding: utf-8
-require 'carrierwave/processing/mime_types'
-require 'shellwords'
-
-# TODO Добавить настройку watermark_image, position
-
-class GenericImageUploader < CarrierWave::Uploader::Base
-  include CarrierWave::RMagick
-  include CarrierWave::MimeTypes
-
-  before :cache, :capture_size_before_cache
-
-  storage :file
-
-  process :set_content_type
-  process :set_image_properties
-
-  def watermark
-    return if !model || !model.respond_to?(getter(:watermarked?)) || !model.send(getter(:watermarked?))
-
-    manipulate! do |img|
-      logo = Magick::Image.read(Rails.root.join("app/assets/images/watermark.png")).first
-      img.composite(logo, Magick::SouthEastGravity, 0, 0, Magick::OverCompositeOp)
-    end
-  end
-
-  def store_dir
-    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
-  end
-
-  #def default_url
-  #  "/assets/fallback/" + [version_name, "default.png"].compact.join('_')
-  #end
-
-  def capture_size_before_cache(new_file)
-    return unless model
-    return unless new_file.path
-    if model.respond_to?(setter(:width)) && model.respond_to?(setter(:height))
-      w, h = `identify -format "%wx %h" #{new_file.path.shellescape}`.split(/x/).map { |dim| dim.to_i }
-      model.send(setter(:width), w)
-      model.send(setter(:height), h)
-    end
-  end
-
-  def set_image_properties
-    return if !model || !file
-
-    model.send(setter(:file_name), file.filename) if model.respond_to?(setter(:file_name))
-    model.send(setter(:size), file.size) if model.respond_to?(setter(:size))
-    model.send(setter(:content_type), file.content_type) if model.respond_to?(setter(:content_type))
-  end
-
-  private
-
-  def setter(name)
-    opt = model.class.uploader_options[mounted_as] || {}
-    if opt[:prefixed]
-      "#{mounted_as}_#{name}="
-    else
-      "#{name}="
-    end
-  end
-
-
-  def getter(name)
-    opt = model.class.uploader_options[mounted_as] || {}
-    if opt[:prefixed]
-      "#{mounted_as}_#{name}"
-    else
-      "#{name}"
-    end
-  end
-
-end

data/app/uploaders/meta_tags_image_uploader.rb

@@ -1,5 +0,0 @@
-class MetaTagsImageUploader < GenericImageUploader
-  version :main do
-    resize_to_limit 1024, 1024
-  end
-end

data/app/utils/admin_structure.rb

@@ -1,82 +0,0 @@
-#encoding: utf-8
-class AdminStructure
-
-  include Rails.application.routes.url_helpers
-
-  Section = Struct.new(:name, :path, :icon, :description, :counter, :show_menu_counter, :creation_path) do
-
-    def show_menu_counter?
-      show_menu_counter.present?
-    end
-
-  end
-
-  Separator = Struct.new(:title)
-
-  CONFIG_FILE_NAME = 'structure.rb'
-
-  attr_accessor :sections
-
-  def initialize(controller)
-    @controller = controller
-    @sections = []
-    load_sections_from_config
-  end
-
-  def menu_items
-    dashboard_item = Section.new(I18n.t('admin.common.dashboard'), admin_dashboard_path, 'glyphicon glyphicon-align-left')
-    [dashboard_item] + @sections
-  end
-
-  def sections
-    @sections.find_all { |section| section.is_a?(Section) }
-  end
-
-  private
-
-  def load_sections_from_config
-    config_path = Rails.root.join('config', CONFIG_FILE_NAME).to_s
-    if File.exist?(config_path)
-      instance_eval(File.read(config_path), config_path)
-    end
-  end
-
-  # Options:
-  # creation_path - false or path string
-  def section(section_reference, options = {})
-    path = options.delete(:path)
-    icon = options.delete(:icon)
-    description = options.delete(:description)
-    counter = options.delete(:counter)
-    show_menu_counter = options.delete(:show_menu_counter)
-    creation_path = options.delete(:creation_path)
-    if section_reference.is_a?(Class)
-      section_name = section_reference.model_name.human
-      path = send("admin_#{section_reference.model_name.route_key}_path") unless path
-      counter = ->() { section_reference.count } unless counter
-      creation_path = send("new_admin_#{section_reference.model_name.singular}_path") if creation_path.nil?
-    else
-      section_name = section_reference
-    end
-    @sections << Section.new(section_name, path, icon, description, counter, show_menu_counter, creation_path)
-  end
-
-  def lookup_section(section_references = 'Настройки', category = nil, options = {})
-    default_options = options.merge(path: send('admin_lookups_index_path', category: category),
-                                    icon: 'glyphicon glyphicon-wrench',
-                                    description: 'Раздел содержит различные настройки и тексты')
-    section(section_references, default_options)
-  end
-
-  def meta_tags_section(section_references = 'Мета-тэги', options = {})
-    default_options = options.merge(path: send('admin_meta_tags_path'),
-                                    icon: 'glyphicon glyphicon-tag',
-                                    description: 'Раздел содержит мета-тэги')
-    section(section_references, default_options)
-  end
-
-  def separator(title)
-    @sections << Separator.new(title)
-  end
-
-end

data/app/utils/bootstrap_link_renderer.rb

@@ -1,40 +0,0 @@
-class BootstrapLinkRenderer < WillPaginate::ActionView::LinkRenderer
-
-  protected
-
-  def html_container(html)
-    tag(:div, tag(:ul, html, class: 'pagination'), class: 't-center')
-  end
-
-  def page_number(page)
-    if page == current_page
-      tag(:li, tag(:a, page), class: 'active')
-    else
-      tag(:li, link(page, page, rel: rel_value(page)))
-    end
-  end
-
-  def gap
-    text = @template.will_paginate_translate(:page_gap) { '&hellip;' }
-    tag(:li, tag(:a, text), class: 'disabled')
-  end
-
-  def previous_page
-    num = @collection.current_page > 1 && @collection.current_page - 1
-    previous_or_next_page(num, @options[:previous_label])
-  end
-
-  def next_page
-    num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
-    previous_or_next_page(num, @options[:next_label])
-  end
-
-  def previous_or_next_page(page, text)
-    if page
-      tag(:li, link(text, page))
-    else
-      tag(:li, tag(:a, text), class: 'disabled')
-    end
-  end
-
-end