thecore_settings 1.1.15 → 2.0.2

data/lib/thecore_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/thecore_settings/dumper.rb

@@ -0,0 +1,12 @@
+module ThecoreSettings
+  module Dumper
+    def self.dump(path)
+      ns = {}
+      ThecoreSettings::Setting.each do |s|
+        ns[s.ns] = {} if ns[s.ns].nil?
+        ns[s.ns][s.key] = s.as_yaml
+      end
+      File.write(path, ns.to_yaml)
+    end
+  end
+end

data/lib/thecore_settings/engine.rb

@@ -1,10 +1,24 @@
 module ThecoreSettings
   class Engine < ::Rails::Engine
-    initializer "thecore_settings.add_to_migrations" do |app|
+    rake_tasks do
+      require File.expand_path('../tasks', __FILE__)
+    end
+
+    initializer 'ThecoreSettings.install_after_action' do |app|
+      require File.dirname(__FILE__) + '/../../app/models/thecore_settings/setting.rb'
+
+      if defined?(ActionController) and defined?(ActionController::Base)
+        ActionController::Base.class_eval do
+          after_action { Settings.unload! }
+        end
+      end
+    end
+
+    initializer 'ThecoreSettings.add_to_migrations' do |app|
       unless app.root.to_s.match root.to_s
         # APPEND TO MAIN APP MIGRATIONS FROM THIS GEM
-        config.paths["db/migrate"].expanded.each do |expanded_path|
-          app.config.paths["db/migrate"] << expanded_path
+        config.paths['db/migrate'].expanded.each do |expanded_path|
+          app.config.paths['db/migrate'] << expanded_path
         end
       end
     end

data/lib/thecore_settings/fallback.rb

@@ -0,0 +1,21 @@
+module ThecoreSettings
+  # we are inheriting from BasicObject so we don't get a bunch of methods from
+  # Kernel or Object
+  class Fallback < BasicObject
+    def initialize(ns, fb)
+      @ns = ns
+      @fb = fb
+    end
+
+    def inspect
+      "#<ThecoreSettings::Fallback ns: #{@ns.inspect}, fb: #{@fb.inspect}>"
+    end
+
+    def method_missing(*args)
+      @ns.ns_mutex.synchronize do
+        @ns.fallback = @fb
+        @ns.__send__(*args)
+      end
+    end
+  end
+end

data/lib/thecore_settings/hex_color_validator.rb

@@ -0,0 +1,11 @@
+module ThecoreSettings
+  class HexColorValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      record.errors[attribute] << (options[:message] || I18n.t('admin.settings.color_invalid')) unless value.blank? || self.class.matches?(value)
+    end
+    def self.matches?(value)
+      return false unless value
+      /^(?:[0-9a-f]{3})(?:[0-9a-f]{3})?$/i.match(value).nil? ? false : true
+    end
+  end
+end

data/lib/thecore_settings/kinds.rb

@@ -0,0 +1,34 @@
+module ThecoreSettings
+  def self.kinds
+    [
+      'string',
+      'text',
+      'integer',
+      'float',
+      'boolean',
+      'html',
+      'code',
+      'sanitized',
+      'yaml',
+      'phone',
+      'phones',
+      'email',
+      'address',
+      'file',
+      'image',
+      'url',
+      'domain',
+      'color',
+      'strip_tags',
+      'sanitize',
+      'sanitize_code',
+      'simple_format',
+      'simple_format_raw',
+      'json',
+    ]
+  end
+
+  def self.types
+    self.kinds
+  end
+end

data/lib/thecore_settings/mongoid.rb

@@ -0,0 +1,19 @@
+module ThecoreSettings
+  module Mongoid
+    extend ActiveSupport::Concern
+    included do
+      include ::Mongoid::Document
+      include ::Mongoid::Timestamps::Short
+
+      store_in collection: "thecore_settings"
+      field :enabled, type: ::Mongoid::VERSION.to_i < 4 ? Boolean : ::Mongoid::Boolean, default: true
+      field :kind, type: String, default: ThecoreSettings.types.first
+      field :ns, type: String, default: 'main'
+      field :key, type: String
+      field :raw, type: String
+      field :label, type: String
+      index({ns: 1, key: 1}, {unique: true, sparse: true})
+    end
+  end
+end
+

data/lib/thecore_settings/namespaced.rb

@@ -0,0 +1,210 @@
+module ThecoreSettings
+  # we are inheriting from BasicObject so we don't get a bunch of methods from
+  # Kernel or Object
+  class Namespaced < BasicObject
+    attr_accessor :settings, :fallback
+    attr_reader :loaded, :mutex, :ns_mutex, :name
+
+    def initialize(name)
+      self.settings = {}
+      @mutex = ::Mutex.new
+      @ns_mutex = ::Mutex.new
+      @loaded = false
+      @locked = false
+      @name = name
+    end
+
+    def nil?
+      false
+    end
+    def inspect
+      "#<ThecoreSettings::Namespaced name: #{@name.inspect}, fallback: #{@fallback.inspect}, loaded: #{@loaded}>"
+    end
+    def pretty_inspect
+      inspect
+    end
+
+    def load!
+      mutex.synchronize do
+        return if loaded
+        @loaded = true
+        @settings = {}
+        ::ThecoreSettings::Setting.ns(@name).each do |setting|
+          @settings[setting.key] = setting
+        end
+      end
+    end
+
+    def unload!
+      mutex.synchronize do
+        @loaded = false
+        @settings = {}
+      end
+    end
+
+    # returns setting object
+    def get(key, options = {})
+      load!
+      key = key.to_s
+      mutex.synchronize do
+        @locked = true
+        v = @settings[key]
+        if v.nil?
+          unless @fallback.nil? || @fallback == @name
+            v = ::Settings.ns(@fallback).getnc(key)
+          end
+          if v.nil?
+            v = set(key, options[:default], options)
+          end
+        end
+        @locked = false
+        v
+      end
+    end
+
+    # returns setting object
+    def getnc(key)
+      load!
+      mutex.synchronize do
+        self.settings[key]
+      end
+    end
+
+    def set(key, value = nil, options = {})
+      load! unless @locked
+      key = key.to_s
+      options.symbolize_keys!
+
+      if !options[:type].nil? && options[:type] == 'yaml' && !value.nil?
+        if value.class.name != 'String'
+          value = value.to_yaml
+        end
+      end
+
+      options.merge!(value: value)
+      if @locked
+        write_to_database(key, options)
+      else
+        mutex.synchronize do
+          write_to_database(key, options)
+        end
+      end
+    end
+
+    def enabled?(key, options = {})
+      get(key, options).enabled?
+    end
+
+    def []=(key, value)
+      set(key, value)
+    end
+    def [](key)
+      get(key)
+    end
+
+    def destroy!(key)
+      load!
+      key = key.to_s
+      mutex.synchronize do
+        ::ThecoreSettings::Setting.where(ns: @name, key: key).destroy_all
+        @settings.delete(key)
+      end
+    end
+
+    def destroy_all!
+      mutex.synchronize do
+        ::ThecoreSettings::Setting.where(ns: @name).destroy_all
+        @loaded = false
+        @settings = {}
+      end
+    end
+
+    # returns processed setting value
+    def method_missing(key, *args)
+      key = key.to_s
+      if key.end_with?('_enabled?')
+        key = key[0..-10]
+        v = get(key)
+        if v.nil?
+          set(key, '').enabled
+        else
+          v.enabled
+        end
+      elsif key.end_with?('_enabled=')
+        key = key[0..-10]
+        v = get(key)
+        if ::ThecoreSettings.mongoid?
+          if ::Mongoid::VERSION >= "4.0.0"
+            v.set(enabled: args.first)
+          else
+            v.set("enabled", args.first)
+          end
+        else
+          v.enabled = args.first
+          v.save!
+        end
+        v.enabled
+      elsif key.end_with?('=')
+        key = key[0..-2]
+        options = args[1] || {}
+        value = args.first
+        set(key, value, options).val
+      else
+        v = get(key, args.first || {})
+        if v.nil?
+          ''
+        else
+          v.val
+        end
+      end
+    end
+
+    def write_to_database(key, options)
+      is_file = !options[:kind].nil? && (options[:kind] == 'image' || options[:kind] == 'file')
+      if is_file
+        options[:raw] = ''
+        file = options[:value]
+      else
+        options[:raw] = options[:value]
+      end
+
+      options.delete(:value)
+      options.delete(:default)
+      options[:ns] = @name
+
+      if @settings[key].nil?
+        options.delete(:overwrite)
+        v = ::ThecoreSettings::Setting.create(options.merge(key: key))
+        if !v.persisted?
+          if v.errors[:key].any?
+            v = ::ThecoreSettings::Setting.where(key: key).first
+            if v.nil?
+              ::Kernel.raise ::ThecoreSettings::PersistenceException, 'Fatal: error in key and not in DB'
+            end
+          else
+            ::Kernel.raise ::ThecoreSettings::PersistenceException, v.errors.full_messages.join(',')
+          end
+        end
+        @settings[key] = v
+      else
+        opts = options.dup
+        if options[:overwrite] == false && !@settings[key].value.blank?
+          opts.delete(:raw)
+          opts.delete(:value)
+          opts.delete(:enabled)
+        end
+        opts.delete(:overwrite)
+        # Pre Rails 6.1 vs Post Rails 6.1
+        # In Rails 6.1 update_attributes has been deprecated
+        @settings[key].respond_to?('update_attributes!') ? @settings[key].update_attributes!(opts) : @settings[key].update!(opts)
+      end
+      if is_file
+        if options[:overwrite] != false || !@settings[key].file?
+          @settings[key].file = file
+          @settings[key].save!
+        end
+      end
+      @settings[key]
+    end
+  end
+end