gestart-admino 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+

data/gestart-admino.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'admino/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gestart-admino'
+  spec.version       = Admino::VERSION
+  spec.authors       = ['Gestart Cloud S.r.l.', 'Stefano Verna']
+  spec.email         = ['dev@gestart.net']
+  spec.description   = %q{Fork Gestart di admino 0.0.22, potato di ciò che Gestart non usa}
+  spec.summary       = %q{Fork Gestart di admino: query object e tabelle delle pagine indice}
+  spec.homepage      = 'https://github.com/gestartcloudsrl/gestart-admino'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 3.1'
+
+  spec.add_dependency 'showcase', '~> 0.2.5'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activemodel'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'i18n'
+  spec.add_development_dependency 'rspec-html-matchers'
+  spec.add_development_dependency 'actionpack'
+  spec.add_development_dependency 'railties'
+  spec.add_development_dependency 'simple_form'
+  spec.add_development_dependency 'ostruct'
+end

data/lib/admino/action_view_extension.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/hash'
+require 'admino/table/presenter'
+require 'admino/query/base_presenter'
+
+module Admino
+  module ActionViewExtension
+    module Internals
+      def self.present_query(query, context, options, key = :presenter)
+        presenter_klass = options.fetch(key, Admino::Query::BasePresenter)
+        presenter_klass.new(query, context)
+      end
+    end
+
+    def table_for(collection, options = {}, &block)
+      options.symbolize_keys!
+      options.assert_valid_keys(:presenter, :class, :query, :html)
+      presenter_klass = options.fetch(:presenter, Admino::Table::Presenter)
+      query = if options[:query]
+                Internals.present_query(options[:query], self, options, :query_presenter)
+              else
+                nil
+              end
+      presenter = presenter_klass.new(collection, options[:class], query, self)
+      html_options = options.fetch(:html, {})
+      presenter.to_html(html_options, &block)
+    end
+
+    def simple_search_form_for(query, options = {}, &block)
+      options.symbolize_keys!
+      Internals.present_query(query, self, options.slice(:presenter)).
+        simple_form(options, &block)
+    end
+  end
+end
+

data/lib/admino/query/base.rb

@@ -0,0 +1,124 @@
+require 'active_support/concern'
+require 'active_model/naming'
+require 'active_model/translation'
+require 'active_model/conversion'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/class/attribute'
+
+require 'admino/query/dsl'
+require 'admino/query/builder'
+
+module Admino
+  module Query
+    class Base
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+      include ActiveModel::Conversion
+      extend Dsl
+
+      attr_reader :params
+      attr_reader :context
+      attr_reader :filter_groups
+      attr_reader :search_fields
+      attr_reader :sorting
+
+      def self.i18n_scope
+        :query
+      end
+
+      def initialize(params = nil, context = {}, config = nil)
+        @params =
+          if params.respond_to?(:to_unsafe_h)
+            ActiveSupport::HashWithIndifferentAccess.new(params.to_unsafe_h)
+          else
+            ActiveSupport::HashWithIndifferentAccess.new(params)
+          end
+        @config = config
+        @context = context
+
+        init_filter_groups
+        init_search_fields
+        init_sorting
+      end
+
+      def scope(starting_scope = nil)
+        starting_scope ||= if config.starting_scope_callable
+                             config.starting_scope_callable.call(self)
+                           else
+                             raise ArgumentError, 'no starting scope provided'
+                           end
+
+        scope = augment_scope(Builder.new(self, starting_scope)).scope
+
+        if config.ending_scope_callable
+          scope.instance_exec(self, &config.ending_scope_callable)
+        else
+          scope
+        end
+      end
+
+      def persisted?
+        false
+      end
+
+      def config
+        @config || self.class.config
+      end
+
+      def filter_groups
+        @filter_groups.values
+      end
+
+      def filter_group_by_name(name)
+        @filter_groups[name]
+      end
+
+      def search_fields
+        @search_fields.values
+      end
+
+      def search_field_by_name(name)
+        @search_fields[name]
+      end
+
+      private
+
+      def augment_scope(query_builder)
+        scope_augmenters.each do |augmenter|
+          query_builder = augmenter.augment_scope(query_builder)
+        end
+
+        query_builder
+      end
+
+      def scope_augmenters
+        scope_augmenters = search_fields + filter_groups
+        scope_augmenters << sorting if sorting
+        scope_augmenters
+      end
+
+      def init_filter_groups
+        @filter_groups = {}
+        i18n_key = self.class.model_name.i18n_key
+        config.filter_groups.each do |config|
+          @filter_groups[config.name] = FilterGroup.new(config, params, i18n_key)
+        end
+      end
+
+      def init_search_fields
+        @search_fields = {}
+        config.search_fields.each do |config|
+          @search_fields[config.name] = SearchField.new(config, params)
+        end
+      end
+
+      def init_sorting
+        if config.sorting
+          i18n_key = self.class.model_name.i18n_key
+          @sorting = Sorting.new(config.sorting, params, i18n_key)
+        end
+      end
+    end
+  end
+end

data/lib/admino/query/base_presenter.rb

@@ -0,0 +1,27 @@
+require 'showcase'
+
+module Admino
+  module Query
+    class BasePresenter < Showcase::Presenter
+      presents_collection :filter_groups
+      presents :sorting
+
+      def simple_form(options = {}, &block)
+        h.simple_form_for(
+          self,
+          options.reverse_merge(default_form_options),
+          &block
+        )
+      end
+
+      def default_form_options
+        {
+          as: :query,
+          method: :get,
+          url: h.request.fullpath
+        }
+      end
+    end
+  end
+end
+

data/lib/admino/query/builder.rb

@@ -0,0 +1,24 @@
+module Admino
+  module Query
+    class Builder
+      attr_accessor :scope
+      attr_reader :context
+
+      def initialize(context, scope)
+        @context = context
+        @scope = scope
+      end
+
+      private
+
+      def method_missing(method, *args)
+        context_method = "#{method}_scope"
+        if context.respond_to?(context_method)
+          Builder.new(context, context.send(context_method, scope, *args))
+        else
+          Builder.new(context, scope.send(method, *args))
+        end
+      end
+    end
+  end
+end

data/lib/admino/query/configuration.rb

@@ -0,0 +1,100 @@
+module Admino
+  module Query
+    class Configuration
+      class SearchField
+        attr_reader :name
+        attr_reader :options
+
+        def initialize(name, options = {})
+          options.symbolize_keys!
+          options.assert_valid_keys(
+            :default
+          )
+
+          @name = name.to_sym
+          @options = options
+        end
+
+        def default_value
+          options[:default]
+        end
+      end
+
+      class FilterGroup
+        attr_reader :name
+        attr_reader :scopes
+        attr_reader :options
+
+        def initialize(name, scopes, options = {})
+          options.symbolize_keys!
+          options.assert_valid_keys(
+            :include_empty_scope,
+            :default
+          )
+
+          @name = name.to_sym
+          @scopes = scopes.map(&:to_sym)
+          @options = options
+        end
+
+        def include_empty_scope?
+          @options.fetch(:include_empty_scope) { false }
+        end
+
+        def default_scope
+          if options[:default]
+            options[:default].to_sym
+          end
+        end
+      end
+
+      class Sorting
+        attr_reader :scopes
+        attr_reader :default_scope
+        attr_reader :default_direction
+
+        def initialize(scopes, options = {})
+          options.symbolize_keys!
+          options.assert_valid_keys(:default_scope, :default_direction)
+
+          @scopes = scopes.map(&:to_sym)
+          @default_scope = if options[:default_scope]
+                             options[:default_scope].to_sym
+                           end
+
+          @default_direction = if options[:default_direction]
+                                 options[:default_direction].to_sym
+                               end
+        end
+      end
+
+      attr_reader :search_fields
+      attr_reader :filter_groups
+      attr_reader :sorting
+      attr_accessor :starting_scope_callable
+      attr_accessor :ending_scope_callable
+
+      def initialize
+        @search_fields = []
+        @filter_groups = []
+      end
+
+      def add_search_field(name, options = {})
+        SearchField.new(name, options).tap do |search_field|
+          self.search_fields << search_field
+        end
+      end
+
+      def add_filter_group(name, scopes, options = {})
+        FilterGroup.new(name, scopes, options).tap do |filter_group|
+          self.filter_groups << filter_group
+        end
+      end
+
+      def add_sorting_scopes(scopes, options = {})
+        @sorting = Sorting.new(scopes, options)
+      end
+    end
+  end
+end
+

data/lib/admino/query/dsl.rb

@@ -0,0 +1,38 @@
+module Admino
+  module Query
+    module Dsl
+      def config
+        @config ||= Admino::Query::Configuration.new
+      end
+
+      def search_field(name, options = {})
+        config.add_search_field(name, options)
+
+        define_method name do
+          search_field_by_name(name).value
+        end
+      end
+
+      def filter_by(name, scopes, options = {})
+        config.add_filter_group(name, scopes, options)
+
+        define_method name do
+          filter_group_by_name(name).value.to_s
+        end
+      end
+
+      def sorting(*args)
+        options = args.extract_options!
+        config.add_sorting_scopes(args, options)
+      end
+
+      def starting_scope(&block)
+        config.starting_scope_callable = block
+      end
+
+      def ending_scope(&block)
+        config.ending_scope_callable = block
+      end
+    end
+  end
+end

data/lib/admino/query/filter_group.rb

@@ -0,0 +1,73 @@
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class FilterGroup
+      attr_reader :params
+      attr_reader :config
+      attr_reader :query_i18n_key
+
+      def initialize(config, params, query_i18n_key = nil)
+        @config = config
+        @params = ActiveSupport::HashWithIndifferentAccess.new(params)
+        @query_i18n_key = query_i18n_key
+      end
+
+      def augment_scope(scope)
+        if active_scope && active_scope != :empty
+          scope.send(active_scope)
+        else
+          scope
+        end
+      end
+
+      def active_scope
+        if value && scopes.include?(value)
+          value
+        else
+          nil
+        end
+      end
+
+      def is_scope_active?(scope)
+        active_scope == scope.to_sym
+      end
+
+      def value
+        value = params.fetch(:query, {}).fetch(param_name, default_value)
+        if value
+          value.to_sym
+        else
+          nil
+        end
+      end
+
+      def default_value
+        if config.default_scope
+          config.default_scope
+        elsif config.include_empty_scope?
+          :empty
+        else
+          nil
+        end
+      end
+
+      def param_name
+        config.name
+      end
+
+      def scopes
+        @scopes ||= config.scopes.dup.tap do |scopes|
+          if config.include_empty_scope?
+            scopes.unshift :empty
+          end
+        end
+      end
+
+      def i18n_key
+        config.name
+      end
+    end
+  end
+end

data/lib/admino/query/filter_group_presenter.rb

@@ -0,0 +1,85 @@
+require 'i18n'
+require 'showcase'
+require 'showcase/helpers/html_options'
+require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class FilterGroupPresenter < Showcase::Presenter
+      def scope_link(scope, *args)
+        options = args.extract_options!
+
+        label = args.first || scope_name(scope)
+
+        active_class = options.delete(:active_class) { 'is-active' }
+        options = Showcase::Helpers::HtmlOptions.new(options)
+
+        if is_scope_active?(scope)
+          options.add_class!(active_class)
+        end
+
+        h.link_to label, scope_path(scope), options.to_h
+      end
+
+      def scopes
+        @scopes ||= super.map do |scope|
+          ScopePresenter.new(scope, self, view_context)
+        end
+      end
+
+      def each_scope(&block)
+        scopes.each(&block)
+      end
+
+      def scope_path(scope)
+        h.request.path + "?" + scope_params(scope).to_query
+      end
+
+      def scope_params(scope)
+        params = ActiveSupport::HashWithIndifferentAccess.new(
+          h.request.query_parameters.deep_dup
+        )
+
+        params[:query] ||= {}
+
+        if is_scope_active?(scope)
+          params[:query].delete(param_name)
+        else
+          params[:query].merge!(param_name => scope.to_s)
+        end
+
+        if params[:query].empty?
+          params.delete(:query)
+        end
+
+        params
+      end
+
+      def scope_name(scope)
+        I18n.t(
+          :"#{query_i18n_key}.#{i18n_key}.scopes.#{scope}",
+          scope: 'query.filter_groups',
+          default: [
+            :"#{i18n_key}.scopes.#{scope}",
+            scope.to_s.titleize
+          ]
+        )
+      end
+
+      def name
+        I18n.t(
+          :"#{query_i18n_key}.#{i18n_key}.name",
+          scope: 'query.filter_groups',
+          default: [
+            :"#{i18n_key}.name",
+            i18n_key.to_s.titleize.capitalize
+          ]
+        )
+      end
+    end
+  end
+end
+

data/lib/admino/query/scope_presenter.rb

@@ -0,0 +1,17 @@
+require 'showcase'
+
+module Admino
+  module Query
+    class ScopePresenter < Showcase::Presenter
+      def initialize(object, parent, view_context)
+        super(object, view_context)
+        @parent = parent
+      end
+
+      def link(*args)
+        @parent.scope_link(object, *args)
+      end
+    end
+  end
+end
+

data/lib/admino/query/search_field.rb

@@ -0,0 +1,43 @@
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class SearchField
+      attr_reader :params
+      attr_reader :config
+
+      def initialize(config, params)
+        @config = config
+        @params = ActiveSupport::HashWithIndifferentAccess.new(params)
+      end
+
+      def augment_scope(scope)
+        if present?
+          scope.send(scope_name, value)
+        else
+          scope
+        end
+      end
+
+      def value
+        value = params.fetch(:query, {}).fetch(param_name, nil)
+
+        value || config.default_value
+      end
+
+      def present?
+        value.present?
+      end
+
+      def param_name
+        config.name
+      end
+
+      def scope_name
+        config.name
+      end
+    end
+  end
+end
+

data/lib/admino/query/sorting.rb

@@ -0,0 +1,74 @@
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+
+module Admino
+  module Query
+    class Sorting
+      attr_reader :params
+      attr_reader :config
+      attr_reader :query_i18n_key
+
+      def initialize(config, params, query_i18n_key = nil)
+        @config = config
+        @params = ActiveSupport::HashWithIndifferentAccess.new(params)
+      end
+
+      def augment_scope(scope)
+        if active_scope
+          scope.send(active_scope, ascending? ? :asc : :desc)
+        else
+          scope
+        end
+      end
+
+      def is_scope_active?(scope)
+        active_scope == scope.to_sym
+      end
+
+      def ascending?
+        if params[:sort_order] == 'desc'
+          false
+        elsif params[:sort_order].blank? && active_scope == default_scope
+          default_direction_is_ascending?
+        else
+          true
+        end
+      end
+
+      def active_scope
+        if param_value && scopes.include?(param_value.to_sym)
+          param_value.to_sym
+        elsif default_scope
+          default_scope
+        else
+          nil
+        end
+      end
+
+      def default_scope
+        config.default_scope
+      end
+
+      def default_direction
+        config.default_direction
+      end
+
+      def default_direction_is_ascending?
+        default_direction != :desc
+      end
+
+      def param_value
+        params.fetch(param_name, nil)
+      end
+
+      def param_name
+        :sorting
+      end
+
+      def scopes
+        config.scopes
+      end
+    end
+  end
+end
+