cotcube-helpers 0.1.1 → 0.1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 819dae89b6428b3cec4226d40f4afa3b790108b2e7a0f8ff9784b49532a894e9
-  data.tar.gz: 2e4823aa3a4f86efa8d94ff07be306cb991a7bd08504cae0209025127e67d472
+  metadata.gz: e3d088e43fd870ff67a238501fd680f1c5688c7108bc90ace92e01cd8c33627b
+  data.tar.gz: 72b07a1f0e502a29e9cb818d62a8d398fe5e094efade358300eab4578b64ceae
 SHA512:
-  metadata.gz: 46647ed87173997191a22b05072e0ce4b53bba9be4a222d86a92605bf35d9c3d4d33ed0381c6ab3e46106e21851d10f4b9b3b178136bf780bdcf89ce055cc469
-  data.tar.gz: 7acdf173d676c7db61e6e2a1aa3111b22ae00c55768611d7355b4f13216c225f9e5ef9204a23796694b95d21d955e7a53e72d3b62b390e3735786aceb0b67801
+  metadata.gz: 7b92ec6b178328bd6944f61828848d1d1c4aa164e9a3680054345189503d237a809ea082441eeab476ff693eeebdf5bf27bec300b3606af589598da946ce1c0a
+  data.tar.gz: 00d63e82c5ed3cfcc9986f4ec3222e2282a692ed0ad54602cb4e212b9285d8c51182d9c87a4e8b9672d2f305409b6f01d27437b73aa40df6872a35e4ea962b8e

data/.irbrc.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 def verbose_toggle
-  irb_context.echo ? irb_context.echo = false : irb_context.echo = true
+  irb_context.echo = (irb_context.echo ? false : true)
 end
 
 alias vt verbose_toggle

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 0.1.5.1 (January 02, 2021)
+  - Hotfixing parallelize
+
+## 0.1.5 (January 02, 2021)
+  - applied new datetime helper to Range#to_time_intervals
+  - added new DateTime extension, containing 'to_seconds_since_sunday_morning'
+  - added #select_within to array_ext
+
+## 0.1.4 (December 27, 2020)
+  - applied cops
+  - added README for reduce; minor changes
+
+## 0.1.3 (December 22, 2020)
+  - added .reduce(bars: , to: ,*args, &block) to reduce a series of bars to a higher timeframe (though only 1hour and 1day are supported yet)
+
+## 0.1.2 (December 21, 2020)
+  - minor changes
+  - minor fix to parallelize and application of positional arguments
+  - added license and README
+
 ## 0.1.1 (December 21, 2020)
 
 

data/Gemfile

@@ -1,5 +1,6 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bitangent.gemspec
 gemspec
-

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Benjamin L. Tischendorf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+## Cotcube::Helpers
+
+Just a collection of helpers not fitting into other repositories of the Cotcube suite. Also usable aside of Cotcube. Where appropriate, these are provided as core\_extensions, otherwise within the model Cotcube::Helpers
+
+#### Extending Array
+
+##### compact\_or\_nil
+
+Returns the array compacted--or just nil, when the result is empty?
+
+##### split\_by(attr)
+
+This is a rather old implementation. Most probably something I developed before I met Array#group\_by.
+
+##### pairwise(&block) / one_by_one(&block)
+
+Yields block on each consecutive pair of the array, hence returning array.size-1 results.
+
+##### triplewise(&block)
+ 
+Yields block on each consecutive triple of the array, hence returning array.size-2 results.
+
+#### Extending Enumerator
+
+##### shy\_peek
+
+Peeks into the successor without raising if there is none available--returning nil instead.
+
+#### Extending Hash
+
+##### keys\_to\_sym
+
+Transforms the keys of a Hash (recursivly for subsequent Arrays and Hashes) into symbols.
+
+#### Extending Range
+
+##### to\_time\_intervals(timezone: Time.find\_zone('America/Chicago'), step:, ranges: nil)
+
+Uses the range of *date alikes* delivered to create an Array of time periods of length :step
+(which is a ActiveSupport::Duration, e.g. 5.minutes or 1.hour). 
+
+When the step is sub-day, the periods are cleared for DST-changes.
+
+When ranges are nil, only periods are returned that are within the full trading hours.  
+
+This is implemented with DateTime's propery, that Sunday is wday==0. If you want to use ranges, just send a an array
+of ranges, providing seconds starting at Sunday morning midnight. Here is the default as example:
+
+```
+    ranges ||= [
+       61200...144000,   # Sun 5pm .. Mon 4pm
+      147600...230400,   # Mon 5pm .. Tue 4pm
+      234000...316800,   # ...
+      320400...403300,
+      406800...489600
+    ]
+```
+
+#### Extending String
+
+##### is\_valid\_json?
+
+#### Subpattern
+
+##### sub(minimum: 1) { [:hyper, :mega] }
+
+sub (should be 'subpattern', but too long) is for use in `case / when` statements.  
+It returns a lambda, that checks the *case'd* expression for matching subpatterns
+based on the the giving minimum. E.g. 'a', 'ab' .. 'abcd' .. 'abcd<any_garbage> will match sub(1){'abcd'}
+but only 'abc' and 'abcd' will match sub(3){'abcd'}
+
+It is developed for evaluating user input, where abbreviation of incoming commands
+is desirable (h for hoover and hyper, what will translate to sub(2){'hoover'} and sub(2){hyper})
+
+To extend functionality even more, it is possible to send array of patterns like
+sub(2){[:hyper,:mega]}, what will respond truthy to "hy" and "meg" but not to "m" or "hypo" (sadly, you can
+set `:minimum`  only once).
+
+*Paired with keystroke() it allows an easy build of an inputhandler.*
+
+#### SimpleOutput
+
+This is a very simple class, that mocks a more complex output handler. It provides puts, print,
+puts! and print!. The actual OutputHandler is another project that needs to be rewritten. Once
+that is done, SimpleOutput will be replaced. The new OutputHandler is a tool to handle information
+flow like logs, to pause and continue output.
+
+#### Input
+
+##### keystroke(quit: false)
+
+A version of STDIN.gets, that does not wait for pressing 'enter' but instantly returns the content
+of the keystroke. 
+
+*Paired with subpattern it allows an easy build of an InputHandler.*
+
+#### Parallelize
+
+##### parallelize(ary, processes: 1, threads: 1, progress: "", &block)
+
+Based on https://github.com/grosser/parallel, it is a quite convenient way to parallelize tasks. 
+
+#### Reduce
+
+##### reduce(bars: , to: nil, datelike: :datetime, &block)
+
+Given a series resp. an array of bars (a bar is a set of contract/symbol, datelike, OHLC, volume) respresenting periods of e.g. 1.minute or 15.minutes, these are 'reduced' to an new series of a higher timeframe like hours or days. More target periods might be added in the futures. 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.5.1

data/cotcube-helpers.gemspec

@@ -9,13 +9,13 @@ Gem::Specification.new do |spec|
   spec.summary       = 'Some helpers and core extensions as part of the Cotcube Suite.'
   spec.description   = 'Some helpers and core extensions as part of the Cotcube Suite...'
 
-  spec.homepage      = 'https://github.com/donkeybridge/'+ spec.name
+  spec.homepage      = "https://github.com/donkeybridge/#{spec.name}"
   spec.license       = 'BSD-4-Clause'
   spec.required_ruby_version = Gem::Requirement.new('~> 2.7')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri'] = spec.homepage + '/CHANGELOG.md'
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -28,7 +28,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activesupport'
 
-
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~>3.6'
   spec.add_development_dependency 'yard', '~>0.9'

data/lib/cotcube-helpers.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Naming/FileName
+# rubocop:enable Naming/FileName
 # frozen_string_literal: true
 
 require 'active_support'
@@ -10,22 +12,20 @@ require_relative 'cotcube-helpers/enum_ext'
 require_relative 'cotcube-helpers/hash_ext'
 require_relative 'cotcube-helpers/range_ext'
 require_relative 'cotcube-helpers/string_ext'
-require_relative 'cotcube-helpers/subpattern.rb'
+require_relative 'cotcube-helpers/datetime_ext'
+require_relative 'cotcube-helpers/subpattern'
 require_relative 'cotcube-helpers/parallelize'
 require_relative 'cotcube-helpers/simple_output'
 require_relative 'cotcube-helpers/input'
-
+require_relative 'cotcube-helpers/reduce'
 
 module Cotcube
   module Helpers
+    module_function :sub,
+                    :parallelize,
+                    :reduce,
+                    :keystroke
 
-    module_function :sub, 
-      :parallelize,
-      :keystroke
-
-
-    
     # please not that module_functions of source provided in private files must be published there
   end
 end
-

data/lib/cotcube-helpers/array_ext.rb

@@ -1,22 +1,25 @@
-class Array
+# frozen_string_literal: true
 
+# Monkey patching the Ruby Core class Array
+class Array
   # returns nil if the compacted array is empty, otherwise returns the compacted array
-  def compact_or_nil(*args, &block)
-    return nil if self.compact == [] 
-    yield self.compact
+  def compact_or_nil(*_args)
+    return nil if compact == []
+
+    yield compact
   end
 
   # sorts by a given attribute and then returns groups of where this attribute is equal
   # .... seems like some_array.group_by(&attr).values
   def split_by(attrib)
     res = []
-    sub = [] 
-    self.sort_by(&attrib).each do |elem|
-      if sub.empty? or sub.last[attrib] == elem[attrib]
+    sub = []
+    sort_by(&attrib).each do |elem|
+      if sub.empty? || (sub.last[attrib] == elem[attrib])
         sub << elem
       else
         res << sub
-        sub = [ elem ]
+        sub = [elem]
       end
     end
     res << sub
@@ -37,7 +40,7 @@ class Array
     end.compact
   end
 
-  alias_method :one_by_one, :pairwise
+  alias one_by_one pairwise
 
   # same as pairwise, but with arity of three
   def triplewise(&block)
@@ -47,7 +50,28 @@ class Array
     each_with_index.map do |_, i|
       next if i < 2
 
-      block.call(self[i - 2], self[i-1], self[i])
+      block.call(self[i - 2], self[i - 1], self[i])
     end.compact
   end
+
+  # selects all elements from array that fit in given ranges.
+  # if :attr is given, selects all elements, where elem[:attr] fit
+  # raises if elem.first[attr].nil?
+  def select_within(ranges:, attr: nil, &block)
+    unless attr.nil? || first[attr]
+      raise ArgumentError,
+            "At least first element of Array '#{first}' does not contain attr '#{attr}'!"
+    end
+    raise ArgumentError, 'Ranges should be an Array or, more precisely, respond_to :map' unless ranges.respond_to? :map
+    raise ArgumentError, 'Each range in :ranges should respond to .include!' unless ranges.map do |x|
+                                                                                      x.respond_to? :include?
+                                                                                    end.reduce(:&)
+
+    select do |el|
+      value = attr.nil? ? el : el[attr]
+      ranges.map do |range|
+        range.include?(block.nil? ? value : block.call(value))
+      end.reduce(:|)
+    end
+  end
 end

data/lib/cotcube-helpers/datetime_ext.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Monkey patching the Ruby class DateTime
+class DateTime
+  # based on the fact that sunday is 'wday 0' plus that trading week starts
+  #   sunday 0:00 (as trading starts sunday 5pm CT to fit tokyo monday morning)
+  def to_seconds_since_sunday_morning
+    wday * 86_400 + hour * 3600 + min * 60 + sec
+  end
+
+  alias to_sssm to_seconds_since_sunday_morning
+end

data/lib/cotcube-helpers/enum_ext.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
+# Monkey patching the Ruby Core class Enumerator
 class Enumerator
   def shy_peek
     begin
-      ret = self.peek
-    rescue
+      ret = peek
+    rescue StandardError
       ret = nil
     end
     ret
   end
 end
-

data/lib/cotcube-helpers/hash_ext.rb

@@ -1,14 +1,16 @@
-class Hash
+# frozen_string_literal: true
 
+# Monkey patching the Ruby Core class Hash
+class Hash
   def keys_to_sym
-    self.keys.each do |key| 
+    each_key do |key|
       case self[key].class.to_s
-      when "Hash"
+      when 'Hash'
         self[key].keys_to_sym
-      when "Array"
-        self[key].map {|el| el.is_a?(Hash) ? el.keys_to_sym : el}
+      when 'Array'
+        self[key].map { |el| el.is_a?(Hash) ? el.keys_to_sym : el }
       end
-      self[key.to_sym] = self.delete(key)
+      self[key.to_sym] = delete(key)
     end
     self
   end

data/lib/cotcube-helpers/input.rb

@@ -1,40 +1,44 @@
+# frozen_string_literal: true
+
+# Top level comment missing!
 module Cotcube
+  # noinspection ALL
   module Helpers
     def keystroke(quit: false)
       begin
         # save previous state of stty
         old_state = `stty -g`
         # disable echoing and enable raw (not having to press enter)
-        system "stty raw -echo"
-        c = STDIN.getc.chr
+        system 'stty raw -echo'
+        c = $stdin.getc.chr rescue '_' # rubocop:disable Style/RescueModifier
         # gather next two characters of special keys
-        if(c=="\e")
-          extra_thread = Thread.new{
-            c = c + STDIN.getc.chr
-            c = c + STDIN.getc.chr
-          }
+        if c == "\e"
+          extra_thread = Thread.new do
+            c += $stdin.getc.chr
+            c += $stdin.getc.chr
+          end
           # wait just long enough for special keys to get swallowed
           extra_thread.join(0.00001)
           # kill thread so not-so-long special keys don't wait on getc
           extra_thread.kill
         end
-      rescue => ex
-        puts "#{ex.class}: #{ex.message}"
-        puts ex.backtrace
+      rescue StandardError => e
+        puts "#{e.class}: #{e.message}"
+        puts e.backtrace
       ensure
         # restore previous state of stty
         system "stty #{old_state}"
       end
-      c.each_byte do |x| 
+      c.each_byte do |x| # rubocop:disable Lint/UnreachableLoop
         case x
         when 3
-          puts "Strg-C captured, exiting..."
+          puts 'Strg-C captured, exiting...'
           quit ? exit : (return true)
         when 13
-          return "_return_"
+          return '_return_'
         when 27
-          puts "ESCAPE gathered"
-          return "_esc_"
+          puts 'ESCAPE gathered'
+          return '_esc_'
         else
           return c
         end

data/lib/cotcube-helpers/parallelize.rb

@@ -1,33 +1,28 @@
+# frozen_string_literal: true
+
+# TODO: Missing top level documentation!
 module Cotcube
+  # TODO: Missing top level documentation!
   module Helpers
-
-    def parallelize(ary, opts = {}, &block)
-      processes =           opts[:processes].nil? ? 1  : opts[:processes]
-      threads_per_process = opts[:threads  ].nil? ? 1  : opts[:threads]
-      progress =            opts[:progress ].nil? ? "" : opts[:progress]
-      chunks = [] 
-      if processes == 0 or processes == 1
-        r = Parallel.map(ary, in_threads: threads_per_process) {|u| v = yield(u); v}
-      elsif [0,1].include?(threads_per_process)
-        r = Parallel.map(ary, in_processes: processes) {|u| v = yield(u)}
+    def parallelize(ary, processes: 1, threads: 1, progress: '', &block)
+      chunks = []
+      if [0, 1].include? processes
+        result = Parallel.map(ary, in_threads: threads, &block)
+      elsif [0, 1].include? threads
+        result = Parallel.map(ary, in_processes: processes, &block)
       else
-        ary.each_slice(threads_per_process) {|chunk| chunks << chunk }
-        if progress == "" 
-          r = Parallel.map(chunks, :in_processes => processes) do |chunk|
-            Parallel.map(chunk, in_threads: threads_per_process) do |unit|
-              yield(unit) 
-            end
-          end
-        else
-          r = Parallel.map(ary, :progress => progress, :in_processes => processes) do |chunk|
-            Parallel.map(chunk, in_threads: threads_per_process) do |unit|
-              yield(unit)
-            end
-          end
-        end
+        ary.each_slice(threads) { |chunk| chunks << chunk }
+        result = if progress == ''
+                   Parallel.map(chunks, in_processes: processes) do |chunk|
+                     Parallel.map(chunk, in_threads: threads, &block)
+                   end
+                 else
+                   Parallel.map(chunks, progress: progress, in_processes: processes) do |chunk|
+                     Parallel.map(chunk, in_threads: threads, &block)
+                   end
+                 end
       end
-      return r
+      result
     end
-
   end
 end

data/lib/cotcube-helpers/range_ext.rb

@@ -1,52 +1,88 @@
+# frozen_string_literal: true
+
+# Monkey patching the Ruby Core class Range
 class Range
-  def to_time_intervals(timezone: Time.find_zone('America/Chicago'), step:, ranges: nil)
+  def to_time_intervals(step:, timezone: Time.find_zone('America/Chicago'), ranges: nil)
+    unless step.is_a? ActiveSupport::Duration
+      raise ArgumentError,
+            ":step must be a 'ActiveSupport::Duration', like '15.minutes', but '#{step}' is a '#{step.class}'"
+    end
 
-    raise ArgumentError, ":step must be a 'ActiveSupport::Duration', like '15.minutes', but '#{step}' is a '#{step.class}'" unless step.is_a? ActiveSupport::Duration
+    valid_classes = [ActiveSupport::TimeWithZone, Time, Date, DateTime]
+    unless timezone.is_a? ActiveSupport::TimeZone
+      raise "Expecting 'ActiveSupport::TimeZone' for :timezone, got '#{timezone.class}"
+    end
 
-    valid_classes = [ ActiveSupport::TimeWithZone, Time, Date, DateTime ]
-    raise "Expecting 'ActiveSupport::TimeZone' for :timezone, got '#{timezone.class}" unless timezone.is_a? ActiveSupport::TimeZone
     starting = self.begin
     ending   = self.end
     starting = timezone.parse(starting) if starting.is_a? String
     ending   = timezone.parse(ending)   if ending.is_a?   String
-    raise ArgumentError, ":self.begin seems not to be proper time value: #{starting} is a #{starting.class}" unless valid_classes.include? starting.class
-    raise ArgumentError, ":self.end seems not to be proper time value: #{ending} is a #{ending.class}" unless valid_classes.include? ending.class
+    unless valid_classes.include? starting.class
+      raise ArgumentError,
+            ":self.begin seems not to be proper time value: #{starting} is a #{starting.class}"
+    end
+    unless valid_classes.include? ending.class
+      raise ArgumentError,
+            ":self.end seems not to be proper time value: #{ending} is a #{ending.class}"
+    end
 
-    ##### The following is the actual big magic line: 
-    # 
-    result    = (starting.to_time.to_i..ending.to_time.to_i).step(step).to_a.map{|x| timezone.at(x)}
+    ##### The following is the actual big magic line, as it creates the raw target array:
     #
-    ####################<3
-
+    result = (starting.to_time.to_i..ending.to_time.to_i).step(step).to_a.map { |x| timezone.at(x) }
+    #
+    # ###################<3##
 
     # with step.to_i >= 86400 we are risking stuff like 25.hours to return bogus
     # also notice: When using this with swaps, you will loose 1 hour (#f**k_it)
     #
     # eventually, for dailies and above, return M-F default, return S-S when forced by empty ranges
-    return result.select{|x| (not ranges.nil? and ranges.empty?) ? true : (not [6,0].include?(x.wday)) } if step.to_i >= 86400
+    if step.to_i >= 86_400
+      return result.select do |x|
+               (not ranges.nil?) && ranges.empty? ? true : (not [6, 0].include?(x.wday))
+             end
+    end
 
     # sub-day is checked for DST and filtered along provided ranges
+    # noinspection RubyNilAnalysis
     starting_with_dst = result.first.dst?
-    seconds_since_sunday_morning = lambda {|x| x.wday * 86400 + x.hour * 3600 + x.min * 60 + x.sec}
+
+    # The following lambda is completely misplaces here.
+    # It should probably relocated to Cotcube::Bardata
+    # NOTE: In this current version 12 belongs to it succeeding hour
+    #       i.e. 12am is right before 1am and 12pm right before 1pm
+    convert_to_sec_since = lambda do |clocking|
+      from_src, to_src = clocking.split(' - ')
+      regex = /^(?<hour>\d+):(?<minute>\d+)(?<morning>[pa]).?m.*/
+
+      from = from_src.match(regex)
+      to   = to_src.match(regex)
+
+      from_i = from[:hour].to_i * 3600 + from[:minute].to_i * 60 + (from[:morning] == 'a' ? 2 : 1) * 12 * 3600
+      to_i = to[:hour].to_i * 3600 + to[:minute].to_i * 60 + (to[:morning] == 'a' ? 2 : 3) * 12 * 3600
+
+      (0...5).to_a.map { |i| [from_i + i * 24 * 3600, to_i + i * 24 * 3600] }
+    end
+    convert_to_sec_since.call('9:00a.m - 5:00p.m.')
+
     ranges ||= [
-      61200..143999,  
-      147600..230399,
-      234000..316799,
-      320400..403199,
-      406800..489599
+      61_200...144_000,   # Sun 5pm .. Mon 4pm
+      147_600...230_400,  # Mon 5pm .. Tue 4pm
+      234_000...316_800,  # ...
+      320_400...403_200,
+      406_800...489_600
     ]
 
-    # if there was a change towards daylight saving time, substract 1 hour, otherwise add 1 hour
+    # if there was a change towards daylight saving time, subtract 1 hour, otherwise add 1 hour
     result.map! do |time|
-      if    not starting_with_dst and     time.dst?
-	time - 3600
-      elsif     starting_with_dst and not time.dst?
-	time + 3600
+      if (not starting_with_dst) && time.dst?
+        time - 3600
+      elsif starting_with_dst && (not time.dst?)
+        time + 3600
       else
-	time
+        time
       end
     end
-    return result if ranges.empty? 
-    result.select{|x| ranges.map{|r| r.include? seconds_since_sunday_morning.call(x)}.reduce(:|) }
+
+    result.select_within(ranges: ranges) { |x| x.to_datetime.to_seconds_since_monday_morning }
   end
 end

data/lib/cotcube-helpers/reduce.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Cotcube
+  # Missing top level documentation
+  module Helpers
+    def reduce(bars:, to: nil, date_alike: :datetime, &block)
+      case to
+      when :days
+        terminators = %i[last daily beginning_of_day]
+        block = proc { |c, b| c[:day] == b[:day] } unless block_given?
+      when :hours
+        terminators = %i[first hours beginning_of_hour]
+        block = proc { |c, b| c[:day] == b[:day] and c[:datetime].hour == b[:datetime].hour } unless block_given?
+      when :weeks
+        terminators = %i[first weeks beginning_of_week]
+        block = proc { |a, b| a[:datetime].to_datetime.cweek == b[:datetime].to_datetime.cweek } unless block_given?
+      when :months
+        terminators = %i[first months beginning_of_month]
+        block = proc { |a, b| a[:datetime].to_datetime.month == b[:datetime].to_datetime.month } unless block_given?
+      else
+        raise ArgumentError, 'Currently supported are reductions to :hours, :days, :weeks, :months '
+      end
+      determine_date_alike = ->(ary) { ary.send(terminators.first)[date_alike].send(terminators.last) }
+      make_new_bar = lambda do |ary, _date = nil|
+        result = {
+          contract: ary.first[:contract],
+          symbol: ary.first[:symbol],
+          datetime: determine_date_alike.call(ary),
+          day: ary.first[:day],
+          open: ary.first[:open],
+          high: ary.map { |x| x[:high] }.max,
+          low: ary.map { |x| x[:low] }.min,
+          close: ary.last[:close],
+          volume: ary.map { |x| x[:volume] }.reduce(:+),
+          type: terminators[1]
+        }
+        result.map { |k, v| result.delete(k) if v.nil? }
+        result
+      end
+      collector = []
+      final     = []
+      bars.each do |bar|
+        if collector.empty? || block.call(collector.last, bar)
+          collector << bar
+        else
+          new_bar = make_new_bar.call(collector)
+          final << new_bar
+          collector = [bar]
+        end
+      end
+      new_bar = make_new_bar.call(collector)
+      final << new_bar
+      final
+    end
+  end
+end

data/lib/cotcube-helpers/string_ext.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
+# Monkey patching the Ruby Core class String
 class String
-  def is_valid_json?
-     JSON.parse(self)
-     return true
-  rescue JSON::ParserError => e
-     return false
+  # ...
+  def valid_json?
+    JSON.parse(self)
+    true
+  rescue JSON::ParserError
+    false
   end
-end
 
+  alias is_valid_json? valid_json?
+end

data/lib/cotcube-helpers/subpattern.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
+# ...
 module Cotcube
+  # ...
   module Helpers
     # sub (should be 'subpattern', but too long) is for use in case / when statements
     #   it returns a lambda, that checks the case'd expression for matching subpattern
     #   based on the the giving minimum. E.g. 'a', 'ab' .. 'abcd' will match sub(1){'abcd'}
-    #   but only 'abc' and 'abcd' will match sub(3){'abcd'}
+    #   but only 'abc' and 'abcd' will match sub(3){'abcd'}.:
     #
     #   The recommended use within evaluating user input, where abbreviation of incoming commands
     #   is desirable (h for hoover and hyper, what will translate to sub(2){'hoover'} and sub(2){hyper})
     #
     #   To extend functionality even more, it is possible to send a group of patterns to, like
     #   sub(2){[:hyper,:mega]}, what will respond truthy to "hy" and "meg" but not to "m" or "hypo"
-    def sub(minimum = 1)
+    def sub(minimum: 1)
       pattern = yield
       case pattern
       when String, Symbol, NilClass

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.5.1
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-21 00:00:00.000000000 Z
+date: 2021-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -76,15 +76,19 @@ files:
 - ".irbrc.rb"
 - CHANGELOG.md
 - Gemfile
+- LICENSE.txt
+- README.md
 - VERSION
 - cotcube-helpers.gemspec
 - lib/cotcube-helpers.rb
 - lib/cotcube-helpers/array_ext.rb
+- lib/cotcube-helpers/datetime_ext.rb
 - lib/cotcube-helpers/enum_ext.rb
 - lib/cotcube-helpers/hash_ext.rb
 - lib/cotcube-helpers/input.rb
 - lib/cotcube-helpers/parallelize.rb
 - lib/cotcube-helpers/range_ext.rb
+- lib/cotcube-helpers/reduce.rb
 - lib/cotcube-helpers/simple_output.rb
 - lib/cotcube-helpers/string_ext.rb
 - lib/cotcube-helpers/subpattern.rb