ecoportal-api-v2 1.1.6 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6294103b68ebdbf099d1137865856b10baec21683bd648727976f245cf197ad
-  data.tar.gz: e0500e2c784a46c7a82ca3aa29e44f96d116bd6898e5b35f9174162457208165
+  metadata.gz: 70ba8da2cd5c6bd11498fb6cf8a40b04d121940c1693efc525372e3a584758f8
+  data.tar.gz: 2aa49af74223a5a03529fd3920714ff9b4f1dcbc636285c6b187acebe9b2e601
 SHA512:
-  metadata.gz: eb18fb2a167afeaea5eac0db4e13ee58d64fc348ff1ebd33942ad1bb7120cbb828ad2652ed2d6b165d7a1b53eea097338032690e26ee97f5765fd87ba2f97862
-  data.tar.gz: 7a61a35335247d39a0e97574f5b2816a92238d93a9f5b23c62b909a92ae03817057752ffc576ae1414c5e6744a6381b473be4cd2cfc2a0fd4e7582cffd97bdd4
+  metadata.gz: 75a8af0bc9495b4ba65688914eaf2ac94e4b08756581a3e6f193c390376ae6d905d08321ba8c8017675e1d2991ce1c699176f74c4c7b4b3b7aa91edbd8b37325
+  data.tar.gz: ea3368515e1fb001874e4e932902e063bb2e1cbf015cb352c2813313bb97abd80c446e5f9ab623fa11dbc0dc8e9c164c5b1947475d7a43c935da91ac34c9be22

data/.rubocop.yml

@@ -1,39 +1,70 @@
 AllCops:
-  TargetRubyVersion: 2.5.1
+  TargetRubyVersion: 2.7.8
   Exclude:
     - 'config/routes.rb'
+  NewCops: enable
 
-Metrics/LineLength:
-  Enabled: false
-Metrics/BlockLength:
-  ExcludedMethods: [context, describe]
-  Max: 50
+Metrics/ClassLength:
+  Max: 500
+Metrics/ModuleLength:
+  Max: 300
 Metrics/MethodLength:
   Max: 50
-Metrics/ClassLength:
-  Max: 200
 Metrics/AbcSize:
   Max: 30
-
-ParameterLists:
+Metrics/ParameterLists:
   Max: 5
   CountKeywordArgs: false
+Metrics/BlockLength:
+  CountAsOne: ['array', 'heredoc', 'method_call']
+  Max: 50
+Metrics/CyclomaticComplexity:
+  Max: 30
+Metrics/PerceivedComplexity:
+  Max: 30
 
-Style/StringLiterals:
+Style/AccessorGrouping:
+  Enabled: false
+Style/ConditionalAssignment:
+  Enabled: false
+Style/BlockDelimiters:
+  BracesRequiredMethods: ['log']
+Style/ClassAndModuleChildren:
   Enabled: false
 Style/FrozenStringLiteralComment:
   Enabled: false
-Style/CommentedKeyword:
+Style/StringLiterals:
   Enabled: false
-Style/MultilineBlockChain:
+Style/StringLiteralsInInterpolation:
   Enabled: false
 Style/Documentation:
   Enabled: false
-Style/StringLiteralsInInterpolation:
+Style/CommentedKeyword:
+  Enabled: false
+Style/MultilineBlockChain:
   Enabled: false
 Style/AndOr:
   Enabled: false
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+Style/FetchEnvVar:
+  Enabled: false
+Style/RegexpLiteral:
+  EnforcedStyle: mixed
+  AllowInnerSlashes: true
 
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+Layout/LeadingCommentSpace:
+  Enabled: false
+  AllowGemfileRubyComment: true
+Layout/ParameterAlignment:
+  Enabled: false
+Layout/MultilineMethodDefinitionBraceLayout:
+  EnforcedStyle: symmetrical
+Layout/LineLength:
+  Enabled: true
 Layout/SpaceInsideHashLiteralBraces:
   Enabled: false
 Layout/SpaceInsideBlockBraces:
@@ -42,14 +73,22 @@ Layout/SpaceAroundOperators:
   Enabled: false
 Layout/ExtraSpacing:
   AllowForAlignment: true
+  AllowBeforeTrailingComments: true
 Layout/AccessModifierIndentation:
   EnforcedStyle: indent
 Layout/DotPosition:
   EnforcedStyle: trailing
 Layout/MultilineMethodCallIndentation:
   EnforcedStyle: indented
-Layout/IndentHash:
+Layout/FirstHashElementIndentation:
+  Enabled: false
+Layout/EmptyLineAfterGuardClause:
   Enabled: false
 
 Naming/VariableNumber:
   EnforcedStyle: snake_case
+  CheckSymbols: false
+Naming/MethodParameterName:
+  AllowedNames: ['x', 'y', 'i', 'j', 'id', 'io']
+Naming/RescuedExceptionsVariableName:
+  Enabled: false

data/CHANGELOG.md

@@ -1,11 +1,26 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [1.1.7] - 2024-02-xx
+## [1.1.8] - 2024-03-23
 
-### Added
 ### Changed
+  - A lot of code tidy up
+
+### Fixed
+  - `Ecoportal::API::Common::Conent::CollectionModel`
+    - correct `item` `klass` resolution
+
+## [1.1.7] - 2024-03-13
+
+### Added
+  - `Ecoportal::API::Common::Concerns::Benchmarkable`
+  - `Ecoportal::API::Common::Conent::CollectionModel`
+    - added ability to define **default** value for `read_only`
+
 ### Fixed
+  - `Ecoportal::API::Common::Content::CollectionModel` tidied up item `klass` scoping
+    - **added** some benchmarking too
+    - memoize `@_items`
 
 ## [1.1.6] - 2024-02-29
 

data/lib/ecoportal/api/common/concerns/benchmarkable.rb

@@ -0,0 +1,160 @@
+module Ecoportal
+  module API
+    module Common
+      module Concerns
+        # @note While benchmarking with multi-thread gives correct results
+        #   for top unique block, will calculate the real time of each individual
+        #   thread, which is way higher than a single thread. However, as they
+        #   run in parallel, the total time would be the valid reference.
+        module Benchmarkable
+          private
+
+          def benchmark_enabled?
+            @benchmark_enabled = true if @benchmark_enabled.nil?
+            @benchmark_enabled
+          end
+
+          def benchmarking(ref = nil, print: false)
+            return yield unless benchmark_enabled?
+            benchmark_mem(ref, print: false) do
+              benchmark_time(ref, print: false) do
+                yield
+              end
+            end.tap do
+              puts "\n#{bench_summary_ref(ref)}" if print
+            end
+          end
+
+          def benchmark_mem(ref = nil, print: false)
+            return yield unless benchmark_enabled?
+            memory_before = memory_usage
+            yield.tap do
+              memory_after = memory_usage
+              mb_footprint = ((memory_after - memory_before) / 1024.0).round(2)
+              bench_add_mem(ref, mb_footprint)
+              puts bench_str_mem(mb, ref: ref, reffix: true) if print
+            end
+          end
+
+          def benchmark_time(ref = nil, print: false)
+            return yield unless benchmark_enabled?
+            result = nil
+            time   = benchmark.realtime do
+              result = yield
+            end.round(2)
+            result.tap do
+              bench_add_time(ref, time)
+              puts bench_str_time(time, ref: ref, reffix: true) if print
+            end
+          end
+
+          def benchmark_summary(ref = nil)
+            return '' unless benchmark_enabled?
+            return bench_summary_ref(ref) unless ref == :all
+
+            bench.keys.each_with_object([]) do |ref, out|
+              out << bench_summary_ref(ref)
+            end.join("\n")
+          end
+
+          def bench_summary_ref(ref = nil)
+            ref_lines = bench_summary_ref_lines(ref)
+            "- #{ref}\n" + "  • " + ref_lines.join("\n  • ")
+          end
+
+          def bench_summary_ref_lines(ref = nil)
+            ref_bench = bench_get(ref)
+            [
+              bench_str_time(*ref_bench[:time].values_at(:avg, :cnt), ref: ref),
+              bench_str_mem(*ref_bench[:mem].values_at(:avg, :cnt), ref: ref)
+            ]
+          end
+
+          def benchmark
+            require 'benchmark'
+            Benchmark
+          end
+
+          def bench
+            @bench ||= {}
+          end
+
+          def bench_add_mem(ref, mem)
+            bench_data_push(bench_get(ref)[:mem], mem)
+          end
+
+          def bench_add_time(ref, time)
+            bench_data_push(bench_get(ref)[:time], time)
+          end
+
+          def bench_get(ref)
+            bench[ref] ||= {
+              time: bench_data,
+              mem:  bench_data
+            }
+          end
+
+          def bench_data
+            {
+              avg: nil,
+              cnt: 0
+            }
+          end
+
+          def bench_data_push(data, value)
+            total       = value + ( (data[:avg] || 0) * data[:cnt])
+            data[:cnt] += 1
+            data[:avg]  = (total / data[:cnt]).round(3)
+            data
+          end
+
+          def bench_str_mem(mem, count = nil, ref: nil, reffix: false)
+            ref = reffix ? ref : nil
+            msg = [ref, 'Memory'].compact.join(' -- ')
+            cnt = count ? " (cnt: #{count})" : ''
+            "#{msg}: #{mem} MB#{cnt}"
+          end
+
+          def active_support_duration?
+            return false unless Kernel.const_defined?(:ActiveSupport)
+            ActiveSupport.const_defined?(:Duration, false)
+          end
+
+          def bench_str_time(time, count = nil, ref: nil, reffix: false)
+            ref      = reffix ? ref : nil
+            msg      = [ref, 'Time'].compact.join(' -- ')
+            total    = (time * count).round(2)
+            str_desc = ''
+            if active_support_duration? && total >= 60
+              duration = ActiveSupport::Duration.build(total.round)
+              str_desc = ": #{duration_to_s(duration)}"
+            end
+            cnt      = count ? " (cnt: #{count}; sum: #{total} s#{str_desc})" : ''
+            "#{msg}: #{time} s#{cnt}"
+          end
+
+          def duration_to_s(value)
+            return "" unless active_support_duration?
+            return "" if value.nil?
+
+            raise ArgumentError, "Expecint ActiveSupport::Duration. Given: #{value.class}" unless value.is_a?(ActiveSupport::Duration)
+            parts = value.parts.map {|pair| pair.reverse.join(" ")}
+            return parts.first if parts.length == 1
+            [parts[..-2].join(", "), parts.last].join(" and ")
+          end
+
+          # @return [Integer] total memory used by this process in KB
+          def memory_usage
+            if Gem.win_platform?
+              wmem = `wmic process where processid=#{Process.pid} get WorkingSetSize | findstr "[0-9]"`
+              return 0 unless wmem
+              wmem.lines.first.chop.strip.to_i / 1024.0
+            else
+              `ps -o rss= -p #{Process.pid}`.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/concerns.rb

@@ -0,0 +1,10 @@
+module Ecoportal
+  module API
+    module Common
+      module Concerns
+      end
+    end
+  end
+end
+
+require 'ecoportal/api/common/concerns/benchmarkable'

data/lib/ecoportal/api/common/content/array_model.rb

@@ -7,13 +7,9 @@ module Ecoportal
         #   - Its purpose is to handle an Array of basic objects (i.e. `Date`, `String`, `Number`)
         class ArrayModel < Content::DoubleModel
           class TypeMismatchedComparison < StandardError
-            def initialize (this: nil, that: msg = "Trying to compare objects with different behavior.")
-              if this
-                msg += " From object with 'order_matters: #{this.order_matters?}' and 'uniq: #{this.uniq?}'."
-              end
-              if that
-                msg += " To object where 'order_matters: #{that.order_matters?}' and 'uniq: #{that.uniq?}'."
-              end
+            def initialize(this: nil, that: msg = "Trying to compare objects with different behavior.")
+              msg += " From object with 'order_matters: #{this.order_matters?}' and 'uniq: #{this.uniq?}'." if this
+              msg += " To object where 'order_matters: #{that.order_matters?}' and 'uniq: #{that.uniq?}'."  if that
               super(msg)
             end
           end
@@ -27,23 +23,37 @@ module Ecoportal
             # @param b [ArrayModel]
             # @return [Boolean] `true` if both elements have same behaviour
             def same_type?(a, b)
-              raise "To use this comparison both objects should be `ArrayModel`" unless a.is_a?(ArrayModel) && b.is_a?(ArrayModel)
+              msg = "To use this comparison both objects should be `ArrayModel`"
+              raise msg unless a.is_a?(ArrayModel) && b.is_a?(ArrayModel)
               (a.order_matters? == b.order_matters?) && (a.uniq? == b.uniq?)
             end
           end
 
           inheritable_class_vars :order_matteres, :uniq
 
-          def initialize(doc = [], parent: self, key: nil, read_only: false)
+          def initialize(doc = [], parent: self, key: nil, read_only: self.class.read_only?)
             super(doc, parent: parent, key: key, read_only: read_only)
           end
 
-          def order_matters?; self.class.order_matters; end
-          def uniq?;          self.class.uniq;          end
+          def order_matters?
+            self.class.order_matters
+          end
+
+          def uniq?
+            self.class.uniq
+          end
+
+          def length
+            count
+          end
 
-          def length;   count;      end
-          def empty?;   count == 0; end
-          def present?; count > 0;  end
+          def empty?
+            count&.zero?
+          end
+
+          def present?
+            count&.positive?
+          end
 
           def each(&block)
             return to_enum(:each) unless block
@@ -66,10 +76,10 @@ module Ecoportal
             _items.slice(0..-1)
           end
 
-          # @param value [Object, Array<Object>, ArrayModel] the value(s) of the new object
+          # @param other [Object, Array<Object>, ArrayModel] the value(s) of the new object
           # @return [ArrayModel] a new object with the current class
-          def new_from(value)
-            self.class.new(into_a(value))
+          def new_from(other)
+            self.class.new(into_a(other))
           end
 
           # @return [ArrayModel] a copy of the current object
@@ -93,28 +103,28 @@ module Ecoportal
           # @param pos [Integer] the position of the element
           # @param value [String, Date, Number] the element
           # @return [Date, String, Number]
-          def []=(post, value)
+          def []=(pos, value)
             _items[pos] = value
             on_change
             self[pos]
           end
 
           # Compares with an `Array` or another `ArrayModel`
-          # @param a [ArrayModel, Array]
-          def ==(a)
-            return true if self.equal?(a)
-            return false unless (a.class == self.class) || a.is_a?(Array)
-            case a
+          # @param other [ArrayModel, Array]
+          def ==(other)
+            return true  if equal?(other)
+            return false unless (other.class == self.class) || other.is_a?(Array)
+
+            case other
             when Array
-              self == new_from(a)
+              self == new_from(other)
             when ArrayModel
-              return true if
-              raise TypeMismatchedComparison.new(this: self, that: a) unless self.class.same_type?(self, a)
+              raise TypeMismatchedComparison.new(this: self, that: other) unless self.class.same_type?(self, other)
 
-              if self.order_matters?
-                _items == a.to_a
+              if order_matters?
+                _items == other.to_a
               else
-                (_items - a.to_a).empty? && (a.to_a - _items).empty?
+                (_items - other.to_a).empty? && (other.to_a - _items).empty?
               end
             end
           end
@@ -154,11 +164,10 @@ module Ecoportal
           end
 
           # Resets the `Array` by keeping its reference and adds the value(s)
-          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be added
-          # @param values [Array]
-          def <(values)
+          # @param other [Object, Array<Object>, ArrayModel] the value(s) to be added
+          def <(other)
             _items.clear
-            self << values
+            self << other
           end
 
           # Clears the `Array` keeping its reference
@@ -169,25 +178,25 @@ module Ecoportal
           end
 
           # Concat to new
-          def +(value)
-            new_from(self.to_a + into_a(value))
+          def +(other)
+            new_from(to_a + into_a(other))
           end
 
           # Join
-          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be joined
+          # @param other [Object, Array<Object>, ArrayModel] the value(s) to be joined
           # @return [ArrayModel] a new object instance with the intersection done
-          def |(value)
-            new = new_from(value) - self
-            new_from(to_a + new.to_a)
+          def |(other)
+            oth = new_from(other) - self
+            new_from(to_a + oth.to_a)
           end
 
           # Intersect
-          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be deleted
+          # @param other [Object, Array<Object>, ArrayModel] the value(s) to be deleted
           # @return [ArrayModel] a new object instance with the intersection done
-          def &(value)
-            self.dup.tap do |out|
-              self.dup.tap do |delta|
-                delta.delete!(*into_a(value))
+          def &(other)
+            dup.tap do |out|
+              dup.tap do |delta|
+                delta.delete!(*into_a(other))
                 out.delete!(*into_a(delta))
               end
             end
@@ -196,9 +205,9 @@ module Ecoportal
           # Subtract
           # @param value [Object, Array<Object>, ArrayModel] the value(s) to be deleted
           # @return [ArrayModel] a **copy** of the object with the elements subtracted
-          def -(value)
-            self.dup.tap do |copy|
-              copy.delete!(*into_a(value))
+          def -(other)
+            dup.tap do |copy|
+              copy.delete!(*into_a(other))
             end
           end
 
@@ -206,7 +215,7 @@ module Ecoportal
           def delete!(*values)
             values.map do |v|
               deletion!(v)
-            end.tap do |r|
+            end.tap do |_r|
               on_change
             end
           end
@@ -216,43 +225,41 @@ module Ecoportal
           # @param val1 [Object] the first value to swap
           # @param val2 [Object] the second value to swap
           # @return [Integer] the new of `value1`, `nil` if it wasn't moved
-          def swap(value1, value2)
-            index(value2).tap do |dest|
-              if dest && pos = index(value1)
-                _items[dest] = value1
-                _items[pos]  = value2
+          def swap(val_1, val_2)
+            index(val_2).tap do |dest|
+              if dest && (pos = index(val_1))
+                _items[dest] = val_1
+                _items[pos]  = val_2
               end
             end
           end
 
           def insert_one(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
-            i = index(value)
-            return i if (i && uniq?)
-            pos = case
-                  when used_param?(pos) && pos
-                    pos
-                  when used_param?(before) && before
-                    index(before)
-                  when used_param?(after) && after
-                    if i = index(after) then i + 1 end
-                  end
+            idx = index(value)
+            return idx if idx && uniq?
+
+            pos =
+              if used_param?(pos) && pos
+                pos
+              elsif used_param?(before) && before
+                index(before)
+              elsif used_param?(after) && after
+                if (idx = index(after)) then idx + 1 end
+              end
 
+            # use last position as default
             pos ||= length
-            pos.tap do |i|
+            pos.tap do |_i|
               _items.insert(pos, value)
               on_change
             end
           end
 
           # TODO
-          def move(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
-            if i = index(value)
-              unless i == pos
-
-                on_change
-              end
-              pos
-            end
+          def move(value, pos: NOT_USED, _before: NOT_USED, _after: NOT_USED)
+            return    unless (idx = index(value))
+            on_change unless idx == pos
+            pos
           end
 
           protected
@@ -270,13 +277,9 @@ module Ecoportal
           end
 
           def deletion!(value)
-            if !uniq?
-              if i = _items.index(value)
-                _items.slice!(i)
-              end
-            else
-              _items.delete(value)
-            end
+            return _items.delete(value) if uniq?
+            return                      unless (idx = _items.index(value))
+            _items.slice!(idx)
           end
         end
       end