vario 0.4.12

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e58ac2e2f8d599f2c079997d4a1aff97eab6f942d3defabf2be5e761fbd153c
+  data.tar.gz: 38b17c68f3d33f8c6244761249831457cb7c2e1d0659128b54bb65140ca82947
+SHA512:
+  metadata.gz: 18dac0cfad4d0e2d4dce4dc8cde21163fa068bb4f2f6c26db0eb87d040477f12eb8eb9a02716bab740a729ba0e300634994aef06512cf36a644b05f520059cf9
+  data.tar.gz: 4fbdb499f8cb06c0ccc1e419efe323e7ee1b538495822762aff7c10d1c94ca9bc3fe046676d3b9927c44e04b0363b3e48757b244226e59a8cf03a342195fd908

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Andre Meij
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Vario
+
+Vario allows configuration over multiple levels and tied to different objects. It is a simple and flexible way to configure your project.
+
+## Usage
+
+Add the vario.rb initializer to your project and configure it.
+Say your way to separate tenants is using an Account model, you would make 'Account' the settable and you can configure settings on it:
+
+```ruby
+Vario.setup do |config|
+  config.key :environment, name: 'Environment', type: :select, collection_proc: -> { [%w[Production production], %w[Test test], %w[Development development]] }, value_proc: -> { Rails.env }
+
+  config.for_settable_type 'Account' do |settable|
+    settable.raise_on_undefined true
+
+    settable.setting 'internationalization.default_currency', type: :string, default: 'USD', description: 'Default currency for new products.', collection_proc: -> { Money::Currency.map { |currency| ["#{currency.iso_code} - #{currency.name}", currency.iso_code] }.sort }
+    settable.setting 'internationalization.week_start', type: :symbol, default: :monday, description: 'First day of the week', collection: [['Monday', :monday], ['Tuesday', :tuesday], ['Wednesday', :wednesday], ['Thursday', :thursday], ['Friday', :friday], ['Saturday', :saturday], ['Sunday', :sunday]]
+  end
+end
+```
+
+Next add vario to your routes.rb:
+
+```ruby
+  mount Vario::Engine, at: "/settings", as: "vario"
+```
+
+Then add a menu entry, or link to the settings page:
+
+```ruby
+link_to("Settings", vario.settings_path(settable: Current&.account&.to_sgid(for: "Vario").to_s))
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vario'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install vario
+```
+
+## Contributing
+
+Contribution directions go here.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Vario'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+  t.warning = false
+end
+
+task default: :test
+
+# Adds the Auxilium semver task
+spec = Gem::Specification.find_by_name 'auxilium'
+load "#{spec.gem_dir}/lib/tasks/semver.rake"

data/app/controllers/vario/application_controller.rb

@@ -0,0 +1,15 @@
+module Vario
+  class ApplicationController < Vario.config.base_controller.constantize
+    protect_from_forgery with: :exception
+
+    layout Vario.config.admin_layout
+
+    def add_breadcrumbs(*args)
+      method(:add_breadcrumbs).super_method&.call(*args)
+    end
+
+    def breadcrumb_settings_path(setting, options  = {})
+      settings_path(options.merge(settable: setting.settable.to_sgid(for: 'Vario').to_s))
+    end
+  end
+end

data/app/controllers/vario/levels_controller.rb

@@ -0,0 +1,63 @@
+require_dependency 'vario/application_controller'
+
+module Vario
+  class LevelsController < ApplicationController
+    self.responder = Auxilium::Responder
+    respond_to :html, :js
+
+    before_action :set_objects
+
+    def create
+      @level = Level.new(@setting, level_params)
+      @setting.levels.unshift @level
+      @setting.save
+
+      respond_with @setting, collection_location: setting_path(@setting)
+    end
+
+    def update
+      if params[:commit] == 'delete'
+        self.action_name = 'destroy'
+        return destroy
+      end
+
+      @level = @setting.levels.find { |level| level.id == params[:id] }
+      @level.value = level_params[:value]
+      @level.conditions = level_params[:conditions].to_h
+      @setting.save
+
+      respond_with @setting, collection_location: setting_path(@setting)
+    end
+
+    def destroy
+      @setting.levels.reject! { |level| level.id == params[:id] }
+      @setting.save
+
+      respond_with @setting, collection_location: setting_path(@setting)
+    end
+
+    def move
+      oldIndex = @setting.levels.find_index { |level| level.id == params[:id] }
+      newIndex = params[:index]
+      @level = @setting.levels[oldIndex]
+      @level.move(oldIndex - newIndex)
+
+      render json: { old: oldIndex, new: newIndex }
+    end
+
+    private
+
+    def set_objects
+      @context = params.dig(:level, :context) || {}
+      @setting = Setting.find(params[:setting_id])
+      if respond_to? :add_breadcrumb
+        add_breadcrumb I18n.t('breadcrumbs.vario.settings.index'), breadcrumb_settings_path(@setting)
+        add_breadcrumb @setting.name, setting_path(@setting)
+      end
+    end
+
+    def level_params
+      params.require(:level).permit(:value, value: [], conditions: {}, context: {})
+    end
+  end
+end

data/app/controllers/vario/settings_controller.rb

@@ -0,0 +1,35 @@
+require_dependency 'vario/application_controller'
+
+module Vario
+  class SettingsController < ApplicationController
+    def index
+      if respond_to?(:add_breadcrumb)
+        add_breadcrumb I18n.t('breadcrumbs.vario.settings.index'), settings_path(settable: params[:settable])
+      end
+
+      @settable = GlobalID::Locator.locate_signed(params[:settable], for: 'Vario')
+      @title = 'Settings'
+      @title = "#{@title} for #{@settable.class.name} #{@settable.name}" if @settable.respond_to?(:name)
+      Vario.config.pre_create_settings(@settable)
+
+      @settings = Setting.where(settable: @settable).order(:name).includes(:settable)
+      @groups = @settings.map(&:name).select { |setting| setting =~ /\./ }.map { |setting| setting.split('.').first }
+      @groups = @groups.find_all { |g| Vario.config.show_group?(g) }
+      @groups = @groups.each_with_object(Hash.new(0)) { |v, h| h[v] += 1; }.map { |k, v| { name: k, settings: v } }
+    end
+
+    def show
+      @setting = Setting.find(params[:id])
+
+      if respond_to?(:add_breadcrumb)
+        add_breadcrumb I18n.t('breadcrumbs.vario.settings.index'), breadcrumb_settings_path(@setting)
+        add_breadcrumb @setting.name, setting_path(@setting)
+      end
+    end
+
+    def levels
+      @setting = Setting.find(params[:id])
+      render :levels, layout: false
+    end
+  end
+end

data/app/helpers/vario/application_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Vario
+  module ApplicationHelper
+    def method_missing(method, *args, &block)
+      if main_app.respond_to?(method)
+        main_app.send(method, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/app/jobs/vario/application_job.rb

@@ -0,0 +1,4 @@
+module Vario
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/vario/application_mailer.rb

@@ -0,0 +1,6 @@
+module Vario
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/vario/application_record.rb

@@ -0,0 +1,5 @@
+module Vario
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/vario/condition.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Vario
+  class Condition
+    include ActiveModel::Model
+    attr_accessor :key, :value
+
+    def initialize(setting, key, value)
+      @setting = setting
+      @key = key
+      @value = value
+    end
+
+    def human_value
+      if key_data[:type] == :select
+        collection.find { |entry| entry.last == value }.first
+      else
+        value
+      end
+    end
+
+    def key_data
+      Vario.config.key_data_for(key)
+    end
+
+    def collection
+      return @collection if @collection
+
+      @collection = key_data[:collection]
+      @collection ||= instance_exec(&key_data[:collection_proc]) if key_data[:collection_proc]
+      @collection ||= []
+      if value.present?
+        current_value = @collection.find { |entry| entry.last == value }
+        @collection << ["<#{value}>", value] unless current_value
+      end
+      @collection
+    end
+  end
+end

data/app/models/vario/level.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Vario
+  class Level
+    include ActiveModel::Model
+    attr_reader :conditions
+    attr_accessor :id, :setting, :value
+
+    def initialize(setting, level, new_record = false)
+      level = level.to_h.with_indifferent_access
+      @setting = setting
+      @id = level[:id] || SecureRandom.hex
+      @value = level[:value]
+      @new_record = new_record
+      self.conditions = level[:conditions]
+    end
+
+    def conditions=(new_conditions)
+      new_conditions = (new_conditions || {}).with_indifferent_access
+      @conditions = setting.keys.map do |key|
+        Condition.new(setting, key, new_conditions[key])
+      end
+    end
+
+    def conditions_for(context)
+      conditions.select { |condition| context.key?(condition.key.to_sym) }
+    end
+
+    def conditions_not_for(context)
+      conditions.reject { |condition| context.key?(condition.key.to_sym) }
+    end
+
+    def set_conditions
+      conditions.reject { |condition| condition.value.blank? }
+    end
+
+    def conditions_hash
+      set_conditions.map { |c| [c.key.to_sym, c.value] }.to_h
+    end
+
+    def with_context_values?(context)
+      context.each do |key, value|
+        condition = conditions.find { |condition| condition.key == key.to_s }
+        return false if condition.value != value
+      end
+
+      true
+    end
+
+    def move(positions)
+      if positions.positive?
+        move_up(positions)
+      else
+        move_down(positions.abs)
+      end
+    end
+
+    def move_up(positions = 1)
+      positions.times { |time| setting.move_level_up(self) }
+      setting.save!
+    end
+
+    def move_down(positions = 1)
+      positions.times { |time| setting.move_level_down(self) }
+      setting.save!
+    end
+
+    def human_value
+      hv = setting.human_value(value)
+      return unless hv
+      setting.type == :array ? hv.join(', ') : hv.to_s
+    end
+
+    def to_h
+      {
+        id: id,
+        conditions: conditions_hash,
+        value: value
+      }
+    end
+
+    def value_present?
+      value === false || value.present?
+    end
+
+    def default?
+      set_conditions.size.zero?
+    end
+
+    def persisted?
+      !@new_record
+    end
+  end
+end

data/app/models/vario/setting.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Vario
+  class Setting < ApplicationRecord
+    attr_reader :settable_setting, :type, :default, :description
+
+    has_paper_trail if respond_to?(:has_paper_trail)
+
+    belongs_to :settable, polymorphic: true, optional: true
+    validates :name, uniqueness: { scope: %i[settable_type settable_id] }
+    validate :validate_levels
+
+    after_initialize :configure, :levels # pre-init the levels
+    before_save :update_level_data
+
+    scope :for_group, ->(group_name) { where('name ilike ?', "#{group_name}.%") }
+    scope :without_group, -> { where.not('name ilike ?', "%.%") }
+
+    def group_name
+      return nil if name.blank?
+
+      parts = name.split('.', 2)
+
+      return nil if parts.size == 1
+
+      parts.first
+    end
+
+    def setting_name
+      return name if name.blank?
+
+      name.split('.', 2).last || name
+    end
+
+    def title
+      return "#{group_name.humanize}: #{setting_name.humanize}" if group_name.present?
+
+      setting_name.humanize if setting_name.present?
+    end
+
+    def value_for(context)
+      current_default = context.delete(:default)
+
+      unless initialized?
+        raise UnknownSetting, "Configuration key '#{name}' not initialized for #{settable_type}" if Vario.config.raise_on_undefined?(settable_type)
+        return current_default unless Vario.config.create_on_request?(settable_type)
+
+        # This is a new record, save it to the table since create_on_request? is true
+        self.keys = Vario.config.default_keys?(settable_type)
+        self.levels << Vario::Level.new(self, conditions: {}, value: current_default)
+      end
+
+      context = context.symbolize_keys
+      update_context(context)
+      validate_context(context)
+
+      result = levels.find do |level|
+        context >= level.conditions_hash
+      end
+
+      return parse_value(result.value) if result.present? && result.value_present?
+
+      parse_value(current_default || default)
+    end
+
+    def configure
+      self.keys ||= []
+
+      @settable_setting = Vario.config.settable_setting(settable_type, name)
+      return unless settable_setting
+
+      @type = settable_setting[:type]
+      self.keys = settable_setting[:keys]
+      @default = settable_setting[:default]
+      @description = settable_setting[:description]
+    end
+
+    def levels
+      @levels ||= (attributes['levels'] || []).map { |level| Level.new(self, level) }
+    end
+
+    def uniq_levels
+      selected = []
+
+      levels.each do |level|
+        next if selected.select { |uniq_level| uniq_level.conditions_hash == level.conditions_hash}.present?
+
+        selected << level
+      end
+
+      selected
+    end
+
+    def uniq_levels!
+      self.levels = uniq_levels.select { |l| l.value_present? }.map(&:to_h)
+      @levels = nil
+      save!
+    end
+
+    def update_level_data
+      self.levels = levels.select { |l| l.value_present? }.map(&:to_h)
+    end
+
+    def move_level_up(level)
+      index = levels.index(level)
+      level = levels.delete(level)
+      levels.insert(index - 1, level)
+    end
+
+    def move_level_down(level)
+      index = levels.index(level)
+      level = levels.delete(level)
+      levels.insert(index + 1, level)
+    end
+
+    def initialized?
+      return false if Vario.config.raise_on_undefined?(settable) && !persisted?
+      settable_setting.present? || persisted?
+    end
+
+    def parse_value(value)
+      return false if [0, '0', 'false', '', false].include?(value) && type == :boolean
+      return true if [1, '1', 'true', true].include?(value) && type == :boolean
+      return unless value.present?
+      return parse_value_array(value) if type == :array
+      return value unless value.is_a?(String)
+      return YAML.load(value) if type == :hash
+      return value.to_i if type == :integer
+
+      value
+    end
+
+    def human_value(value)
+      parsed_value = parse_value(value)
+      return parsed_value if collection.blank?
+      return parsed_value.map { |pv| collection.find { |i| i.last == pv }.first } if type == :array
+
+      collection.find { |i| i.last == parsed_value }.first
+    end
+
+    def parse_value_array(value)
+      values = value
+      values = values.split(/,|\n/).map(&:strip) if values.is_a?(String)
+      values = values.reject(&:blank?)
+
+      # If a collection has been defined, and 'all' is in the selected values, return all id's from the colletion
+      return collection.map(&:last) if (values.include?('all') || values.include?(:all)) && collection
+
+      values
+    end
+
+    def collection
+      return @collection if @collection
+      return unless settable_setting
+
+      @collection = settable_setting[:collection]
+      @collection ||= instance_exec(&settable_setting[:collection_proc]) if settable_setting[:collection_proc]
+      @collection ||= []
+      @collection
+    end
+
+    def new_level
+      Level.new(self, {}, true)
+    end
+
+    private
+
+    ###
+    # Fill blank values for which we've got a value_proc
+    #
+    def update_context(context)
+      keys.each do |key|
+        key = key.to_sym
+        key_data = Vario.config.key_data_for(key)
+        context[key] ||= instance_exec(&key_data[:value_proc]) if key_data.key?(:value_proc)
+      end
+    end
+
+    def validate_context(context)
+      missing = keys.map(&:to_sym) - context.keys
+      raise ArgumentError, "missing context '#{missing.join(', ')}''" if missing.present?
+    end
+
+    def validate_levels
+      errors.add(:levels, I18n.t('errors.messages.taken')) if levels.map(&:conditions_hash).uniq.size != levels.size
+    end
+  end
+end

data/app/views/vario/levels/_form.html.slim

@@ -0,0 +1,53 @@
+- label     = nil if label.blank?
+- context   = {} if context.blank?
+- draggable = true if draggable.nil?
+
+= sts.form_for([setting, level], id: level.id, url: polymorphic_path([vario, setting, level]), remote: true, title: label, footer: false, header: label.present?, padding: label.present?) do |f|
+  - context.each do |key, value|
+    = f.fields_for :context do |ff|
+      = ff.input key, as: :hidden, input_html: { value: value }
+  - level.conditions_for(context).each do |condition|
+    = f.fields_for :conditions do |ff|
+      = ff.input condition.key, as: :hidden, input_html: { value: context[condition.key.to_sym] }
+  .grid.grid-cols-12.gap-4
+    .col-span-1
+      - if draggable
+        button.draggable
+          i class="fal fa-grip-lines" style="margin-top: 8px; margin-left: 16px;"
+    .col-span-7
+      .grid.grid-cols-12.gap-4
+        - level.conditions_not_for(context).each do |condition|
+          div class="col-span-#{[12 / level.conditions_not_for(context).size, 3].max}"
+            = f.fields_for :conditions do |ff|
+              - case condition.key_data[:type]
+                - when :select
+                  = ff.input condition.key, as: :dropdown, label: condition.key, collection: condition.collection, include_blank: true, required: false, input_html: { id: "#{condition.key}_#{level.id}", value: condition.value }
+                - when :boolean
+                  = ff.input condition.key, as: :switch, label: condition.key, value: condition.value, required: false
+                - else
+                  = ff.input condition.key, label: condition.key, required: false, input_html: { value: context[condition.key.to_sym] }
+
+    .col-span-2
+      - case setting.type
+        - when :array
+          - if setting.collection.present?
+            = f.input :value, as: :select, input_html: { multiple: true, id: "value_#{level.id}" }, collection: [["All", 'all']] + setting.collection, required: false
+          - else
+            = f.input :value, as: :text, input_html: { rows: 10, style: 'height: auto' },  hint: 'Multiple values possible, separate with "," or new lines.'
+        - when :integer
+          = f.input :value, as: :number
+        - when :boolean
+          = f.input :value, as: :switch
+        - when :text
+          = f.input :value, as: :editor, mode: 'text/plain'
+        - when :hash
+          = f.input :value, as: :editor, mode: 'application/yaml'
+        - else
+          - if setting.collection.present?
+            = f.input :value, as: :dropdown, collection: setting.collection, required: false
+          - else
+            = f.input :value
+    .col-span-1.p-3
+      = f.button t('.save'), value: 'save'
+    .col-span-1.p-3
+      = f.button t('.delete'), value: 'delete' unless label.present?

data/app/views/vario/levels/create.js.erb

@@ -0,0 +1,4 @@
+<% if @setting.saved_changes? %>
+  document.querySelector("[data-id='<%= @setting.id %>_levels']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/levels', locals: { setting: @setting, context: @context })) %>"
+  document.querySelector("[data-id='<%= @setting.id %>_new_level']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/new_level', locals: { setting: @setting, context: @context })) %>"
+<% end %>

data/app/views/vario/levels/destroy.js.erb

@@ -0,0 +1,4 @@
+<% if @setting.saved_changes? %>
+  document.querySelector("[data-id='<%= @setting.id %>_levels']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/levels', locals: { setting: @setting, context: @context })) %>"
+  document.querySelector("[data-id='<%= @setting.id %>_new_level']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/new_level', locals: { setting: @setting, context: @context })) %>"
+<% end %>

data/app/views/vario/levels/update.js.erb

@@ -0,0 +1,4 @@
+<% if @setting.saved_changes? %>
+  document.querySelector("[data-id='<%= @setting.id %>_levels']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/levels', locals: { setting: @setting, context: @context })) %>"
+  document.querySelector("[data-id='<%= @setting.id %>_new_level']").innerHTML = "<%= escape_javascript(render(partial: 'vario/settings/new_level', locals: { setting: @setting, context: @context })) %>"
+<% end %>