avo 0.4.10 → 0.5.0.beta5

data/lib/avo/engine.rb

@@ -2,48 +2,31 @@
 Gem.loaded_specs['avo'].dependencies.each do |d|
   require d.name
 end
+require 'view_component/engine'
 
 module Avo
   class Engine < ::Rails::Engine
     isolate_namespace Avo
 
-    initializer 'avo.autoload', before: :set_autoload_paths do |app|
-      {
-        'Avo::Resources': ['app', 'avo', 'resources'],
-        'Avo::Filters': ['app', 'avo', 'filters'],
-        'Avo::Actions': ['app', 'avo', 'actions'],
-      }.each do |namespace, path|
-        next unless Rails.root.join(*path).exist?
-
-        Rails.autoloaders.main.push_dir(Rails.root.join(*path), namespace: namespace.to_s.safe_constantize)
-      end
+    config.after_initialize do
+      # Boot Avo
+      ::Avo::App.boot
     end
 
-    initializer 'avo.init' do |app|
-      avo_root_path = Avo::Engine.root.to_s
-
-      app.config.middleware.use I18n::JS::Middleware
-
-      if Avo::IN_DEVELOPMENT
-        # Register reloader
-        app.reloaders << app.config.file_watcher.new([], {
-          Avo::Engine.root.join('lib', 'avo').to_s => ['rb'],
-        }) {}
-
-        # What to do on file change
-        config.to_prepare do
-          Dir.glob(avo_root_path + '/lib/avo/app/**/*.rb'.to_s).each { |c| load c }
-        end
-      else
-        Dir.glob(avo_root_path + '/lib/avo/app/**/*.rb'.to_s).each { |c| require c }
+    initializer 'avo.autoload', before: :set_autoload_paths do |app|
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'filters'))
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'actions'))
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'resources'))
+    end
 
-        Avo::App.boot if Avo::PACKED
-      end
+    initializer 'avo.init_fields' do |app|
+      # Init the fields
+      ::Avo::App.init_fields
     end
 
     initializer 'webpacker.proxy' do |app|
       app.config.debug_exception_response_format = :api
-      app.config.logger = ::Logger.new(STDOUT)
+      # app.config.logger = ::Logger.new(STDOUT)
 
       insert_middleware = begin
                             Avo.webpacker.config.dev_server.present?
@@ -62,7 +45,8 @@ module Avo
 
     config.app_middleware.use(
       Rack::Static,
-      urls: ['/avo-packs'], root: Avo::Engine.root.join('public')
+      urls: ['/avo-packs'],
+      root: Avo::Engine.root.join('public')
     )
 
     config.generators do |g|

data/lib/avo/fields/badge_field.rb

@@ -0,0 +1,18 @@
+module Avo
+  module Fields
+    class BadgeField < BaseField
+      def initialize(name, **args, &block)
+        @defaults = {
+          partial_name: 'badge-field',
+        }
+
+        super(name, **args, &block)
+
+        hide_on [:edit, :new]
+
+        default_options = { info: :info, success: :success, danger: :danger, warning: :warning }
+        @meta[:options] = args[:options].present? ? default_options.merge(args[:options]) : default_options
+      end
+    end
+  end
+end

data/lib/avo/fields/base_field.rb

@@ -0,0 +1,184 @@
+module Avo
+  module Fields
+    class BaseField
+      extend ActiveSupport::DescendantsTracker
+      extend Avo::Fields::FieldExtensions::HasFieldName
+      include Avo::Fields::FieldExtensions::VisibleInDifferentViews
+
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :translation_key
+      attr_accessor :partial_name
+      attr_accessor :partial_path
+      attr_accessor :updatable
+      attr_accessor :sortable
+      attr_accessor :required
+      attr_accessor :readonly
+      attr_accessor :nullable
+      attr_accessor :null_values
+      attr_accessor :format_using
+      attr_accessor :computed # if block is present
+      attr_accessor :computable # if allowed to be computable
+      attr_accessor :computed_value # the value after computation
+      attr_accessor :block
+      attr_accessor :placeholder
+      attr_accessor :help
+      attr_accessor :default
+      attr_accessor :can_see
+      attr_accessor :model
+      attr_accessor :resource
+      attr_accessor :view
+      attr_accessor :user
+      attr_accessor :action
+      attr_accessor :meta
+      attr_accessor :panel_name
+      attr_accessor :link_to_resource
+
+      @meta = {}
+
+      def initialize(id, **args, &block)
+        super(id, **args, &block)
+        @defaults ||= {}
+
+        args = @defaults.merge(args).symbolize_keys
+
+        null_values = [nil, '', *args[:null_values]]
+        # The field properties as a hash {property: default_value}
+        @field_properties = {
+          id: id,
+          name: id.to_s.humanize(keep_id_suffix: true),
+          translation_key: nil,
+          block: block,
+          partial_name: 'field',
+          required: false,
+          readonly: false,
+          updatable: true,
+          sortable: false,
+          nullable: false,
+          null_values: null_values,
+          computable: true,
+          computed: block.present?,
+          computed_value: false,
+          format_using: false,
+          placeholder: id.to_s.humanize,
+          help: nil,
+          default: nil,
+          can_see: nil,
+          meta: {},
+          panel_name: nil,
+        }
+
+        # Set the values in the following order
+        # - app defaults
+        # - field defaults
+        # - field option
+        @field_properties.each do |name, default_value|
+          final_value = args[name.to_sym]
+          self.send("#{name}=", name != 'null_values' && (final_value.nil? || !defined?(final_value)) ? default_value : final_value)
+        end
+
+        # Set the visibility
+        show_on args[:show_on] if args[:show_on].present?
+        hide_on args[:hide_on] if args[:hide_on].present?
+        only_on args[:only_on] if args[:only_on].present?
+        except_on args[:except_on] if args[:except_on].present?
+
+        if args[:use_partials].present?
+          @custom_partials = args[:use_partials]
+        end
+      end
+
+      def hydrate(model: nil, resource: nil, action: nil, view: nil, panel_name: nil, user: nil)
+        @model = model if model.present?
+        @view = view if view.present?
+        @resource = resource if resource.present?
+        @action = action if action.present?
+        @user = user if user.present?
+        @panel_name = panel_name if panel_name.present?
+
+        self
+      end
+
+      def value
+        # Get model value
+        value = @model.send(id) if model_or_class(@model) == 'model' and @model.respond_to? id
+
+        if @view === :new or @action.present?
+          if default.present? and default.respond_to? :call
+            value = default.call @model, @resource, @view, self
+          else
+            value = default
+          end
+        end
+
+        # Run callback block if present
+        if computable and block.present?
+          value = block.call @model, @resource, @view, self
+        end
+
+        # Run the value through resolver if present
+        value = @format_using.call value if @format_using.present?
+
+        value
+      end
+
+      def fill_field(model, key, value)
+        return model unless model.methods.include? key.to_sym
+
+        model.send("#{key}=", value)
+
+        model
+      end
+
+      def partial_path_for(view)
+        return @custom_partials[view] if @custom_partials.present? and @custom_partials[view].present?
+
+        "avo/fields/#{view}/#{partial_name}"
+      end
+
+      # Try to see if the field has a different database ID than it's name
+      def database_id(model)
+        begin
+          foreign_key
+        rescue => exception
+          id
+        end
+      end
+
+      def has_own_panel?
+        false
+      end
+
+      def resolve_attribute(value)
+        value
+      end
+
+      def to_permitted_param
+        id.to_sym
+      end
+
+      def component_name(view = :index)
+        "Avo::#{view.to_s.classify}::Fields::#{partial_name.gsub('-field', '').underscore.camelize}FieldComponent"
+      end
+
+      def model_errors
+        return {} if model.nil?
+
+        model.errors
+      end
+
+      def type
+        self.class.name.demodulize.to_s.underscore
+      end
+
+      private
+        def model_or_class(model)
+          if model.class == String
+            'class'
+          else
+            'model'
+          end
+        end
+    end
+  end
+end

data/lib/avo/fields/belongs_to_field.rb

@@ -0,0 +1,65 @@
+module Avo
+  module Fields
+    class BelongsToField < BaseField
+      def initialize(name, **args, &block)
+        @defaults = {
+          partial_name: 'belongs-to-field',
+          placeholder: I18n.t('avo.choose_an_option')
+        }
+
+        super(name, **args, &block)
+
+        @meta[:searchable] = args[:searchable] == true ? true : false
+        @meta[:relation_method] = name.to_s.parameterize.underscore
+      end
+
+      def options
+        target_resource.model_class.all.map do |model|
+          {
+            value: model.id,
+            label: model.send(target_resource.class.title)
+          }
+        end
+      end
+
+      def database_value
+        target_resource.id
+      end
+
+      def foreign_key
+        if @model.present?
+          if @model.class == Class
+            @model.reflections[@meta[:relation_method]].foreign_key
+          else
+            @model.class.reflections[@meta[:relation_method]].foreign_key
+          end
+        elsif @resource.present?
+          @resource.model_class.reflections[@meta[:relation_method]].foreign_key
+        end
+      end
+
+      def relation_model_class
+        @resource.model_class
+      end
+
+      def label
+        value.send(target_resource.class.title)
+      end
+
+      def to_permitted_param
+        foreign_key.to_sym
+      end
+
+      private
+        def target_resource
+          if @model._reflections[id.to_s].klass.present?
+            App.get_resource_by_model_name @model._reflections[id.to_s].klass.to_s
+          elsif @model._reflections[id.to_s].options[:class_name].present?
+            App.get_resource_by_model_name @model._reflections[id.to_s].options[:class_name]
+          else
+            App.get_resource_by_name id.to_s
+          end
+        end
+    end
+  end
+end

data/lib/avo/{app/fields → fields}/boolean_field.rb

@@ -1,10 +1,12 @@
 module Avo
   module Fields
-    class BooleanField < Field
+    class BooleanField < BaseField
+      attr_reader :true_value
+      attr_reader :false_value
+
       def initialize(name, **args, &block)
         @defaults = {
-          sortable: true,
-          component: 'boolean-field',
+          partial_name: 'boolean-field',
           computable: true,
         }
 
@@ -14,12 +16,8 @@ module Avo
         @false_value = args[:false_value].present? ? args[:false_value] : false
       end
 
-      def hydrate_field(fields, model, resource, view)
-        {
-          value: resolve_attribute(fields[:value]),
-          true_value: @true_value,
-          false_value: @false_value,
-        }
+      def value
+        resolve_attribute super
       end
 
       def resolve_attribute(value)
@@ -27,11 +25,11 @@ module Avo
       end
 
       def truthy_values
-        ['true', @true_value]
+        ['true', '1', @true_value]
       end
 
       def falsy_values
-        ['false', @false_value]
+        ['false', '0', @false_value]
       end
     end
   end

data/lib/avo/fields/boolean_group_field.rb

@@ -0,0 +1,40 @@
+module Avo
+  module Fields
+    class BooleanGroupField < BaseField
+      attr_reader :options
+
+      def initialize(name, **args, &block)
+        @defaults = {
+          partial_name: 'boolean-group-field',
+          computable: true,
+        }
+
+        super(name, **args, &block)
+
+        @options = args[:options].present? ? args[:options] : {}
+      end
+
+      def to_permitted_param
+        ["#{id}": [] ]
+      end
+
+      def fill_field(model, key, value)
+        new_value = {}
+
+        # Filter out the empty ("") value boolean group generates
+        value = value.filter do |arr_value|
+          arr_value.present?
+        end
+
+        # Cast values to booleans
+        options.each do |id, label|
+          new_value[id] = value.include? id.to_s
+        end
+
+        model[id] = new_value
+
+        model
+      end
+    end
+  end
+end

data/lib/avo/fields/code_field.rb

@@ -0,0 +1,29 @@
+module Avo
+  module Fields
+    class CodeField < BaseField
+      attr_reader :height
+      attr_reader :language
+      attr_reader :theme
+      attr_reader :tab_size
+      attr_reader :indent_with_tabs
+      attr_reader :line_wrapping
+
+      def initialize(name, **args, &block)
+        @defaults = {
+          partial_name: 'code-field',
+        }
+
+        hide_on :index
+
+        super(name, **args, &block)
+
+        @language = args[:language].present? ? args[:language].to_s : 'javascript'
+        @theme = args[:theme].present? ? args[:theme].to_s : 'material-darker'
+        @height = args[:height].present? ? args[:height].to_s : 'auto'
+        @tab_size = args[:tab_size].present? ? args[:tab_size] : 2
+        @indent_with_tabs = args[:indent_with_tabs].present? ? args[:indent_with_tabs] : false
+        @line_wrapping = args[:line_wrapping].present? ? args[:line_wrapping] : true
+      end
+    end
+  end
+end