avo 0.5.0.beta3 → 0.5.0.beta8

data/config/webpack/test.js

@@ -1,5 +1,5 @@
 process.env.NODE_ENV = process.env.NODE_ENV || 'development'
 
-const environment = require('./environment')
+const webpackConfig = require('./base')
 
-module.exports = environment.toWebpackConfig()
+module.exports = webpackConfig

data/config/webpacker.yml

@@ -1,82 +1,33 @@
 # Note: You must restart bin/webpack-dev-server for changes to take effect
 
 default: &default
-  source_path: app/frontend
-  source_entry_path: packs
+  source_path: app/packs
+  source_entry_path: entrypoints
   public_root_path: public
   cache_path: tmp/cache/webpacker
   check_yarn_integrity: false
   # use a different sub-folder name
   public_output_path: avo-packs
   webpack_compile_output: true
+  extract_css: true
 
   # Additional paths webpack should lookup modules
   # ['app/assets', 'engine/foo/app/assets']
-  resolved_paths: []
+  additional_paths_paths: []
 
   # Reload manifest.json on all requests so we reload latest compiled packs
   cache_manifest: false
 
-  # Extract and emit a css file
-  extract_css: true
-
-  static_assets_extensions:
-    - .jpg
-    - .jpeg
-    - .png
-    - .gif
-    - .tiff
-    - .ico
-    - .svg
-    - .eot
-    - .otf
-    - .ttf
-    - .woff
-    - .woff2
-
-  extensions:
-    - .ts
-    - .vue
-    - .mjs
-    - .js
-    - .sass
-    - .scss
-    - .css
-    - .module.sass
-    - .module.scss
-    - .module.css
-    - .png
-    - .svg
-    - .gif
-    - .jpeg
-    - .jpg
-
+# We override the development env. when packed.
+# Avo needs to be packed and compiled for when the dev uses it in his development env.
 development:
   <<: *default
-  compile: true
 
-  # Verifies that correct packages and versions are installed by inspecting package.json, yarn.lock, and node_modules
-  check_yarn_integrity: true
+  # Production depends on precompilation of packs prior to booting for performance.
+  compile: true
 
-  # Reference: https://webpack.js.org/configuration/dev-server/
-  dev_server:
-    https: false
-    host: localhost
-    port: 3039
-    public: localhost:3039
-    hmr: true
-    # Inline should be set to true if using HMR
-    inline: true
-    overlay: true
-    compress: true
-    disable_host_check: true
-    use_local_ip: false
-    quiet: false
-    headers:
-      'Access-Control-Allow-Origin': '*'
-    watch_options:
-      ignored: '**/node_modules/**'
-    env_prefix: "AVO_WEBPACKER_DEV_SERVER"
+  # Cache manifest.json for performance
+  cache_manifest: true
 
 test:
   <<: *default
@@ -92,8 +43,5 @@ production:
   # Production depends on precompilation of packs prior to booting for performance.
   compile: false
 
-  # Extract and emit a css file
-  extract_css: true
-
   # Cache manifest.json for performance
   cache_manifest: true

data/db/factories.rb

@@ -12,6 +12,7 @@ FactoryBot.define do
   factory :team do
     name { Faker::Company.name }
     description { Faker::Lorem.paragraph(sentence_count: 4) }
+    url { Faker::Internet.url }
   end
 
   factory :post do

data/lib/avo.rb

@@ -1,20 +1,9 @@
-require_relative 'avo/configuration'
+require 'zeitwerk'
 require_relative 'avo/version'
+require_relative 'avo/engine' if defined?(Rails)
 
-require_relative 'avo/app/fields/field'
-
-require_relative 'avo/app/action'
-
-require_relative 'avo/app/filter'
-require_relative 'avo/app/filters/boolean_filter'
-require_relative 'avo/app/filters/select_filter'
-
-require_relative 'avo/app/fields_loader'
-require_relative 'avo/app/actions_loader'
-# require_relative 'avo/app/fields_loader_helper'
-require_relative 'avo/app/resource'
-
-require_relative 'avo/app/licensing/license_manager'
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
 module Avo
   ROOT_PATH = Pathname.new(File.join(__dir__, '..'))
@@ -31,4 +20,4 @@ module Avo
   end
 end
 
-require_relative 'avo/engine' if defined?(Rails)
+loader.eager_load

data/lib/avo/action_model.rb

@@ -0,0 +1,20 @@
+module Avo
+  class ActionModel
+    include ActiveModel::Model
+
+    # This class augments a model the action form declaration.
+    def initialize(attributes = {})
+      set_attr_accessors attributes
+
+      super(attributes)
+    end
+
+    private
+
+    def set_attr_accessors(attributes)
+      attributes.each do |k, v|
+        self.class.class_eval { attr_accessor k }
+      end
+    end
+  end
+end

data/lib/avo/app.rb

@@ -0,0 +1,162 @@
+module Avo
+  class App
+    class_attribute :app, default: {
+      resources: [],
+      cache_store: nil
+    }
+    class_attribute :fields, default: []
+    class_attribute :request, default: nil
+    class_attribute :context, default: nil
+    class_attribute :license, default: nil
+
+    class << self
+      def boot
+        init_fields
+
+        I18n.locale = Avo.configuration.language_code
+
+        if Rails.cache.class == ActiveSupport::Cache::NullStore
+          self.app[:cache_store] ||= ActiveSupport::Cache::MemoryStore.new
+        else
+          self.app[:cache_store] = Rails.cache
+        end
+      end
+
+      def init(request:, context:)
+        self.request = request
+        self.context = context
+
+        # Set the current host for ActiveStorage
+        ActiveStorage::Current.host = request.base_url
+
+        init_resources
+
+        self.license = Licensing::LicenseManager.new(Licensing::HQ.new(request).response).license
+      end
+
+      def cache_store
+        self.app[:cache_store]
+      end
+
+      # This method will find all fields available in the Avo::Fields namespace and add them to the fields class_variable array
+      # so later we can instantiate them on our resources.
+      #
+      # If the field has their `def_method` set up it will follow that convention, if not it will snake_case the name:
+      #
+      # Avo::Fields::TextField -> text
+      # Avo::Fields::DateTimeField -> date_time
+      def init_fields
+        Avo::Fields::BaseField.descendants.each do |class_name|
+          next if class_name.to_s == 'BaseField'
+
+          if class_name.to_s.end_with? 'Field'
+            load_field class_name.get_field_name, class_name
+          end
+        end
+      end
+
+      def load_field(method_name, klass)
+        self.fields.push(
+          name: method_name,
+          class: klass,
+        )
+      end
+
+      def init_resources
+        self.app[:resources] = BaseResource.descendants
+          .select do |resource|
+            resource != BaseResource
+          end
+          .map do |resource|
+            if resource.is_a? Class
+              resource.new
+            end
+          end
+      end
+
+      def get_resources
+        self.app[:resources]
+      end
+
+      # Returns the Avo resource by camelized name
+      #
+      # get_resource_by_name('User') => UserResource
+      def get_resource(resource)
+        self.app[:resources].find do |available_resource|
+          "#{resource}Resource".safe_constantize == available_resource.class
+        end
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_name('user') => UserResource
+      def get_resource_by_name(name)
+        self.get_resource name.singularize.camelize
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_name('User') => UserResource
+      # get_resource_by_name(User) => UserResource
+      def get_resource_by_model_name(name)
+        get_resources.find do |resource|
+          resource.model_class.model_name.name == name.to_s
+        end
+      end
+
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_controller_name('delayed_backend_active_record_jobs') => DelayedJobResource
+      # get_resource_by_controller_name('users') => UserResource
+      def get_resource_by_controller_name(name)
+        get_resources.find do |resource|
+          resource.model_class.to_s.pluralize.underscore.gsub('/', '_') == name.to_s
+        end
+      end
+
+      # Returns the Rails model class by singular snake_cased name
+      #
+      # get_model_class_by_name('user') => User
+      def get_model_class_by_name(name)
+        name.to_s.camelize.singularize
+      end
+
+      def get_available_resources(user = nil)
+        App.get_resources
+          .select do |resource|
+            Services::AuthorizationService.authorize user, resource.model, Avo.configuration.authorization_methods.stringify_keys['index'], raise_exception: false
+          end
+          .sort_by { |r| r.name }
+      end
+
+      def get_navigation_items(user = nil)
+        get_available_resources(user).select do |resource|
+          resource.model_class.present?
+        end
+      end
+
+      def draw_routes
+        # We should eager load all the classes so we find all descendants
+        Rails.application.eager_load!
+
+        Proc.new do
+          BaseResource.descendants
+            .select do |resource|
+              resource != :BaseResource
+            end
+            .map do |resource|
+              if resource.is_a? Class
+                if resource.model_class.present?
+                  route_key = resource.model_class.model_name.route_key
+                else
+                  route_key = resource.to_s.underscore.gsub('_resource', '').downcase.pluralize.to_sym
+                end
+
+                resources route_key
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/avo/base_action.rb

@@ -0,0 +1,126 @@
+module Avo
+  class BaseAction
+    extend FieldsCollector
+    extend HasContext
+
+    class_attribute :name, default: self.class.to_s.demodulize.underscore.humanize(keep_id_suffix: true)
+    class_attribute :message
+    class_attribute :confirm_button_label
+    class_attribute :cancel_button_label
+    class_attribute :no_confirmation, default: false
+    class_attribute :model
+    class_attribute :view
+    class_attribute :user
+    class_attribute :resource
+    class_attribute :fields
+
+    attr_accessor :response
+    attr_accessor :model
+    attr_accessor :resource
+    attr_accessor :user
+    attr_accessor :fields_loader
+
+    def initialize(model: nil, resource: nil, user: nil)
+      self.class.model = model if model.present?
+      self.class.resource = resource if resource.present?
+      self.class.user = user if user.present?
+
+      self.class.message ||= I18n.t('avo.are_you_sure_you_want_to_run_this_option')
+      self.class.confirm_button_label ||= I18n.t('avo.run')
+      self.class.cancel_button_label ||= I18n.t('avo.cancel')
+
+      @response ||= {}
+      @response[:message_type] ||= :notice
+      @response[:message] ||= I18n.t('avo.action_ran_successfully')
+    end
+
+    def context
+      self.class.context
+    end
+
+    def get_field_definitions
+      return [] if self.class.fields.blank?
+
+      self.class.fields.map do |field|
+        field.hydrate(action: self)
+      end
+    end
+
+    def get_fields
+      get_field_definitions.map do |field|
+        field.hydrate(action: self, model: @model)
+      end
+      .select do |field|
+        field.visible?
+      end
+    end
+
+    def get_attributes_for_action
+      get_fields.map do |field|
+        [field.id, field.value]
+      end
+      .to_h
+    end
+
+    def handle_action(models:, fields:)
+      avo_fields = get_fields.map { |field| [field.id, field] }.to_h
+
+      if fields.present?
+        processed_fields = fields.to_unsafe_h.map do |name, value|
+          [name, avo_fields[name.to_sym].resolve_attribute(value)]
+        end
+
+        processed_fields = processed_fields.to_h
+      else
+        processed_fields = {}
+      end
+
+      result = self.handle models: models, fields: processed_fields
+
+      self
+    end
+
+    def param_id
+      self.class.to_s.demodulize.underscore.gsub '/', '_'
+    end
+
+    def succeed(text)
+      self.response[:message_type] = :notice
+      self.response[:message] = text
+
+      self
+    end
+
+    def fail(text)
+      self.response[:message_type] = :alert
+      self.response[:message] = text
+
+      self
+    end
+
+    def redirect_to(path = nil, &block)
+      self.response[:type] = :redirect
+      if block.present?
+        self.response[:path] = block
+      else
+        self.response[:path] = path
+      end
+
+      self
+    end
+
+    def reload
+      self.response[:type] = :reload
+
+      self
+    end
+
+    def download(path, filename)
+      self.response[:type] = :download
+      self.response[:path] = path
+      self.response[:filename] = filename
+
+      self
+    end
+  end
+end