rails_admin_settings 1.4.0 → 1.6.0

data/app/models/rails_admin_settings/setting.rb

@@ -7,7 +7,6 @@ end
 
 module RailsAdminSettings
   class Setting
-    #binding.pry
     if RailsAdminSettings.mongoid?
       include RailsAdminSettings::Mongoid
     end

data/app/views/rails_admin/main/_setting_value.html.haml

@@ -1,4 +1,4 @@
-- if ['string', 'integer', 'phone', 'email', 'address', 'url', 'domain'].include?(@object.type)
+- if ['string', 'integer', 'float', 'phone', 'email', 'address', 'url', 'domain'].include?(@object.type)
   = form.text_field :raw, :value => field.value
 - if @object.type == 'boolean'
   = form.check_box :raw, {:value => field.value}, 'true', 'false'
@@ -8,7 +8,6 @@
   = form.text_area :raw, :value => field.value, :rows => 10, :cols => 80
 - elsif @object.type == 'code' || @object.type == 'sanitize_code'
   :ruby
-    #binding.pry
     js_data = {
       csspath: asset_path('ckeditor/plugins/codemirror/css/codemirror.min.css'),
       jspath: asset_path('ckeditor/plugins/codemirror/js/codemirror.min.js'),

data/lib/generators/rails_admin_settings/templates/migration.rb

@@ -15,6 +15,9 @@ class CreateRailsAdminSettings < ActiveRecord::Migration[5.0]
         t.attachment :file
       elsif defined?(CarrierWave)
         t.string :file
+      elsif defined?(Shrine)
+        t.text :file_data
+
       end
       t.timestamps
     end

data/lib/rails_admin_settings.rb

@@ -6,6 +6,20 @@ module RailsAdminSettings
   end
   cattr_accessor :scrubber
 
+  class PersistenceException < Exception
+  end
+
+  autoload :Mongoid,           "rails_admin_settings/mongoid"
+  autoload :Fallback,          "rails_admin_settings/fallback"
+  autoload :Namespaced,        "rails_admin_settings/namespaced"
+  autoload :Processing,        "rails_admin_settings/processing"
+  autoload :Validation,        "rails_admin_settings/validation"
+  autoload :RequireHelpers,    "rails_admin_settings/require_helpers"
+  autoload :RailsAdminConfig,  "rails_admin_settings/rails_admin_config"
+  autoload :Uploads,           "rails_admin_settings/uploads"
+  autoload :HexColorValidator, "rails_admin_settings/hex_color_validator"
+  autoload :Dumper,            "rails_admin_settings/dumper"
+
   class << self
     def orm
       if defined?(::Mongoid)
@@ -22,55 +36,74 @@ module RailsAdminSettings
     def active_record?
       orm == :active_record
     end
-  end
-
-  class PersistenceException < Exception
-  end
-
-  autoload :Mongoid,           "rails_admin_settings/mongoid"
-  autoload :Fallback,          "rails_admin_settings/fallback"
-  autoload :Namespaced,        "rails_admin_settings/namespaced"
-  autoload :Processing,        "rails_admin_settings/processing"
-  autoload :Validation,        "rails_admin_settings/validation"
-  autoload :RequireHelpers,    "rails_admin_settings/require_helpers"
-  autoload :RailsAdminConfig,  "rails_admin_settings/rails_admin_config"
-  autoload :Uploads,           "rails_admin_settings/uploads"
-  autoload :HexColorValidator, "rails_admin_settings/hex_color_validator"
-  autoload :Dumper,            "rails_admin_settings/dumper"
 
-  def self.migrate!
-    if RailsAdminSettings.mongoid?
-      RailsAdminSettings::Setting.where(:ns.exists => false).update_all(ns: 'main')
-      RailsAdminSettings::Setting.all.each do |s|
-        s.kind = s.read_attribute(:type) if !s.read_attribute(:type).blank? && s.kind != s.read_attribute(:type)
-        s.save! if s.changed?
-        s.unset(:type)
-      end
-    else
-      if Settings.table_exists?
-        RailsAdminSettings::Setting.where("ns IS NULL").update_all(ns: 'main')
+    def apply_defaults!(file, verbose = false)
+      if File.file?(file)
+        puts "[settings] Loading from #{file}" if verbose
+        if defined?(Psych) && Psych.respond_to?(:safe_load)
+          yaml = Psych.safe_load(File.read(file))
+        else
+          yaml = YAML.load(File.read(file), safe: true)
+        end
+        yaml.each_pair do |namespace, vals|
+          process_defaults(namespace, vals, verbose)
+        end
       end
     end
-  end
-
-  def self.track_history!
-    return false unless Settings.table_exists?
 
-    if mongoid?
-      if ::Mongoid.const_defined?('History')
-        RailsAdminSettings::Setting.send(:include, ::Mongoid::History::Trackable)
-        RailsAdminSettings::Setting.send(:track_history, {track_create: true, track_destroy: true})
-      else
-        puts "[rails_admin_settings] WARN unable to track_history: Mongoid::History not loaded!"
+    def process_defaults(namespace, vals, verbose = false)
+      vals.symbolize_keys!
+      n = Settings.ns(namespace)
+      vals.each_pair do |key, val|
+        val.symbolize_keys!
+        if !val[:kind].nil? && (val[:kind] == 'file' || val[:kind] == 'image')
+          unless Settings.file_uploads_supported
+            raise PersistenceException, "Fatal: setting #{key} is #{val[:type]} but file upload engine is not detected"
+          end
+          value = File.open(Settings.root_file_path.join(val.delete(:value)))
+        else
+          value = val.delete(:value)
+        end
+        puts "#{key} - default '#{value}' current '#{Settings.get(key).raw}'" if verbose
+        n.set(key, value, val.merge(overwrite: false))
       end
-      if ::Mongoid.const_defined?('Userstamp')
-        RailsAdminSettings::Setting.send(:include, ::Mongoid::Userstamp)
+      n.unload!
+    end
+
+    def migrate!
+      if RailsAdminSettings.mongoid?
+        RailsAdminSettings::Setting.where(:ns.exists => false).update_all(ns: 'main')
+        RailsAdminSettings::Setting.all.each do |s|
+          s.kind = s.read_attribute(:type) if !s.read_attribute(:type).blank? && s.kind != s.read_attribute(:type)
+          s.save! if s.changed?
+          s.unset(:type)
+        end
       else
-        puts "[rails_admin_settings] WARN unable to track_history: Mongoid::Userstamp not loaded!"
+        if Settings.table_exists?
+          RailsAdminSettings::Setting.where("ns IS NULL").update_all(ns: 'main')
+        end
       end
-    elsif active_record?
-      if defined?(PaperTrail) && PaperTrail::Version.table_exists?
-        RailsAdminSettings::Setting.send(:has_paper_trail)
+    end
+
+    def track_history!
+      return false unless Settings.table_exists?
+
+      if mongoid?
+        if ::Mongoid.const_defined?('History')
+          RailsAdminSettings::Setting.send(:include, ::Mongoid::History::Trackable)
+          RailsAdminSettings::Setting.send(:track_history, {track_create: true, track_destroy: true})
+        else
+          puts "[rails_admin_settings] WARN unable to track_history: Mongoid::History not loaded!"
+        end
+        if ::Mongoid.const_defined?('Userstamp')
+          RailsAdminSettings::Setting.send(:include, ::Mongoid::Userstamp)
+        else
+          puts "[rails_admin_settings] WARN unable to track_history: Mongoid::Userstamp not loaded!"
+        end
+      elsif active_record?
+        if defined?(PaperTrail) && PaperTrail::Version.table_exists?
+          RailsAdminSettings::Setting.send(:has_paper_trail)
+        end
       end
     end
   end

data/lib/rails_admin_settings/determine_mime_type.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/determine_mime_type
+    module DetermineMimeType
+      LOG_SUBSCRIBER = -> (event) do
+        Shrine.logger.info "MIME Type (#{event.duration}ms) – #{{
+            io:       event[:io].class,
+            uploader: event[:uploader],
+        }.inspect}"
+      end
+
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:determine_mime_type] ||= { analyzer: :file, analyzer_options: {} }
+        uploader.opts[:determine_mime_type].merge!(opts)
+
+        # instrumentation plugin integration
+        uploader.subscribe(:mime_type, &log_subscriber) if uploader.respond_to?(:subscribe)
+      end
+
+      module ClassMethods
+        # Determines the MIME type of the IO object by calling the specified
+        # analyzer.
+        def determine_mime_type(io)
+          analyzer = opts[:determine_mime_type][:analyzer]
+
+          analyzer = mime_type_analyzer(analyzer) if analyzer.is_a?(Symbol)
+          args     = if analyzer.is_a?(Proc)
+                       [io, mime_type_analyzers].take(analyzer.arity.abs)
+                     else
+                       [io, opts[:determine_mime_type][:analyzer_options]]
+                     end
+
+          mime_type = instrument_mime_type(io) { analyzer.call(*args) }
+          io.rewind
+
+          mime_type
+        end
+        alias mime_type determine_mime_type
+
+        # Returns a hash of built-in MIME type analyzers, where keys are
+        # analyzer names and values are `#call`-able objects which accepts the
+        # IO object.
+        def mime_type_analyzers
+          @mime_type_analyzers ||= MimeTypeAnalyzer::SUPPORTED_TOOLS.inject({}) do |hash, tool|
+            hash.merge!(tool => mime_type_analyzer(tool))
+          end
+        end
+
+        # Returns callable mime type analyzer object.
+        def mime_type_analyzer(name)
+          MimeTypeAnalyzer.new(name)
+        end
+
+        private
+
+        # Sends a `mime_type.shrine` event for instrumentation plugin.
+        def instrument_mime_type(io, &block)
+          return yield unless respond_to?(:instrument)
+
+          instrument(:mime_type, io: io, &block)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Calls the configured MIME type analyzer.
+        def extract_mime_type(io)
+          self.class.determine_mime_type(io)
+        end
+      end
+
+      class MimeTypeAnalyzer
+        SUPPORTED_TOOLS = [:fastimage, :file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime, :content_type]
+        MAGIC_NUMBER    = 256 * 1024
+
+        def initialize(tool)
+          raise Error, "unknown mime type analyzer #{tool.inspect}, supported analyzers are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
+
+          @tool = tool
+        end
+
+        def call(io, options = {})
+          mime_type = send(:"extract_with_#{@tool}", io, options)
+          io.rewind
+
+          mime_type
+        end
+
+        private
+
+        def extract_with_file(io, options)
+          require "open3"
+
+          return nil if io.eof? # file command returns "application/x-empty" for empty files
+
+          Open3.popen3(*%W[file --mime-type --brief -]) do |stdin, stdout, stderr, thread|
+            begin
+              IO.copy_stream(io, stdin.binmode)
+            rescue Errno::EPIPE
+            end
+            stdin.close
+
+            status = thread.value
+
+            raise Error, "file command failed to spawn: #{stderr.read}" if status.nil?
+            raise Error, "file command failed: #{stderr.read}" unless status.success?
+
+            $stderr.print(stderr.read)
+
+            output = stdout.read.strip
+
+            raise Error, "file command failed: #{output}" if output.include?("cannot open")
+
+            output
+          end
+        rescue Errno::ENOENT
+          raise Error, "file command-line tool is not installed"
+        end
+
+        def extract_with_fastimage(io, options)
+          require "fastimage"
+
+          type = FastImage.type(io)
+          "image/#{type}" if type
+        end
+
+        def extract_with_filemagic(io, options)
+          require "filemagic"
+
+          return nil if io.eof? # FileMagic returns "application/x-empty" for empty files
+
+          FileMagic.open(FileMagic::MAGIC_MIME_TYPE) do |filemagic|
+            filemagic.buffer(io.read(MAGIC_NUMBER))
+          end
+        end
+
+        def extract_with_mimemagic(io, options)
+          require "mimemagic"
+
+          mime = MimeMagic.by_magic(io)
+          mime&.type
+        end
+
+        def extract_with_marcel(io, options)
+          require "marcel"
+
+          return nil if io.eof? # marcel returns "application/octet-stream" for empty files
+
+          filename = (options[:filename_fallback] ? extract_filename(io) : nil)
+          Marcel::MimeType.for(io, name: filename)
+        end
+
+        def extract_with_mime_types(io, options)
+          require "mime/types"
+
+          if filename = extract_filename(io)
+            mime_type = MIME::Types.of(filename).first
+            mime_type&.content_type
+          end
+        end
+
+        def extract_with_mini_mime(io, options)
+          require "mini_mime"
+
+          if filename = extract_filename(io)
+            info = MiniMime.lookup_by_filename(filename)
+            info&.content_type
+          end
+        end
+
+        def extract_with_content_type(io, options)
+          if io.respond_to?(:content_type) && io.content_type
+            io.content_type.split(";").first
+          end
+        end
+
+        def extract_filename(io)
+          if io.respond_to?(:original_filename)
+            io.original_filename
+          elsif io.respond_to?(:path)
+            File.basename(io.path)
+          end
+        end
+      end
+
+    end
+
+    register_plugin(:determine_mime_type, DetermineMimeType)
+  end
+end

data/lib/rails_admin_settings/kinds.rb

@@ -4,6 +4,7 @@ module RailsAdminSettings
       'string',
       'text',
       'integer',
+      'float',
       'boolean',
       'html',
       'code',

data/lib/rails_admin_settings/processing.rb

@@ -10,7 +10,7 @@ module RailsAdminSettings
     end
 
     def text_kind?
-      (RailsAdminSettings.kinds - ['phone', 'phones', 'integer', 'yaml', 'json', 'boolean']).include? kind
+      (RailsAdminSettings.kinds - ['phone', 'phones', 'integer', 'float', 'yaml', 'json', 'boolean']).include? kind
     end
 
     def upload_kind?
@@ -31,10 +31,14 @@ module RailsAdminSettings
 
     def value
       if upload_kind?
-        if file?
-          file.url
+        unless defined?(Shrine)
+          if file?
+            file.url
+          else
+            nil
+          end
         else
-          nil
+          file.url if file.present?
         end
       elsif raw.blank? || disabled?
         default_value
@@ -54,7 +58,8 @@ module RailsAdminSettings
     end
 
     def to_s
-      if yaml_kind? || json_kind? || phone_kind? || integer_kind?
+      if yaml_kind? || json_kind? || phone_kind? || integer_kind? || float_kind?
+
         raw
       else
         value
@@ -94,6 +99,8 @@ module RailsAdminSettings
         ''
       elsif integer_kind?
         0
+      elsif float_kind?
+        0
       elsif yaml_kind?
         nil
       elsif json_kind?
@@ -181,6 +188,8 @@ module RailsAdminSettings
         process_text
       elsif integer_kind?
         raw.to_i
+      elsif float_kind?
+        raw.to_f
       elsif yaml_kind?
         load_yaml
       elsif json_kind?

data/lib/rails_admin_settings/rails_admin_config.rb

@@ -4,7 +4,6 @@ module RailsAdminSettings
       if base.respond_to?(:rails_admin)
         base.rails_admin do
           navigation_label I18n.t('admin.settings.label')
-
           list do
             if Object.const_defined?('RailsAdminToggleable')
               field :enabled, :toggle
@@ -16,9 +15,9 @@ module RailsAdminSettings
             field :name
             field :raw do
               pretty_value do
-                if bindings[:object].file_kind?
+                if bindings[:object].file_kind? and !defined?(Shrine) and bindings[:object].to_path.present?
                   "<a href='#{CGI::escapeHTML(bindings[:object].file.url)}'>#{CGI::escapeHTML(bindings[:object].to_path)}</a>".html_safe
-                elsif bindings[:object].image_kind?
+                elsif bindings[:object].image_kind? and !defined?(Shrine) and !bindings[:object].file.nil?
                   "<a href='#{CGI::escapeHTML(bindings[:object].file.url)}'><img src='#{CGI::escapeHTML(bindings[:object].file.url)}' /></a>".html_safe
                 else
                   value

data/lib/rails_admin_settings/settings.rb

@@ -39,6 +39,8 @@ class Settings < BasicObject
 
     def table_exists?
       RailsAdminSettings.mongoid? || RailsAdminSettings::Setting.table_exists?
+    rescue ActiveRecord::NoDatabaseError
+      false
     end
 
     def unload!
@@ -64,32 +66,7 @@ class Settings < BasicObject
     end
 
     def apply_defaults!(file, verbose = false)
-      if File.file?(file)
-        puts "[settings] Loading from #{file}" if verbose
-        if defined?(Psych) && Psych.respond_to?(:safe_load)
-          yaml = Psych.safe_load(File.read(file))
-        else
-          yaml = YAML.load(File.read(file), safe: true)
-        end
-        yaml.each_pair do |namespace, vals|
-          vals.symbolize_keys!
-          n = ns(namespace)
-          vals.each_pair do |key, val|
-            val.symbolize_keys!
-            if !val[:kind].nil? && (val[:kind] == 'file' || val[:kind] == 'image')
-              unless @@file_uploads_supported
-                ::Kernel.raise ::RailsAdminSettings::PersistenceException, "Fatal: setting #{key} is #{val[:type]} but file upload engine is not detected"
-              end
-              value = File.open(root_file_path.join(val.delete(:value)))
-            else
-              value = val.delete(:value)
-            end
-            puts "#{key} - default '#{value}' current '#{Settings.get(key).raw}'" if verbose
-            n.set(key, value, val.merge(overwrite: false))
-          end
-          n.unload!
-        end
-      end
+      RailsAdminSettings.apply_defaults!(file, verbose)
     end
 
     def get(key, options = {})