cotcube-helpers 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cec4f9d660486e17a4ff9ef38f53ffd1a5089de00ecbcdadb016b80dbc4231f9
-  data.tar.gz: 90943be69de4e059082d49070741b9689cd714a5a88a4b8ead2dea74ab4f3017
+  metadata.gz: 0417adfcb0f782bfa9e783dbd1c673a489fca39ce9a0f14fa965eb47aaa64b11
+  data.tar.gz: 1b14e149cc6b1bd437d1413dfa49b461c798868959cf97b164a0b3a2e1f72889
 SHA512:
-  metadata.gz: bf6306e1baaadfe9fa6f6b4533d2bfb0c31fc464ffa288368d3e47a22f76c1db7a1c48470aa83970e52752b4a911a7b60f759ee75495df43f093661274c13f0c
-  data.tar.gz: 6ea7ccc812fd160479f9519532669db81fbf4311fcb6335b841d738bcd81c86e922c994bb005e56c543b4cf0cd3f1d7a4a92db1ad7b52e5ac4d770c6932139cb
+  metadata.gz: c2babf733929f4ca0705ac2018b075e3b62df051c4918d01fcc6c11b49a7cad2ee68fd8ef26504edc5678c3057a97092de252a34cec2a953f638cd9262c2e65d
+  data.tar.gz: 1d9e367613f5b373c73cada786dee68d4e5ccc965573373b39d6419433a5f8131bc553773279d7ba58f2706a63be474448e15cc1e7bce1da63278ad384abeee0

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,28 @@
+## 0.1.6 (January 15, 2021)
+  - removing :ranges from Range#select_within
+  - Added Array#select_right_by
+
+## 0.1.5.4 (January 02, 2021)
+
+
+## 1.5.1.3 (January 02, 2021)
+  - hotfixing the hotfix (hello CI tools, c ya coming)
+
+## 1.5.1.2 (January 02, 2021)
+  - hotfix problem in Range.to_time_intervals
+
+## 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)
 

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/README.md

@@ -12,7 +12,7 @@ Returns the array compacted--or just nil, when the result is empty?
 
 This is a rather old implementation. Most probably something I developed before I met Array#group\_by.
 
-##### pairwise(&block) / triplewise(&block)
+##### pairwise(&block) / one_by_one(&block)
 
 Yields block on each consecutive pair of the array, hence returning array.size-1 results.
 
@@ -41,17 +41,18 @@ Uses the range of *date alikes* delivered to create an Array of time periods of
 
 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
-accomplished by the fact, that Sunday is wday==0. If you want to use ranges, just send a an array
+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..143999,   # Sun 5pm .. Mon 4pm
-      147600..230399,   # Mon 5pm .. Tue 4pm
-      234000..316799,   # ...
-      320400..403199,
-      406800..489599
+       61200...144000,   # Sun 5pm .. Mon 4pm
+      147600...230400,   # Mon 5pm .. Tue 4pm
+      234000...316800,   # ...
+      320400...403300,
+      406800...489600
     ]
 ```
 
@@ -63,18 +64,19 @@ of ranges, providing seconds starting at Sunday morning midnight. Here is the de
 
 ##### 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 subpattern
-based on the the giving minimum. E.g. 'a', 'ab' .. 'abcd' will match sub(1){'abcd'}
+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'}
 
-The recommended use within evaluating user input, where abbreviation of incoming commands
+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 a group of patterns to, like
-sub(2){[:hyper,:mega]}, what will respond truthy to "hy" and "meg" but not to "m" or "hypo"
+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*
+*Paired with keystroke() it allows an easy build of an inputhandler.*
 
 #### SimpleOutput
 
@@ -90,7 +92,7 @@ flow like logs, to pause and continue output.
 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*
+*Paired with subpattern it allows an easy build of an InputHandler.*
 
 #### Parallelize
 
@@ -98,4 +100,8 @@ of the keystroke.
 
 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.3
+0.1.6

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,24 +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,
-      :reduce,
-      :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,48 @@ 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
+
+  def select_right_by(inclusive: false, exclusive: false, initial: [], &block)
+    # unless range.is_a? Range and
+    #       (range.begin.nil? or range.begin.is_a?(Integer)) and
+    #       (range.end.nil? or range.end.is_a?(Integer))
+    #  raise ArgumentError, ":range, if given, must be a range of ( nil|Integer..nil|Integer), got '#{range}'"
+    # end
+
+    raise ArgumentError, 'No block given.' unless block.is_a? Proc
+
+    inclusive = true unless exclusive
+    if inclusive && exclusive
+      raise ArgumentError,
+            "Either :inclusive or :exclusive must remain falsey, got '#{inclusive}' and '#{exclusive}'"
+    end
+
+    index = find_index { |obj| block.call(obj) }
+
+    self[((inclusive ? index : index + 1)..)]
+  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,30 +1,28 @@
+# frozen_string_literal: true
+
+# TODO: Missing top level documentation!
 module Cotcube
+  # TODO: Missing top level documentation!
   module Helpers
-
-    def parallelize(ary, processes: 1, threads: 1, progress: "", &block)
-      chunks = [] 
-      if [0,1].include? processes 
-        result = Parallel.map(ary, in_threads: threads) {|u| v = yield(u); v}
-      elsif [0,1].include?(threads)
-        result = 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) {|chunk| chunks << chunk }
-        if progress == "" 
-          result = Parallel.map(chunks, :in_processes => processes) do |chunk|
-            Parallel.map(chunk, in_threads: threads) do |unit|
-              yield(unit) 
-            end
-          end
-        else
-          result = Parallel.map(chunks, :progress => progress, :in_processes => processes) do |chunk|
-            Parallel.map(chunk, in_threads: threads) 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
       result
     end
-
   end
 end

data/lib/cotcube-helpers/range_ext.rb

@@ -1,52 +1,96 @@
+# 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,
+                        debug: false)
+    unless step.is_a? ActiveSupport::Duration
+      raise ArgumentError,
+            ":step must be a 'ActiveSupport::Duration', like '15.minutes', but '#{step}' is a '#{step.class}'"
+    end
+    unless [15.minutes, 60.minutes, 1.hour, 1.day].include? step
+      raise ArgumentError, 'Sorry, currently supporting only 15.minutes, 1.hour, 1.day as :step'
+    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
-
-    ##### 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)}
-    #
-    ####################<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
-
-    # sub-day is checked for DST and filtered along provided ranges
-    starting_with_dst = result.first.dst?
-    seconds_since_sunday_morning = lambda {|x| x.wday * 86400 + x.hour * 3600 + x.min * 60 + x.sec}
-    ranges ||= [
-       61200..143999,   # Sun 5pm .. Mon 4pm
-      147600..230399,   # Mon 5pm .. Tue 4pm
-      234000..316799,   # ...
-      320400..403199,
-      406800..489599
-    ]
-
-    # if there was a change towards daylight saving time, substract 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
-      else
-	time
+    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
+
+    # here sub-day and super-day need to be distinguished, as they react differently to daylight time
+    # for super-day, just return an array containing all calendar days
+    if step.to_i >= 1.day
+      (starting.to_date..ending.to_date).to_a.map(&:to_datetime)
+    else
+
+      # sub-day is checked for DST
+      # noinspection RubyNilAnalysis
+      actual_starting   = starting.to_time.to_i
+      actual_ending     = ending.to_time.to_i
+      actual_ending -= 3600 if starting.dst? && (not ending.dst?)
+      actual_ending += 3600 if ending.dst? && (not starting.dst?)
+
+      ##### The following is the actual big magic line, as it creates the raw target array:
+      #
+      result = (actual_starting..actual_ending).step(step).to_a.map { |x| timezone.at(x) }
+      #
+      # ###################<3##
+
+      # 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 ||= [
+      #  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, subtract 1 hour, otherwise add 1 hour
+      result.map! do |time|
+        print "#{time}\t" if debug
+        if (not starting.dst?) && time.dst?
+          time -= 3600
+          print "Time reduced (not starting_DST, but current\t" if debug
+        elsif starting.dst? && (not time.dst?)
+          time += 3600
+          print "Time extended (starting DST, but not current\t" if debug
+        end
+        puts "#{time} " if debug
+        time
+      end
+
+      result # .select_within(ranges: ranges) { |x| x.to_datetime.to_seconds_since_sunday_morning }
     end
-    return result if ranges.empty? 
-    result.select{|x| ranges.map{|r| r.include? seconds_since_sunday_morning.call(x)}.reduce(:|) }
   end
 end

data/lib/cotcube-helpers/reduce.rb

@@ -1,39 +1,52 @@
+# frozen_string_literal: true
+
 module Cotcube
+  # Missing top level documentation
   module Helpers
-    def reduce(bars: , to: nil, datelike: :datetime, &block)
-      terminators = case to
-                   when 1.day
-                     [:last, :beginning_of_day]
-                   when 1.hour
-                     [:first, :beginning_of_hour]
-                   else 
-                     raise ArgumentError, "Currently supported are reductions to '1.hour' and '1.day'"
-                   end
-      determine_datelike = lambda {|ary| ary.send(terminators.first)[datelike].send(terminators.last) }
-      make_new_bar = lambda do |ary, date = nil|
-	result = {
-	  symbol:   ary.first[:symbol],
-          datetime: determine_datelike.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(:+)
-	}
-	result.map{|k,v| result.delete(k) if v.nil?}
-	result
+    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     = [ ]
+      collector = []
+      final     = []
       bars.each do |bar|
-        if collector.empty? or block.call(collector.last, bar)
-	  collector << bar
-	else
+        if collector.empty? || block.call(collector.last, bar)
+          collector << bar
+        else
           new_bar = make_new_bar.call(collector)
-	  final << new_bar
-	  collector = [ bar ]
-	end
+          final << new_bar
+          collector = [bar]
+        end
       end
       new_bar = make_new_bar.call(collector)
       final << new_bar
@@ -41,4 +54,3 @@ module Cotcube
     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,11 +1,13 @@
 # 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})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.6
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-22 00:00:00.000000000 Z
+date: 2021-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,6 +82,7 @@ files:
 - 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