adminos 1.0.0.pre.rc.1

data/lib/adminos/generators/utilities.rb

@@ -0,0 +1,87 @@
+require 'adminos/generators/gemfile_merge'
+require 'bundler'
+require 'shellwords'
+
+module Adminos
+  module Generators
+    module Utilities
+      private
+
+      def indent_code(code, with: '  ')
+        code.split("\n").map { |line| line.present? ? "#{with}#{line}" : line }.join("\n")
+      end
+
+      def commit_changes(message)
+        git add: '.'
+        git commit: ['--message', message, '--author', 'Adminos Molinos <studio@molinos.ru>'].shelljoin
+      end
+
+      def run_in_root(command, with: nil, verbose: true, capture: nil, **options)
+        Bundler.with_clean_env do
+          ENV['DISABLE_SPRING'] = '1'
+          command << options_for_cli(options)
+          in_root { run(command, with: with, verbose: verbose, capture: capture) }
+        end
+      end
+
+      def options_for_cli(options)
+        options.inject('') do |command, (key, value)|
+          case value
+          when Array
+            command << " --#{key}=#{value.join(' ')}"
+          when TrueClass
+            command << " --#{key}"
+          when FalseClass
+            command << " --no-#{key}"
+          else
+            command << " --#{key}=#{value.to_s.shellescape}"
+          end
+        end
+      end
+
+      def replace_file(file_name, contents)
+        create_file(file_name, contents, force: true)
+      end
+
+      def merge_gemfile_with(source, target: Pathname.pwd.join('Gemfile'))
+        gemfile = IO.read(target || 'Gemfile')
+        addition = file_content(source)
+        gemfile = GemfileMerge.new(addition, gemfile).merge
+        replace_file target, gemfile if target
+        gemfile
+      end
+
+      def binstubs(*gem_names, **options)
+        run_in_root "bundle binstubs #{gem_names.shelljoin}", **options
+      end
+
+      #def generate(generator, *args, force: options.force?, quiet: options.quiet?)
+      #  run_in_root "bin/rails generate #{generator} #{args.map(&Shellwords.method(:escape)).join(' ')}", force: force, quiet: quiet
+      #end
+
+      def file_content(file)
+        IO.read(find_in_source_paths(file))
+      end
+
+      def file_exists?(file)
+        File.exist?(file)
+      end
+
+      def rubocop_target_ruby_version
+        RUBY_VERSION.split('.')[0..1].join('.')
+      end
+
+      def install_dependencies(verbose: !options.quiet?)
+        run_in_root 'bundle install', verbose: verbose
+        binstubs 'bundler', force: true, verbose: verbose
+      end
+
+      def migration_version
+        major = ActiveRecord::VERSION::MAJOR
+        if major >= 5
+          "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

data/lib/adminos/helpers/admin.rb

@@ -0,0 +1,190 @@
+module Adminos::Helpers::Admin
+  def admin_index_path(resource_class)
+    url_parts = [:admin, resource_class.name.pluralize.underscore]
+    url_parts << :index if ActiveModel::Naming.uncountable?(resource_class)
+    polymorphic_path(url_parts)
+  end
+
+  def top_menu_item(*args, &block)
+    options = args.extract_options!
+    opts = { value: args.first, block: (capture(&block) if block_given?) }.
+      merge(options)
+
+    render partial: 'shared/helpers/admin/top_menu_item', locals: opts
+  end
+
+  def admin_published_sign(*args)
+    options = args.extract_options!
+    render(partial: 'shared/helpers/admin/published_sign',
+            locals: { options: options })
+  end
+
+  def admin_unpublished_sign(*args)
+    options = args.extract_options!
+    render(partial: 'shared/helpers/admin/unpublished_sign',
+            locals: { options: options })
+  end
+
+  def admin_locked_sign(*args)
+    options = args.extract_options!
+    render(partial: 'shared/helpers/admin/locked_sign',
+            locals: { options: options })
+  end
+
+  def admin_nav_published_sign(*args)
+    options = args.extract_options!
+    render(partial: 'shared/helpers/admin/nav_published_sign',
+            locals: { options: options })
+  end
+
+  def collection_name
+    I18n.t("admin.#{collection.klass.name.underscore.pluralize}.actions.index.title")
+  end
+
+  def collection_title(*args)
+    options = args.extract_options!
+    label = args.first || options.delete(:label) || collection_name
+    title(label)
+  end
+
+  def collection_header(*args)
+    options = args.extract_options!
+    label = options.delete(:label) || I18n.t("admin.#{collection.klass.name.underscore.pluralize}.actions.index.header")
+    with_button_new = options.delete(:button_new)
+    with_button_new = true if with_button_new.blank? && with_button_new != false
+
+    render(partial: 'shared/helpers/admin/collection_header',
+            locals: { label: label, with_button_new: with_button_new })
+  end
+
+  def collection_button_new
+    parent_object = parent_resource rescue nil
+    record_or_hash_or_array = [:admin, parent_object, collection.klass.new].compact
+    url = polymorphic_path(record_or_hash_or_array,
+                            action: :new)
+
+    render(partial: 'shared/helpers/admin/collection_button_new',
+            locals: { url: url })
+  end
+
+  def object_link_new(object)
+    render(partial: 'shared/helpers/admin/object_link_new',
+            locals: { object: object })
+  end
+
+  def object_link_edit(object)
+    parent_object = parent_resource rescue nil
+    object = parent_object ? [:admin, parent_object, object] : [:admin, object]
+    render(partial: 'shared/helpers/admin/object_link_edit',
+            locals: { object: object })
+  end
+
+  def object_link_duplication(object)
+    parent_object = parent_resource rescue nil
+    object = parent_object ? [:admin, parent_object, object] : [:admin, object]
+    render(partial: 'shared/helpers/admin/object_link_duplication',
+            locals: { object: object })
+  end
+
+  def object_link_children(*args)
+    options = args.extract_options!
+    url = options.delete(:url)
+    render(partial: 'shared/helpers/admin/object_link_children',
+            locals: { url: url })
+  end
+
+  def resource_name(*args)
+    options = args.extract_options!
+    args << { primary_attribute: :name }.merge(options)
+    _resource_name(*args)
+  end
+
+  def resource_nav_name(*args)
+    options = args.extract_options!
+    args << { primary_attribute: :nav_name }.merge(options)
+    _resource_name(*args)
+  end
+
+  def _resource_name(*args)
+    options = args.extract_options!
+    primary_attribute = options.delete(:primary_attribute) || :name
+    name = (resource.respond_to?(primary_attribute) && resource.try(primary_attribute)) ||
+      (resource.respond_to?(:title) && resource.try(:title))
+    if name.present?
+      name
+    else
+      I18n.t("admin.#{resource.class.name.underscore.pluralize}.labels.actions.#{params[:action]}")
+    end
+  end
+
+  def resource_title
+    title(resource_name)
+  end
+
+  def resource_header(*args, &block)
+    options = args.extract_options!
+    text = args.first || options.delete(:text) || resource_name
+    admin_page_header(text, &block)
+  end
+
+  def resource_button_value_main
+    I18n.t("admin.#{resource.class.name.underscore.pluralize}.labels.actions.#{params[:action]}")
+  end
+
+  def resource_button_value_stay
+    I18n.t("admin.#{resource.class.name.underscore.pluralize}.labels.actions.#{params[:action]}_stay_in_place")
+  end
+
+  def resource_button_value_cancel
+    I18n.t('labels.admin.cancel')
+  end
+
+  def resource_form_object
+    parent_object = parent_resource rescue nil
+    if parent_object.present?
+      [:admin, parent_resource, resource]
+    else
+      [:admin, resource]
+    end
+  end
+
+  def admin_cb(object)
+    content_tag :label, class: 'f-check' do
+      concat(check_box_tag 'id_eq[]', object.id, false, id: "id_eq_#{object.id}")
+      concat(content_tag(:span, '', class: 'f-check__box'))
+    end
+  end
+
+  def batch_actions_tag(*args, &block)
+    options = args.extract_options!
+    with_destroy = options.delete(:with_destroy)
+    with_destroy = true if with_destroy.blank? && with_destroy != false
+    with_publication     = options.delete(:publication)
+    with_nav_publication = options.delete(:nav_publication)
+
+    render(partial: 'shared/helpers/admin/batch_actions_tag',
+            locals: {
+              block: (capture(&block) if block_given?),
+              with_destroy: with_destroy,
+              with_publication: with_publication,
+              with_nav_publication: with_nav_publication
+            })
+  end
+
+  def admin_page_header(*args, &block)
+    options = args.extract_options!
+    opts = { value: args.first, block: (capture(&block) if block_given?) }.
+      merge(opts: options)
+    render partial: 'shared/helpers/admin/page_header', locals: opts
+  end
+
+  def admin_sortable_column(column, label)
+    the_col   = params[:order_by] == column.to_s
+    current   = params[:direction] == 'asc' ? :asc : :desc
+    direction = the_col && current == :asc ? :desc : :asc
+    opts = params.merge(page: params[:page], search: params[:search], order_by: column, direction: direction)
+    opts.permit!
+
+    link_to(label, opts) + (tag(:i, class: "icon-chevron-#{current == :desc ? 'down' : 'up'}") if the_col)
+  end
+end

data/lib/adminos/helpers/bootstrap.rb

@@ -0,0 +1,64 @@
+module Adminos::Helpers::Bootstrap
+  def bs_btn(*args)
+    (['btn'] + args.map { |arg| BS_BTN_CLS.include?(arg.to_s) ? "btn-#{arg}" : arg }).join(' ')
+  end
+
+  def h_bs_btn(*args)
+    { class: bs_btn(*args) }
+  end
+
+  def bs_label(type, *args, &block)
+    options = args.extract_options!
+    bs_append_cls(options, 'label', type, BS_LABEL_CLS)
+    content_tag :span, *args, options, &block
+  end
+
+  def bs_badge(type, *args, &block)
+    options = args.extract_options!
+    bs_append_cls(options, 'badge', type, BS_BADGE_CLS)
+    content_tag :span, *args, options, &block
+  end
+
+  def bs_alert(type, *args, &block)
+    options = args.extract_options!
+
+    fade = 'fade in' if options.delete(:fade)
+    bs_append_cls(options, 'alert', type, BS_ALERT_CLS, fade)
+
+    if options[:close] || options[:close].nil?
+      close = options.delete(:close) || 'x'
+      close = %{<a class="close" data-dismiss="alert">#{close}</a>}
+    end
+
+    content = args.shift || capture(&block)
+
+    content_tag :div, "#{close}#{content}".html_safe, options
+  end
+
+  def bs_icon(type, *args)
+    options = args.extract_options!
+    css_class = options.delete(:class)
+    args << { class: "icon-#{type} #{css_class}" }.merge(options)
+    content_tag(:i, nil, *args)
+  end
+
+  def bs_icon_white(type, content = nil)
+    %{<i class="icon-white icon-#{type}"></i>#{content}}.html_safe
+  end
+
+  private
+
+  def bs_append_cls(options, default, type, classes, *args)
+    cls = args
+    cls << default
+    cls << ("#{default}-#{type}" if classes.include?(type.to_s))
+    cls << options[:class]
+    cls = cls.compact.join(' ')
+    options[:class] = cls
+  end
+
+  BS_BTN_CLS = %w(small large mini disabled primary info success warning danger inverse)
+  BS_LABEL_CLS = %w(success warning important info inverse)
+  BS_ALERT_CLS = %w(error success info)
+  BS_BADGE_CLS = %w(error success warning important info inverse)
+end

data/lib/adminos/helpers/models/apply_sortable_order.rb

@@ -0,0 +1,10 @@
+module Adminos::ApplySortableOrder
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def apply_sortable_order(id, *args)
+      options = args.extract_options!
+      self.where(options.merge(id: id)).order(position: :asc).update_all('position = FIND_IN_SET(id, ?)', id.join(','))
+    end
+  end
+end

data/lib/adminos/helpers/models/array_attrs.rb

@@ -0,0 +1,17 @@
+module Adminos::ArrayAttrs
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def array_attrs(*args)
+      options = args.extract_options!
+
+      args.each do |name|
+        define_method :"#{name}_to_a" do
+          value = send(name)
+          split = value.split("\n") || []
+          values = split.map { |value| value.strip }
+        end
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/cropped.rb

@@ -0,0 +1,20 @@
+module Adminos::Cropped
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def cropped(as_attribute, coord_attribute = nil)
+
+      define_method "#{as_attribute}_cropped" do
+        public_send(as_attribute).variant(combine_options: { crop: public_send("#{as_attribute}_cropped_coord") })
+      end
+
+      define_method "#{as_attribute}_attr_coord" do
+        coord_attribute || "#{as_attribute}_coord"
+      end
+
+      define_method "#{as_attribute}_cropped_coord" do
+        public_send(public_send("#{as_attribute}_attr_coord"))
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/dom_id.rb

@@ -0,0 +1,16 @@
+# <http://stackoverflow.com/questions/1183506/make-blank-params-nil#1186265>.
+module Adminos::DomId
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def with_dom_id(*args)
+      options = args.extract_options!
+      identifier_method = options.delete(:identifier_method) || :id
+
+      define_method :dom_id do
+        @dom_id ||= [ self.class.name.pathalize,
+                      self.send(identifier_method).to_s.gsub('-', '_') ].join('_')
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/flag_attrs.rb

@@ -0,0 +1,43 @@
+module Adminos::FlagAttrs
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def flag_attrs(*args)
+      options = args.extract_options!
+
+      on = args.delete(:on) || true
+      off = args.delete(:off) || false
+
+      args.each do |name|
+        define_method :"set_#{name}_on" do
+          update_attribute(name, on)
+        end
+
+        define_method :"set_#{name}_off" do
+          update_attribute(name, off)
+        end
+
+        (class << self; self; end).class_eval do
+          define_method :"set_#{name}_on" do
+            update_all(name => on)
+          end
+
+          define_method :"set_each_#{name}_on" do
+            all.each { |object| object.update_attribute(name, on) }
+          end
+
+          define_method :"set_#{name}_off" do
+            update_all(name => off)
+          end
+
+          define_method :"set_each_#{name}_off" do
+            all.each { |object| object.update_attribute(name, off) }
+          end
+        end
+
+        scope :"#{name}", -> { where(name => true) }
+        scope :"not_#{name}", -> { where(name => false) }
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/if_blank_set_to_nil_params.rb

@@ -0,0 +1,19 @@
+# <http://stackoverflow.com/questions/1183506/make-blank-params-nil#1186265>.
+module Adminos::IfBlankSetToNilParams
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def if_blank_set_to_nil_params(*args)
+      options = args.extract_options!
+      attrs = args.first
+      fail ArgumentError if attrs.blank?
+      attrs = [attrs] unless attrs.is_a?(Array)
+
+      before_validation do |object|
+        attrs.each do |attr_name|
+          object[attr_name] = nil if object[attr_name].blank?
+        end
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/move_to.rb

@@ -0,0 +1,17 @@
+module Adminos::MoveTo
+  def self.included(base)
+    base.class_eval do
+      sortable
+    end
+  end
+
+  def move_to(id)
+    if id.blank?
+      self.move_to_top!
+    else
+      to_position = self.class.where(id: id).pluck(:position).first
+      to_position += 1 if to_position < self.position
+      self.insert_at!(to_position)
+    end
+  end
+end

data/lib/adminos/helpers/models/nested_set/duplication.rb

@@ -0,0 +1,31 @@
+module Adminos::NestedSet::Duplication
+  extend ActiveSupport::Concern
+
+  # Метод клонирует объект. Добавляет в slug -сopy, т.к.  он уникален
+  # Далее объект сохранятеся в базе. Если объект в корне, то он туда и помещается
+  # Иначе объект помещается в нужного родителя
+  # Переопредели generated_slug в модели если хочешь свою логику
+  def duplication
+    cloned = self.dup
+    cloned.slug = generated_slug if cloned.respond_to?('slug=')
+    cloned.published = false if cloned.respond_to?('published=')
+    cloned.translations = self.translations.map(&:dup) if cloned.respond_to?('translations')
+
+    cloned.save
+    self.parent.children << cloned unless self.root?
+  end
+
+  private
+
+  def generated_slug
+    prefix =
+      if self.respond_to?(:translations)
+        self.class.with_translated_attribute(:name, reasonable_name, I18n.available_locales).size
+      else
+        self.class.where(name: reasonable_name).size
+      end
+
+    base_slug = self.class.find_by(slug: reasonable_name.parameterize).try(:slug)
+    base_slug.present? ? base_slug + prefix.to_s : reasonable_name.parameterize
+  end
+end

data/lib/adminos/helpers/models/nested_set/materialize_path.rb

@@ -0,0 +1,50 @@
+module Adminos::NestedSet::MaterializePath
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def materialize_path(*args)
+      options = args.extract_options!
+
+      prefix           = options.delete(:prefix) || nil
+      delimiter        = options.delete(:delimiter) || '/'
+      path_column      = options.delete(:path_column) || 'path'
+      segment_accessor = options.delete(:segment_accessor) || 'slug'
+
+      validates segment_accessor, presence: true
+      validate :path_column_uniqueness
+
+      define_method :path_column_uniqueness do
+        twins = self.class.where('id != ?', self.id).
+          where(path_column => self.ancestors.map do |ancestor|
+                                  ancestor[segment_accessor]
+                                end.push(self[segment_accessor]).join(delimiter))
+
+        errors.add(segment_accessor, :taken) if twins.present?
+      end
+
+      after_save do |object|
+        # Some scope is being added when turning published on/off
+        path_segments = object.class.unscoped do
+          object.self_and_ancestors.map { |obj| obj.send(segment_accessor) }
+        end
+        path_segments.unshift prefix if prefix
+        ancestors_path = path_segments.join(delimiter)
+
+        updates = {
+          object.id => ancestors_path
+        }
+
+        object.descendants.each do |descendant|
+          descendant.depth += 1 if prefix
+          path_segments[descendant.depth] = descendant.send(segment_accessor)
+          updates[descendant.id] = path_segments[0..descendant.depth].join(delimiter)
+        end
+
+        # No callbacks for descendatns
+        updates.each do |id, path|
+          self.class.where(id: id).update_all(path_column => path)
+        end
+      end
+    end
+  end
+end

data/lib/adminos/helpers/models/nested_set/place_to.rb

@@ -0,0 +1,35 @@
+module Adminos::NestedSet::PlaceTo
+  extend ActiveSupport::Concern
+
+  def place_to(*args)
+    options = args.extract_options!
+    parent_id = args.first  || options.delete(:parent_id)
+    prev_id   = args.second || options.delete(:prev_id)
+    opts = { place_first: true }.merge(options)
+    if parent_id.present?
+      parent = self.class.find(parent_id)
+      self.move_to_child_of(parent)
+    else
+      self.move_to_root
+    end
+
+    if prev_id.present?
+      prev = self.class.find(prev_id)
+      self.move_to_right_of(prev)
+    else
+      current_first = self.parent.present? ? self.parent.children.first : self.class.order('lft ASC').first
+      if opts[:place_first] && ((self.parent.present? && self.parent.children.count > 1) || !self.parent.present?)
+        self.move_to_left_of(current_first)
+      end
+    end
+    self.reload
+    run_callbacks(:save)
+  end
+
+  def move_children_to_parent!
+    self.children.each do |child|
+      child.place_to(self.parent, nil)
+      child.set_published_off if child.respond_to?(:set_published_off)
+    end
+  end
+end

data/lib/adminos/helpers/models/nested_set/safe_destroy.rb

@@ -0,0 +1,34 @@
+module Adminos::NestedSet::SafeDestroy
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def safe_destroy
+      order('depth DESC').each { |page| page.destroy }
+    end
+  end
+
+  def safe_destroy
+    self.move_children_to_root!
+    self.destroy
+  end
+
+  def safe_destroy(*args)
+    options = args.extract_options!
+
+    case options[:children_to]
+    when :parent
+      self.move_children_to_parent!
+    else
+      self.move_children_to_root!
+    end
+
+    self.destroy unless options[:without_destroy]
+  end
+
+  def move_children_to_root!
+    self.children.each do |child|
+      child.move_to_root
+      child.set_published_off if child.respond_to?(:set_published_off)
+    end
+  end
+end

data/lib/adminos/helpers/models/recognizable.rb

@@ -0,0 +1,28 @@
+module Adminos::Recognizable
+  def self.included(base)
+    base.extend ClassMethods
+    # base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def acts_as_recognizable(*args)
+      extend FriendlyId
+
+      options = args.extract_options!
+      sluggable_column = args.first || options.delete(:sluggable_column) || :name
+      slug_column = options.delete(:slug_column) || :slug
+
+      friendly_id sluggable_column, slug_column: slug_column, use: :slugged
+      validates slug_column, uniqueness: true
+
+      define_method :slug_friendly do
+        friendly_id
+      end
+
+      # friendly_id slugs transliteration <https://github.com/norman/babosa>.
+      define_method :normalize_friendly_id do |input|
+        input.to_s.to_slug.normalize(transliterations: :russian).normalize.to_s
+      end
+    end
+  end
+end