ecoportal-api-v2 1.1.7 → 2.0.0

data/ecoportal-api-v2.gemspec

@@ -1,5 +1,4 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "ecoportal/api/v2_version"
 
@@ -9,25 +8,27 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Oscar Segura"]
   spec.email         = ["rien@ecoportal.co.nz", "oscar@ecoportal.co.nz", "bozydar@ecoportal.co.nz"]
 
-  spec.summary       = %q{A collection of helpers for interacting with the ecoPortal MS's V2 API}
+  spec.summary       = "A collection of helpers for interacting with the ecoPortal MS's V2 API"
   spec.homepage      = "https://www.ecoportal.com"
   spec.licenses      = %w[MIT]
 
-  spec.required_ruby_version = '>= 2.7.2'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.required_ruby_version = '>= 3.2.2'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler",   ">= 2.4.12", "< 3"
-  spec.add_development_dependency "rspec",     ">= 3.12.0", "< 4"
-  spec.add_development_dependency "rake",      ">= 13.0.3", "< 14"
-  spec.add_development_dependency "yard",      ">= 0.9.34", "< 1"
-  spec.add_development_dependency "redcarpet", ">= 3.6.0",  "< 4"
-  spec.add_development_dependency "pry"      , ">= 0.14"
+  spec.add_development_dependency "pry"      , '>= 0.14'
+  spec.add_development_dependency "rake",      '>= 13.0.3', "< 14"
+  spec.add_development_dependency "redcarpet", '>= 3.6.0',  "< 4"
+  spec.add_development_dependency "rspec",     '>= 3.12.0', "< 4"
+  spec.add_development_dependency "yard",      '~>  0.9.34'
 
-  spec.add_dependency 'ecoportal-api', '>= 0.9.6', '< 0.10'
+  spec.add_dependency 'ecoportal-api', '~> 0.10'
+  spec.add_dependency 'mime-types',    '~> 3.5', '>= 3.5.2'
 end

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

@@ -14,59 +14,63 @@ module Ecoportal
             @benchmark_enabled
           end
 
-          def benchmarking(ref = nil, print: false)
+          def benchmarking(ref = nil, units: 1, print: false, &block)
             return yield unless benchmark_enabled?
-            benchmark_mem(ref, print: false) do
-              benchmark_time(ref, print: false) do
-                yield
-              end
+            benchmark_mem(ref, units: units, print: false) do
+              benchmark_time(ref, units: units, print: false, &block)
             end.tap do
               puts "\n#{bench_summary_ref(ref)}" if print
             end
           end
 
-          def benchmark_mem(ref = nil, print: false)
+          def benchmark_mem(ref = nil, units: 1, 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)
+              bench_add_mem(ref, mb_footprint, units: units)
               puts bench_str_mem(mb, ref: ref, reffix: true) if print
             end
           end
 
-          def benchmark_time(ref = nil, print: false)
+          def benchmark_time(ref = nil, units: 1, 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)
+              bench_add_time(ref, time, units: units)
               puts bench_str_time(time, ref: ref, reffix: true) if print
             end
           end
 
           def benchmark_summary(ref = nil)
-            return '' unless benchmark_enabled?
+            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)
+            bench.keys.each_with_object([]) do |rf, out|
+              out << bench_summary_ref(rf)
             end.join("\n")
           end
 
           def bench_summary_ref(ref = nil)
             ref_lines = bench_summary_ref_lines(ref)
-            "- #{ref}\n" + "  • " + ref_lines.join("\n  • ")
+            msg =  "- #{ref}\n"
+            msg << "  • "
+            msg << ref_lines.join("\n  • ")
+            msg
           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)
+              bench_str_time(*ref_bench[:time].values_at(:avg, :cnt, :last), ref: ref),
+              bench_str_mem(*ref_bench[:mem].values_at(:avg, :cnt, :last), ref: ref)
             ]
           end
 
@@ -79,12 +83,12 @@ module Ecoportal
             @bench ||= {}
           end
 
-          def bench_add_mem(ref, mem)
-            bench_data_push(bench_get(ref)[:mem], mem)
+          def bench_add_mem(ref, mem, units: 1)
+            bench_data_push(bench_get(ref)[:mem], mem, units: units)
           end
 
-          def bench_add_time(ref, time)
-            bench_data_push(bench_get(ref)[:time], time)
+          def bench_add_time(ref, time, units: 1)
+            bench_data_push(bench_get(ref)[:time], time, units: units)
           end
 
           def bench_get(ref)
@@ -96,50 +100,58 @@ module Ecoportal
 
           def bench_data
             {
-              avg: nil,
-              cnt: 0
+              avg:  nil,
+              cnt:  0,
+              last: nil
             }
           end
 
-          def bench_data_push(data, value)
-            total       = value + ( (data[:avg] || 0) * data[:cnt])
-            data[:cnt] += 1
+          def bench_data_push(data, value, units: 1)
+            total       = value + ((data[:avg] || 0) * data[:cnt])
+            data[:last] = value.round(3)
+            data[:cnt] += units
             data[:avg]  = (total / data[:cnt]).round(3)
             data
           end
 
-          def bench_str_mem(mem, count = nil, ref: nil, reffix: false)
-            ref = reffix ? ref : nil
+          def bench_str_mem(mem, count = nil, last = nil, ref: nil, reffix: false)
+            ref = nil unless reffix
             msg = [ref, 'Memory'].compact.join(' -- ')
-            cnt = count ? " (cnt: #{count})" : ''
+            cnt = count ? " (cnt: #{count}; lst: #{last} MB)" : ''
             "#{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
+          def bench_str_time(time, count = nil, last = nil, ref: nil, reffix: false)
+            ref      = nil unless reffix
             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)}"
+              str_desc = " > #{duration_to_s(duration)}"
             end
-            cnt      = count ? " (cnt: #{count}; sum: #{total} s#{str_desc})" : ''
+
+            cnt      = count ? " (cnt: #{count}; lst: #{last} s ; sum: #{total} s#{str_desc})" : ''
             "#{msg}: #{time} s#{cnt}"
           end
 
           def duration_to_s(value)
-            return "" unless active_support_duration?
-            return "" if value.nil?
+            return '' unless active_support_duration?
+            return '' if value.nil?
+
+            msg = "Expecint ActiveSupport::Duration. Given: #{value.class}"
+            raise ArgumentError, msg unless value.is_a?(ActiveSupport::Duration)
 
-            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
 
@@ -148,6 +160,7 @@ module Ecoportal
             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

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

@@ -0,0 +1,41 @@
+module Ecoportal
+  module API
+    module Common
+      module Concerns
+        module Threadable
+          private
+
+          def new_thread(threads, max: 20, &block)
+            if max == 1
+              yield
+              return []
+            end
+
+            threads.shift.join if threads.count >= max
+            threads << Thread.new(&block)
+          end
+
+          def mutex(key = :general)
+            require 'thread'
+            key           = key.to_sym
+            @mutex      ||= {}
+            @mutex[key] ||= Mutex.new
+          end
+
+          def with_preserved_thread_globals(abort: false, report: true)
+            mutex(:thread_globals).synchronize do
+              aux_thr_aoe = Thread.abort_on_exception
+              aux_thr_roe = Thread.report_on_exception
+              Thread.abort_on_exception  = abort
+              Thread.report_on_exception = report
+              yield
+            ensure
+              Thread.abort_on_exception  = aux_thr_aoe
+              Thread.report_on_exception = aux_thr_roe
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,4 +7,5 @@ module Ecoportal
   end
 end
 
+require 'ecoportal/api/common/concerns/threadable'
 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
@@ -26,8 +22,9 @@ module Ecoportal
             # @param a [ArrayModel]
             # @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)
+            def same_type?(a, b) # rubocop:disable Naming/MethodParameterName
+              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
@@ -38,15 +35,29 @@ module Ecoportal
             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 empty?;   count == 0; end
-          def present?; count > 0;  end
+          def length
+            count
+          end
+
+          def empty?
+            count&.zero?
+          end
+
+          def present?
+            count&.positive?
+          end
 
           def each(&block)
             return to_enum(:each) unless block
+
             _items.each(&block)
           end
 
@@ -66,10 +77,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 +104,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 +165,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 +179,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 +206,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 +216,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 +226,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
@@ -266,17 +274,15 @@ module Ecoportal
           def into_a(value)
             raise "Can't convert to 'Array' a 'Hash', as is a key_value pair Enumerable" if value.is_a?(Hash)
             return value.to_a.slice(0..-1) if value.is_a?(Enumerable)
+
             [].push(value).compact
           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