symphonia 3.4.0 → 4.0.0

data/lib/symphonia/model_filters/boolean_filter.rb

@@ -2,12 +2,12 @@ module Symphonia
   module ModelFilters
     class BooleanFilter < Base
 
-      def operator=(o)
-        if o == '!'
-          @operator = 'not_eq'
-        else
-          @operator = 'eq'
-        end
+      def operator=(to)
+        @operator = if to == '!'
+                      'not_eq'
+                    else
+                      'eq'
+                    end
       end
 
       def apply(scope)
@@ -16,11 +16,10 @@ module Symphonia
         scope.where(t[name].send(operator, true))
       end
 
-      def form_field(_c)
-        _c.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      def form_field(context)
+        context.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
       end
-    end
 
+    end
   end
-
-end
+end

data/lib/symphonia/model_filters/date_filter.rb

@@ -1,18 +1,18 @@
 module Symphonia
   module ModelFilters
     class DateFilter < Base
-      attr_accessor :available_values
+      attr_writer :available_values
 
-      def initialize(name, query, options={})
+      def initialize(name, query, options = {})
         super
         @operator = 'in'
       end
 
-      def value=(q)
-        v = available_values.values.reduce(:merge)[q.to_sym]
+      def value=(to)
+        v = available_values.values.reduce(:merge)[to.to_sym]
         @operator = 'between' unless q == 'today'
-        @value = if q == 'custom'
-                   data = self.query.controller.params.require(:date_from_custom).permit(:from, :to)
+        @value = if to == 'custom'
+                   data = query.controller.params.require(:date_from_custom).permit(:from, :to)
                    v.call(data)
                  else
                    v.call
@@ -34,48 +34,49 @@ module Symphonia
       def available_values
         {
           past: {
-            last_month: -> {d = Date.today.last_month.beginning_of_month; d..d.end_of_month},
-            last_year: -> {d = Date.today.last_year.beginning_of_year; d..d.end_of_year}
+            last_month: -> { d = Date.today.last_month.beginning_of_month; d..d.end_of_month },
+            last_year: -> { d = Date.today.last_year.beginning_of_year; d..d.end_of_year },
           },
           present: {
-            today: -> {Date.today},
-            this_month: -> {Date.today.beginning_of_month..Date.today.end_of_month},
-            this_year: -> {Date.today.beginning_of_year..Date.today.end_of_year},
-            custom: ->(data) {data[:from].to_date..data[:to].to_date}
+            today: -> { Date.today },
+            this_month: -> { Date.today.beginning_of_month..Date.today.end_of_month },
+            this_year: -> { Date.today.beginning_of_year..Date.today.end_of_year },
+            custom: ->(data) { data[:from].to_date..data[:to].to_date },
           },
           future: {
-            next_month: -> {d = Date.today.next_month.beginning_of_month; d..d.end_of_month},
-            next_year: -> {d = Date.today.next_year.beginning_of_year; d..d.end_of_year}
-          }
+            next_month: -> { d = Date.today.next_month.beginning_of_month; d..d.end_of_month },
+            next_year: -> { d = Date.today.next_year.beginning_of_year; d..d.end_of_year },
+          },
         }
       end
 
-      def form_field(_c)
-        groups = available_values.inject({}) do |mem, (time, values)|
-          mem[_c.t("time.#{time}")] = values.collect do |(k, _val)|
-            [_c.t("query_options.filter_date.values.#{k}"), k]
+      def form_field(context)
+        groups = available_values.each_with_object({}) do |(time, values), mem|
+          mem[context.t("time.#{time}")] = values.collect do |(k, _val)|
+            [context.t("query_options.filter_date.values.#{k}"), k]
           end
-          mem
         end
         selected = Array(@query.active_filters[name])
-        _c.content_tag(:div, class: 'row') do
-          _c.select_tag("#{form_field_name}", _c.grouped_options_for_select(groups, selected), {
+        context.content_tag(:div, class: 'row') do
+          context.select_tag(form_field_name.to_s, context.grouped_options_for_select(groups, selected), {
             class: 'form-control',
             include_blank: true,
-            onchange: 'symphoniaFiltersForm.dateFilterCallback(this)'
-          }) + _c.content_tag(:div, class: 'filter-custom-date clearfix input-daterange input-group inline', style: 'display: none') do
-            _c.date_field_tag("#{form_field_name}_custom[to]", '', {
-              placeholder: _c.t('query_options.filter_date.to'),
-              class: 'form-control datepicker pull-right'
+            onchange: 'symphoniaFiltersForm.dateFilterCallback(this)',
+          }) + context.content_tag(:div, class: 'filter-custom-date clearfix input-daterange input-group inline',
+                                   style: 'display: none') do
+            context.date_field_tag("#{form_field_name}contextustom[to]", '', {
+              placeholder: context.t('query_options.filter_date.to'),
+              class: 'form-control datepicker pull-right',
             }) +
-              # _c.content_tag(:span, _c.t('query_options.filter_date.to'), class: 'input-group-addon')+
-              _c.date_field_tag("#{form_field_name}_custom[from]", '', {
+              # context.content_tag(:span, context.t('query_options.filter_date.to'), class: 'input-group-addon')+
+              context.date_field_tag("#{form_field_name}_custom[from]", '', {
                 placeholder: _c.t('query_options.filter_date.from'),
-                class: 'form-control datepicker'
+                class: 'form-control datepicker',
               })
           end
         end
       end
+
     end
   end
-end
+end

data/lib/symphonia/model_filters/integer_filter.rb

@@ -8,11 +8,10 @@ module Symphonia
         scope.where(t[name].send(operator, value.to_f))
       end
 
-      def form_field(_c)
-        _c.number_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      def form_field(context)
+        context.number_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
       end
-    end
 
+    end
   end
-
-end
+end

data/lib/symphonia/model_filters/select_filter.rb

@@ -1,7 +1,7 @@
 module Symphonia
   module ModelFilters
     class SelectFilter < StringFilter
-      attr_accessor :available_values
+      attr_writer :available_values
 
       def initialize(name, query, options = {})
         super
@@ -9,7 +9,7 @@ module Symphonia
       end
 
       def available_values
-        return @available_values.call(_c, self) if @available_values.is_a? Proc
+        return @available_values.call(context, self) if @available_values.is_a? Proc
 
         @available_values || case @attribute
                              when Symphonia::ModelAttributes::EnumAttribute
@@ -17,18 +17,16 @@ module Symphonia
                              end
       end
 
-      def value=(q)
-        @value = if q.is_a?(Array)
-                   q
+      def value=(to)
+        @value = if to.is_a?(Array)
+                   to
                  else
-                   q.to_s.split("|")
+                   to.to_s.split("|")
                  end
       end
 
-      def operator=(o)
-        if o == '!'
-          @operator = 'not_in'
-        end
+      def operator=(to)
+        @operator = 'not_in' if to == '!'
       end
 
       def apply(scope)
@@ -37,16 +35,20 @@ module Symphonia
         scope.where(t[name].send(operator, value))
       end
 
-      def form_field(_c)
+      def form_field(context)
         selected = Array(@query.active_filters[name])
-        _c.content_tag(:div, class: 'input-group') do
-          _c.content_tag(:div, class: 'input-group-prepend') do
-            _c.content_tag(:span, _c.check_box_tag("o[#{form_field_name}]", '!', operator == 'not_in', title: 'Not In'), class: "input-group-text")
+        context.content_tag(:div, class: 'input-group') do
+          context.content_tag(:div, class: 'input-group-prepend') do
+            context.content_tag(:span,
+                                context.check_box_tag("o[#{form_field_name}]", '!', operator == 'not_in', title: 'Not In'), class: "input-group-text")
           end +
-            _c.select_tag("#{form_field_name}[]", _c.options_for_select(available_values, selected), class: 'form-control', include_blank: true, multiple: selected.size > 1) +
-            _c.content_tag(:div, _c.link_to(_c.fa_icon('plus-square-o'), 'javascript:void(0)', onclick: "toggleMultiSelect($(this).closest('.input-group').find('select'))", title: I18n.t(:title_toggle_multiselect), class: "input-group-text"), class: 'input-group-append')
+            context.select_tag("#{form_field_name}[]", context.options_for_select(available_values, selected),
+                               class: 'form-control', include_blank: true, multiple: selected.size > 1) +
+            context.content_tag(:div,
+                                context.link_to(context.fa_icon('plus-square-o'), 'javascript:void(0)', onclick: "toggleMultiSelect($(this).closest('.input-group').find('select'))", title: I18n.t(:title_toggle_multiselect), class: "input-group-text"), class: 'input-group-append')
         end
       end
+
     end
   end
-end
+end

data/lib/symphonia/model_filters/string_filter.rb

@@ -8,11 +8,10 @@ module Symphonia
         scope.where(t[name].lower.send(operator, value&.downcase))
       end
 
-      def form_field(_c)
-        _c.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      def form_field(context)
+        context.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
       end
-    end
 
+    end
   end
-
-end
+end

data/lib/symphonia/query.rb

@@ -1,6 +1,7 @@
 module Symphonia
   class SymphoniaQueryNotRegistered < StandardError
   end
+
   class FilterNotFound < StandardError
   end
 
@@ -108,10 +109,8 @@ module Symphonia
       @columns ||= column_names.map { |c| available_columns[c] }.compact
     end
 
-    def render_filters
-      (available_filters | filters).each do |filter|
-        yield filter
-      end
+    def render_filters(&block)
+      (available_filters | filters).each(&block)
     end
 
     def entity_scope
@@ -161,11 +160,16 @@ module Symphonia
       'symphonia/common/query'
     end
 
-    def to_params(force = false)
+    # Serialize query to params
+    # @param [FalseClass] force use applied filters, even that wasn't before
+    # @return [Hash]
+    def to_params(force: false)
       if @q
         { q: @q }
       elsif @set_filter || force
-        filters.each_with_object(set_filter: 1) { |var, mem| f, v = var; mem[f.send(:form_field_name).to_sym] = v; }
+        filters.inject(set_filter: 1) do |(f, v), mem|
+          mem[f.send(:form_field_name).to_sym] = v
+        end
       else
         {}
       end
@@ -175,7 +179,6 @@ module Symphonia
       "#<#{self.class.name} set_filter=#{@set_filter} >"
     end
 
-
     def available_filters
       self.active_filters ||= {}
       self.operators ||= {}
@@ -230,33 +233,6 @@ module Symphonia
       @default_column_names
     end
 
-    def add_column(_type, name, options = {})
-      @available_columns[name] = "Symphonia::QueryColumns::#{_type.to_s.classify}Column".constantize.new(name, self, options)
-    end
-
-    # aliases
-
-    def add_generic_column(name, options = {})
-      add_column(:generic, name, options)
-    end
-
-    def add_text_column(name, options = {})
-      add_column(:text, name, options)
-    end
-
-    def add_price_column(name, options = {})
-      add_column(:price, name, options)
-    end
-
-    def add_date_column(name, options = {})
-      add_column(:date, name, options)
-    end
-
-    def add_boolean_column(name, options = {})
-      add_column(:boolean, name, options)
-    end
-
-    #
     def add_attribute_column(attribute, options = {})
       @available_columns[attribute.name] = ::Symphonia::QueryColumns::AttributeColumn.new(attribute, self, options)
     end

data/lib/symphonia/query_columns.rb

@@ -1,8 +1,7 @@
-require_dependency('symphonia/query_columns/generic_column')
 require_dependency('symphonia/query_columns/attribute_column')
 
 module Symphonia
   module QueryColumns
 
   end
-end
+end

data/lib/symphonia/query_columns/attribute_column.rb

@@ -1,14 +1,14 @@
 module Symphonia
   module QueryColumns
-    class AttributeColumn < GenericColumn
+    class AttributeColumn
 
-      attr_reader :attribute
+      attr_reader :attribute, :name, :query, :model, :includes, :preload, :joins
       attr_accessor :no_header, :sort_options
-      attr_writer :header, :sort
+      attr_writer :header, :sort, :sort_column_name, :sort_definition
 
       delegate :default?, :title, to: :attribute
 
-      def initialize(attribute, query, options={})
+      def initialize(attribute, query, options = {})
         @attribute = attribute
         @name = attribute.name
         @query = query
@@ -38,6 +38,60 @@ module Symphonia
         @attribute.format(view, entity)
       end
 
+      def summarize?
+        false
+      end
+
+      def header?
+        !(@header == false)
+      end
+
+      def sort?
+        !(@sort == false)
+      end
+
+      def sort_definition
+        return nil unless sort?
+
+        @sort_definition ||= SortableTable::SortColumnCustomDefinition.new(@name, { asc: "#{sort_column_name} asc", desc: "#{sort_column_name} desc" })
+      end
+
+      def value(entity)
+        entity.send(name)
+      end
+
+      def sum_value(view)
+        format_value(view, OpenStruct.new(name => sum))
+      end
+
+      def sum
+        return nil unless summarize?
+
+        @sum ||= query.entities.sum(name)
+      end
+
+      def css_classes
+        @name.to_s
+      end
+
+      def inspect
+        "#<#{self.class.name} name='#{name}' options=#{@options.inspect}>"
+      end
+
+      private
+
+      def t(*args)
+        I18n.translate(*args)
+      end
+
+      def l(*args)
+        I18n.localize(*args)
+      end
+
+      def sort_column_name
+        @sort_column_name.presence || [@model.table_name, @name].join('.')
+      end
+
     end
   end
-end
+end

data/lib/symphonia/spec_helper.rb

@@ -1,4 +1,6 @@
-require File.expand_path('../../../spec/spec_helper', __FILE__)
-Dir.glob(File.expand_path('../../../spec/{factories,support}/*.rb', __FILE__)).each do |file|
-  require file
+if Rails.env.test?
+  require File.expand_path('../../../spec/spec_helper', __FILE__)
+  Dir.glob(File.expand_path('../../../spec/{factories,support}/*.rb', __FILE__)).each do |file|
+    require file
+  end
 end

data/lib/symphonia/version.rb

@@ -1,3 +1,5 @@
 module Symphonia
-  VERSION = '3.4.0'
+
+  VERSION = '4.0.0'
+
 end

data/spec/controllers/account_controller_spec.rb

@@ -1,99 +1,96 @@
-module Symphonia
-  RSpec.describe AccountsController do
+RSpec.describe Symphonia::AccountsController do
 
-    include ActiveJob::TestHelper
+  include ActiveJob::TestHelper
 
-    routes { Symphonia::Engine.routes }
+  routes { Symphonia::Engine.routes }
 
-    let(:regular_user) { FactoryBot.create(:user) }
+  let(:regular_user) { FactoryBot.create(:user) }
 
-    context 'logged', logged: true do
-      context '#update' do
+  context 'logged', logged: true do
+    context '#update' do
 
-        it 'valid' do
-          put :update, params: { user: { login: Faker::Internet.user_name } }
-          expect(response).to redirect_to account_path
-        end
-
-        it 'invalid' do
-          put :update, params: { user: { login: '' } }
-          expect(response).to have_http_status :success
-        end
+      it 'valid' do
+        put :update, params: { user: { login: Faker::Internet.user_name } }
+        expect(response).to redirect_to account_path
+      end
 
+      it 'invalid' do
+        put :update, params: { user: { login: '' } }
+        expect(response).to have_http_status :success
       end
 
     end
+  end
 
-    context '#resend_activation' do
+  context '#resend_activation' do
 
-      let(:email) { Faker::Internet.email }
-      subject { get :resend_activation, params: { email: email } }
+    let(:email) { Faker::Internet.email }
+    subject { get :resend_activation, params: { email: email } }
 
-      it 'non exist user' do
-        is_expected.to redirect_to :root
-        expect(flash[:error]).not_to be :blank
-      end
+    it 'non exist user' do
+      is_expected.to redirect_to :root
+      expect(flash[:error]).not_to be :blank
+    end
 
-      it 'active user' do
-        _user = FactoryBot.create(:user, email: email, status: 'active')
-        is_expected.to redirect_to :root
-        expect(flash[:error]).not_to be :blank
-      end
+    it 'active user' do
+      _user = FactoryBot.create(:user, email: email, status: 'active')
+      is_expected.to redirect_to :root
+      expect(flash[:error]).not_to be :blank
+    end
 
-      it 'pending user' do
-        user = FactoryBot.create(:user, email: email, status: 'pending')
-        token = user.perishable_token.dup
+    it 'pending user' do
+      user = FactoryBot.create(:user, email: email, status: 'pending')
+      token = user.perishable_token.dup
 
-        expect { get :resend_activation, params: { email: email } }.to have_enqueued_job.on_queue('mailers')
-        expect(response).to have_http_status :redirect
+      expect { get :resend_activation, params: { email: email } }.to have_enqueued_job.on_queue('mailers')
+      expect(response).to have_http_status :redirect
 
-        expect(user.reload.perishable_token).not_to eq token
-        expect(flash[:error]).to be_nil
-        expect(flash[:notice]).not_to be :blank
-      end
+      expect(user.reload.perishable_token).not_to eq token
+      expect(flash[:error]).to be_nil
+      expect(flash[:notice]).not_to be :blank
     end
+  end
 
-    context '#activation' do
-      let(:token) { SecureRandom.hex(3) }
-      subject { get :activation, params: { activation_code: token } }
-
-      it 'valid token' do
-        user = FactoryBot.create(:user, status: 'pending')
-        user.update_columns(perishable_token: token)
-        is_expected.to redirect_to :login
-        expect(user.reload.status).to eq 'active'
-      end
+  context '#activation' do
+    let(:token) { SecureRandom.hex(3) }
+    subject { get :activation, params: { activation_code: token } }
 
-      it 'invalid token' do
-        is_expected.to redirect_to :root
-        expect(flash[:error]).not_to be :blank
-      end
+    it 'valid token' do
+      user = FactoryBot.create(:user, status: 'pending')
+      user.update_columns(perishable_token: token)
+      is_expected.to redirect_to :login
+      expect(user.reload.status).to eq 'active'
     end
 
-    context '#lost_password' do
+    it 'invalid token' do
+      is_expected.to redirect_to :root
+      expect(flash[:error]).not_to be :blank
+    end
+  end
 
-      it 'with mail' do
-        user = FactoryBot.create(:user, status: 'active')
+  context '#lost_password' do
 
-        expect { post :lost_password, params: { email: user.email } }.to have_enqueued_job.on_queue('mailers')
-        expect(flash[:error]).to be_nil
-      end
+    it 'with mail' do
+      user = FactoryBot.create(:user, status: 'active')
 
-      it 'with inactive user' do
-        user = FactoryBot.create(:user, status: 'pending')
-        expect { post :lost_password, params: { email: user.email } }.not_to have_enqueued_job.on_queue('mailers')
-        expect(flash[:error]).not_to be :blank
-      end
+      expect { post :lost_password, params: { email: user.email } }.to have_enqueued_job.on_queue('mailers')
+      expect(flash[:error]).to be_nil
     end
 
-    context "#reset_password" do
-      subject { FactoryBot.create :user }
-      it "reset" do
-        put :reset_password, params: { id: subject.perishable_token, password: "secret-pass-1" }
-        expect(response).to redirect_to /login/
-        expect { subject.reload }.to change(subject, :crypted_password)
-      end
+    it 'with inactive user' do
+      user = FactoryBot.create(:user, status: 'pending')
+      expect { post :lost_password, params: { email: user.email } }.not_to have_enqueued_job.on_queue('mailers')
+      expect(flash[:error]).not_to be :blank
     end
+  end
 
+  context "#reset_password" do
+    subject { FactoryBot.create :user }
+    it "reset" do
+      put :reset_password, params: { id: subject.perishable_token, password: "secret-pass-1" }
+      expect(response).to redirect_to /login/
+      expect { subject.reload }.to change(subject, :crypted_password)
+    end
   end
+
 end