tresse 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1837779d3e8be68176eb4fb52d2cc16d411ce24
-  data.tar.gz: 504b3c9a5c52290d7fd49bc9ddf24d685c4ea5be
+  metadata.gz: 07e2b40e7224b8da9af9768fb077d0a9552b04ba
+  data.tar.gz: d5e471d9d944580185fe2aa97e53fec105f87ae8
 SHA512:
-  metadata.gz: cb7be058cf592b5ae2e0f75ce973f94acd79c7406fef6301e2b040ce19529d497013b28f95d1e029b38938fbe8c1264fdaf16b234a10d368651ea70a9f1b1a4d
-  data.tar.gz: 99b7ea37ef5ea2e2dac2e99a3336b137cd282f2aaa619a6d827d42d0f9e341a594022b04278a6be2e2ef8e7ce7ef39fec0487e1f12ea3b9afd48a8d24d88c19c
+  metadata.gz: e69445a655dc2d80002b087ff8355d1e344a052919be4944b52c94bef65f4065b3d8eb0cf090a0f0e8276cebc028f002399a8b638d892584b51eaefa2cc881fa
+  data.tar.gz: e812e89f78b44ad82726bc978bd36c780957c645b4fc55278279b770f87ed219c5995ea4ed02a16d5196c78b6d0ebeb87e43ba313d847d0789cff2bb2ff63c2b

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 # CHANGELOG.md
 
 
+## tresse 1.0.0  released 2019-09-16
+
+* #source / #map / #reduce
+* #each / #flatten
+* work threads
+
+
 ## tresse 0.1.0  released 2019-09-15
 
 * Initial release

data/README.md

@@ -1,41 +1,72 @@
 
 # tresse
 
-A poorly thought out and stupid each+map+reduce contraption.
+A poorly thought out and stupid source+map+reduce contraption.
 
+You source one or more pieces of data, map them a couple of times then reduce them.
+
+By default, the whole of Tresse uses 8 work threads, it can be changed:
+```ruby
+Tresse.max_work_thread_count # => 8
+
+Tresse.max_work_thread_count = 10
+
+Tresse.max_work_thread_count # => 10
+```
 
 ## use
 
+Two sources flattened together
+```ruby
+r =
+  Tresse::Group.new('test0')
+    .source { (0..3).to_a }
+    .source { (4..9).to_a }
+    .values # or .flatten
+    .sort
+
+r #=> (0..9).to_a
 ```
-require 'tresse'
 
+Combining two sources again
+```ruby
 r =
   Tresse::Group.new('test0')
-    .append { 'b' }
-    .append { 'a' }
-    .collect { |e| e * 2 }
+    .source { (0..3).to_a }
+    .source { ('a'..'c').to_a }
+    .map { |e| e.collect { |e| e * 2 } }
+    .values # or .flatten
 
 r
-  # => %[ aa bb ]
-  # or
-  # => %[ bb aa ]
+  # => [ 0, 2, 4, 6, 'aa', 'bb', 'cc' ]
+  #    or
+  # => [ 'aa', 'bb', 'cc', 0, 2, 4, 6 ]
 ```
 
+Each can be used, the outcome of its block is discarded
 ```ruby
-require 'tresse'
+t = []
+  # collecting on the side
 
 r =
   Tresse::Group.new('test0')
-    .append { [ 'a' ] }
-    .append { [ 'c' ] }
-    .append { [ 'b' ] }
-    .each { |e| e[0] = e[0] * 2 }
-    .inject([]) { |a, e| a << e.first; a.sort }
+    .source { (0..3).to_a }
+    .source { ('a'..'c').to_a }
+    .each { |e| t << e.collect { |e| e * 2 } }
+    .values
 
 r
-  # => %w[ aa bb cc ]
+  # => [ 0, 1, 2, 3, 'a', 'b', 'c' ]
+  #    or
+  # => [ 'a', 'b', 'c', 0, 1, 2, 3 ]
+
+t
+  # => [ [ 0, 2, 4, 6 ], [ 'aa', 'bb', 'cc' ] ]
+  #    or
+  # => [ [ 'aa', 'bb', 'cc' ], [ 0, 2, 4, 6 ] ]
 ```
 
+
 ## license
 
 MIT, see [LICENSE.txt](LICENSE.txt)

data/lib/tresse.rb

@@ -4,27 +4,23 @@ require 'thread'
 
 module Tresse
 
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 
   class << self
 
-    attr_accessor :max_work_threads
-
     def init
 
-      @max_work_threads = 7
       @work_queue = Queue.new
-      @thread_queue = Queue.new
-
-      @on_error = lambda do |where, err|
-        puts "-" * 80
-        p where
-        p err
-        puts err.backtrace
-        puts "-" * 80
-      end
-
-      run
+      @work_threads = 8.times.collect { |i| make_work_thread }
+
+      @on_error =
+        lambda do |where, err|
+          puts "-" * 80
+          p where
+          p err
+          puts err.backtrace
+          puts "-" * 80
+        end
     end
 
     def enqueue(batch)
@@ -39,44 +35,46 @@ module Tresse
       @on_error = block
     end
 
-    protected
-
-    def run
-
-      @max_work_threads.times { |i| @thread_queue << i }
+    def max_work_thread_count
 
-      Thread.new do
-        loop do
-          begin
+      @work_threads.size
+    end
 
-            i = @thread_queue.pop
-            batch = @work_queue.pop
+    def max_work_thread_count=(i)
 
-            hand_to_worker_thread(i, batch)
+      i0 = @work_threads.size
 
-          rescue => err
+      @work_threads << make_work_thread while @work_threads.size < i
+      @work_threads.pop while @work_threads.size > i
 
-            @on_error.call(:in_loop, err)
-          end
-        end
-      end
+      i
     end
 
-    def hand_to_worker_thread(i, batch)
+    protected
+
+    def make_work_thread
 
       Thread.new do
-        begin
 
-          Thread.current[:tress] = true
-          Thread.current[:i] = i
+        t = Thread.current
+        t[:tresse] = true
 
-          batch.process
+        loop do
+          begin
 
-          @thread_queue << i unless i >= @max_work_threads
+            batch = @work_queue.pop
 
-        rescue => err
+            unless @work_threads.include?(t)
+              @work_queue << batch
+              break
+            end
 
-          @on_error.call(:in_worker_thread, err)
+            batch.process
+
+          rescue => err
+
+            @on_error.call(:in_worker_thread, err)
+          end
         end
       end
     end
@@ -88,122 +86,153 @@ module Tresse
   class Batch
 
     attr_reader :group
-    attr_reader :each_index, :value
+    attr_reader :map_index
+    attr_accessor :value
 
     def initialize(group, block_or_group)
 
       @group = group
       @bog = block_or_group
 
-      @each_index = -1
+      @map_index = -1
       @value = nil
     end
 
     def process
 
-      @each_index += 1
-      @group.send(:hand, self)
+      @map_index += 1
+      @group.send(:receive, self)
     end
 
-    protected
-
-    def generate
+    def source
 
       args = [ group ] + [ nil ] * 7
       args = args[0, @bog.method(:call).arity]
 
       @value = @bog.call(*args)
     end
+
+    def map(type, block)
+
+      args = [ @value, self ]
+      args = args[0, block.method(:call).arity.abs]
+
+      r = block.call(*args)
+
+      @value = r if type == :map
+    end
   end
 
   class Group
 
     attr_accessor :name
-    attr_reader :batches
+    #attr_reader :batches
 
-    def initialize(name)
+    def initialize(name=nil)
 
       @name = name
 
       @batches = []
-      @eaches = [ nil ]
+      @launched = false
+      @maps = [ nil ]
 
-      @final = nil
-      @final_batches = []
-      @final_queue = Queue.new
+      @reduce = nil
+      @reduce_batches = []
+      @reduction_queue = Queue.new
     end
 
     #
-    # appending methods
+    # sourcing methods
 
-    def append(o=nil, &block)
+    def source(o=nil, &block)
 
       batch = Tresse::Batch.new(self, o ? o : block)
 
       @batches << batch
-      Tresse.enqueue(batch)
+
+      self
     end
 
     #
-    # step methods
+    # mapping
 
     def each(&block)
 
-      @eaches << block
+      do_map(:each, block)
+    end
 
-      self
+    def map(&block)
+
+      do_map(:map, block)
     end
 
     #
-    # final methods
+    # reducing
+
+    def reduce(target, &block)
+
+      do_reduce(target, block)
+    end
+    alias inject reduce
 
-    def inject(target, &block)
+    def flatten
 
-      @final = [ target, block ]
+      do_reduce([], lambda { |a, e| a.concat(e) })
+    end
+    alias values flatten
+
+    protected
+
+    def do_map(type, block)
 
-      @final_queue.pop
+      @maps << [ type, block ]
+
+      launch
+
+      self
     end
-    alias reduce inject
 
-    def collect(&block)
+    def do_reduce(target, block)
 
-      @final = block
+      @reduce = [ target, block ]
 
-      @final_queue.pop
+      launch
+
+      @reduction_queue.pop
     end
-    alias map collect
 
-    protected
+    def launch
+
+      return if @launched == true
+      @launched = true
 
-    def hand(batch)
+      @batches.each { |b| Tresse.enqueue(b) }
+    end
+
+    def receive(batch)
 
-      if batch.each_index == 0
-        batch.send(:generate)
+      if batch.map_index == 0
+        batch.source
         Tresse.enqueue(batch)
-      elsif e = @eaches[batch.each_index]
-        args = [ batch.value, batch ]
-        args = args[0, e.method(:call).arity.abs]
-        e.call(*args)
+      elsif m = @maps[batch.map_index]
+        batch.map(*m)
         Tresse.enqueue(batch)
       else
-        queue_for_final(batch)
+        queue_for_reduction(batch)
       end
     end
 
-    def queue_for_final(batch)
+    def queue_for_reduction(batch)
 
-      @final_batches << batch
+      @reduce_batches << batch
 
-      return if @final_batches.size < @batches.size
+      return if @reduce_batches.size < @batches.size
+      return unless @reduce
 
       es = @batches.collect(&:value)
+      target, block = @reduce
 
-      @final_queue <<
-        if @final.is_a?(Array)
-          es.inject(@final[0], &@final[1])
-        else
-          es.collect(&@final)
-        end
+      @reduction_queue << es.inject(target, &block)
     end
   end
 end

data/tresse.gemspec

@@ -13,10 +13,10 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/jmettraux/tresse'
   #s.rubyforge_project = 'rufus'
   s.license = 'MIT'
-  s.summary = 'a stupid each+map+reduce thing'
+  s.summary = 'a stupid source+map+reduce thing'
 
   s.description = %{
-a poorly thought out and stupid each+map+reduce contraption
+a poorly thought out and stupid source+map+reduce contraption
   }.strip
 
   #s.files = `git ls-files`.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tresse
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-15 00:00:00.000000000 Z
+date: 2019-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
-description: a poorly thought out and stupid each+map+reduce contraption
+description: a poorly thought out and stupid source+map+reduce contraption
 email:
 - jmettraux@gmail.com
 executables: []
@@ -61,5 +61,5 @@ rubyforge_project:
 rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
-summary: a stupid each+map+reduce thing
+summary: a stupid source+map+reduce thing
 test_files: []