keybreak 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b9146d36f6868c36c5a167ab3b61ce8b5bb85fd
-  data.tar.gz: 6e48f6323e51eb5713a6927d5d041d0d9582dd97
+  metadata.gz: f1cc4542e1cff84c14f701250bfe7797a618371e
+  data.tar.gz: a1f3cd7c78f43bc1d6b24b1dcd267b97faa3f5bc
 SHA512:
-  metadata.gz: 8306abbdd10e3fb401b58ad0a8aae8b191c985dcd06ce2a91cf0013246b52193df6b356a11eb393e3bf973464a7ccc3b5b8fdb281efed721cacd056681f310fa
-  data.tar.gz: 1a8f4dcc80d4914076482267d098401b64b0db04d01950921b8b859330dbf3744e434bf907cbee738e2cd94a0b5a50b5603903d6319554bc84d3d00fc7f09a14
+  metadata.gz: 4221eb518702614f0c7b98c5feb5c171f1792b0893a96ede9cf9dcd953e1b4b3ed16f9060f29c75fcd53580fcdae39776b2a1846971e2bd12d112229402b051b
+  data.tar.gz: 3653bc51a73bbbff5e9a394eb394f74bfe5c8534fa9cef7cba742701249ecd9c90285e688f36b61a6599056209c97652bf6973ee9f291684259e5809a44f75a5

data/.rspec

@@ -1 +1,2 @@
---format documentation
+--format documentation
+--color

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.3.0 (2016-03-05)
+
+Features:
+
+  - defined the return value of Controller#on as self instance
+
 ## 0.2.0 (2016-01-31)
 
 Features:

data/README.md

@@ -1,349 +1,355 @@
-# Keybreak
-
-Keybreak is a utility module for key break processing in Ruby.
-
-## Introduction
-
-### Key break processing
-
-The "key break processing" means, assuming a sorted sequence of records which can be grouped by a column,
-doing the same process for each group.
-
-The column used for the grouping is a "key".
-In processing the record sequence, when the key's value in a record changes from the previous record,
-it is called "key break".
-
-
-### Motivation
-
-A typical key break processing is counting the number of records for each key like below:
-
-```ruby
-RECORDS =<<EOD
-a	1
-b	2
-b	3
-c	4
-c	5
-c	6
-d	7
-e	8
-e	9
-EOD
-
-count = 0
-prev_key = nil
-
-RECORDS.each_line do |line|
-  key = line.split("\t")[0]
-  
-  if !prev_key.nil? && key != prev_key
-    puts "#{prev_key}:#{count}"
-    count = 0
-  end
-  
-  count += 1
-  prev_key = key
-end
-
-if !prev_key.nil?
-    puts "#{prev_key}:#{count}"
-end
-```
-
-Note that you have to write "puts" once again after the iteration.
-This is quite troublesome even for such a simple task, and is very my motivation.
-
-With Keybreak module, the code goes like below:
-
-```ruby
-require "keybreak"
-
-RECORDS =<<EOD
-a	1
-b	2
-b	3
-c	4
-c	5
-c	6
-d	7
-e	8
-e	9
-EOD
-
-Keybreak.execute_with_controller do |c, count|
-  c.on(:keystart) {count = 0}
-  c.on(:keyend) {|key| puts "#{key}:#{count}"}
-
-  RECORDS.each_line do |line|
-    key = line.split("\t")[0]
-    c.feed(key)
-    count += 1
-  end
-end
-```
-
-You need to register event handlers as a key break consists of two events:
-First, the end of current key sequence (:keyend).
-Next, the start of new key sequence (:keystart).
-
-Then call feed() in your record loop.
-The method holds current key, detects a key break, and calls the event handlers accordingly.
-The block given to execute_with_controller makes sure to process the end of the last key.
-
-In many cases, taking a functional approach such as Enumerable#map, Enumerable#slice_when, etc. would achieve the task simply.
-But sometimes, a procedural code is needed.
-Keybreak module may assist you to make your key break code simpler.
-
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'keybreak'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install keybreak
-
-
-## Usage
-
-In your ruby source, write the line below:
-
-```ruby
-require "keybreak"
-```
-
-Here are some examples of typical key break processing.
-See [examples](https://github.com/hashimoton/keybreak/tree/master/examples) for full code.
-
-### Print first values for each key
-
-Register a :keystart handler which prints the given key and value.
-
-```ruby
-RECORDS =<<EOD
-a	1
-b	2
-b	3
-c	4
-c	5
-c	6
-d	7
-e	8
-e	9
-EOD
-
-Keybreak.execute_with_controller do |c|
-  c.on(:keystart) {|key, value| puts "#{key}:#{value}"}
-
-  RECORDS.each_line do |line|
-    key, value = line.split("\t")
-    c.feed(key, value)
-  end
-end
-```
-
-The result will be:
-
-```
-a:1
-b:2
-c:4
-d:7
-e:8
-```
-
-### Print last values for each key
-
-Borrows RECORDS from above example.
-
-Register a :keyend handler which prints the given key and value.
-
-```ruby
-Keybreak.execute_with_controller do |c|
-  c.on(:keyend) {|key, value| puts "#{key}:#{value}"}
-
-  RECORDS.each_line do |line|
-    key, value = line.split("\t")
-    c.feed(key, value)
-  end
-end
-```
-
-The result will be:
-
-```
-a:1
-b:3
-c:6
-d:7
-e:9
-```
-
-### Print sum of values for each key
-
-Clear sum when a key starts.
-Print sum when the key ends.
-
-```ruby
-Keybreak.execute_with_controller do |c, sum|
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "#{key}:#{sum}"}
-
-  RECORDS.each_line do |line|
-    key, value = line.split("\t")
-    c.feed(key)
-    sum += value.to_i
-  end
-end
-```
-
-The result will be:
-
-```
-a:1
-b:5
-c:15
-d:7
-e:17
-```
-
-
-### Print sum of values for each key and sub key
-
-Nest Keybreak.execute_with_controller.
-
-Give sub key handlers a set of primary key and sub key (an array for instance)
-so that a primary key break is also detected as a sub key break.
-
-```ruby
-RECORDS =<<EOD
-a	a1	1
-b	b1	2
-b	b2	3
-c	c1	4
-c	c1	5
-c	c2	6
-d	d1	7
-e	e1	8
-e	e1	9
-EOD
-
-Keybreak.execute_with_controller do |c, sum|
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "total #{key}:#{sum}"}
- 
-  Keybreak.execute_with_controller do |sub_c, sub_sum|
-    sub_c.on(:keystart) {sub_sum = 0}
-    sub_c.on(:keyend) do |keys|
-      puts "#{keys[1]}:#{sub_sum}"
-      sum += sub_sum
-    end
-    
-    RECORDS.each_line do |line|
-      key, sub_key, value = line.split("\t")
-      sub_c.feed([key, sub_key])
-      c.feed(key)
-      sub_sum += value.to_i
-    end
-  end
-end
-```
-
-The result will be:
-
-```
-a1:1
-total a:1
-b1:2
-b2:3
-total b:5
-c1:9
-c2:6
-total c:15
-d1:7
-total d:7
-e1:17
-total e:17
-```
-
-### Print sum of values for each key where empty key means continuation
-
-Sometimes we face the empty keys which mean to continue the value in the previous record.
-The pivot table of MS Excel is an example.
-Keybreak module can handle this case by providing a block for detecting a keybreak.
-
-```ruby
-RECORDS =<<EOD
-a	a1	1
-b	b1	2
-	b2	3
-c	c1	4
-		5
-	c2	6
-d	d1	7
-e	e1	8
-		9
-EOD
-
-Keybreak.execute_with_controller do |c, sum|
-  c.on(:detection) {|key| !key.empty?}
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "total #{key}:#{sum}"}
- 
-  Keybreak.execute_with_controller do |sub_c, sub_sum|
-    sub_c.on(:detection) {|keys| !keys.all? {|key| key.empty?}}
-    sub_c.on(:keystart) {sub_sum = 0}
-    sub_c.on(:keyend) do |keys|
-      puts "#{keys[1]}:#{sub_sum}"
-      sum += sub_sum
-    end
- 
-    RECORDS.each_line do |line|
-      key, sub_key, value = line.split("\t")
-      sub_c.feed([key, sub_key])
-      c.feed(key)
-      sub_sum += value.to_i
-    end
-  end
-end
-```
-
-The result will be the same as the previous example.
-
-By default, the below block is used for the key break detections.
-
-```
-{|key, prev_key| key != prev_key}
-```
-
-## Development
-
-
-### Test
-
-Run the tests in spec directory:
-
-```
-$ cd keybreak
-$ rake spec
-```
-
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/hashimoton/keybreak.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+# Keybreak
+
+Keybreak is a utility module for key break processing in Ruby.
+
+## Introduction
+
+### Key break processing
+
+The "key break processing" means, assuming a sorted sequence of records which can be grouped by a column,
+doing the same process for each group.
+
+The column used for the grouping is a "key".
+In processing the record sequence, when the key's value in a record changes from the previous record,
+it is called "key break" (also known as ["control break"](https://en.wikipedia.org/wiki/Control_break)).
+
+
+### Motivation
+
+A typical key break processing is counting the number of records for each key like below:
+
+```ruby
+RECORDS =<<EOD
+a	1
+b	2
+b	3
+c	4
+c	5
+c	6
+d	7
+e	8
+e	9
+EOD
+
+count = 0
+prev_key = nil
+
+RECORDS.each_line do |line|
+  key = line.split("\t")[0]
+  
+  if !prev_key.nil? && key != prev_key
+    puts "#{prev_key}:#{count}"
+    count = 0
+  end
+  
+  count += 1
+  prev_key = key
+end
+
+if !prev_key.nil?
+    puts "#{prev_key}:#{count}"
+end
+```
+
+Note that you have to write "puts" once again after the iteration.
+This is quite troublesome even for such a simple task, and is very my motivation.
+
+With Keybreak module, the code goes like below:
+
+```ruby
+require "keybreak"
+
+RECORDS =<<EOD
+a	1
+b	2
+b	3
+c	4
+c	5
+c	6
+d	7
+e	8
+e	9
+EOD
+
+Keybreak.execute_with_controller do |c, count|
+  c.on(:keystart) {count = 0}
+  c.on(:keyend) {|key| puts "#{key}:#{count}"}
+
+  RECORDS.each_line do |line|
+    key = line.split("\t")[0]
+    c.feed(key)
+    count += 1
+  end
+end
+```
+
+You need to register event handlers as a key break consists of two events:
+First, the end of current key sequence (:keyend).
+Next, the start of new key sequence (:keystart).
+
+Then call feed() in your record loop.
+The method holds current key, detects a key break, and calls the event handlers accordingly.
+The block given to execute_with_controller makes sure to process the end of the last key.
+
+In many cases, taking a functional approach such as Enumerable#map, Enumerable#slice_when, etc. would achieve the task simply.
+But sometimes, a procedural code is needed.
+Keybreak module may assist you to make your key break processing code simpler.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'keybreak'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install keybreak
+
+
+## Usage
+
+In your ruby source, write the line below:
+
+```ruby
+require "keybreak"
+```
+
+Here are some examples of typical key break processing.
+See [examples](https://github.com/hashimoton/keybreak/tree/master/examples) for full code.
+
+### Print first values for each key
+
+Register a :keystart handler which prints the given key and value.
+
+```ruby
+RECORDS =<<EOD
+a	1
+b	2
+b	3
+c	4
+c	5
+c	6
+d	7
+e	8
+e	9
+EOD
+
+Keybreak.execute_with_controller do |c|
+  c.on(:keystart) {|key, value| puts "#{key}:#{value}"}
+
+  RECORDS.each_line do |line|
+    key, value = line.split("\t")
+    c.feed(key, value)
+  end
+end
+```
+
+The result will be:
+
+```
+a:1
+b:2
+c:4
+d:7
+e:8
+```
+
+### Print last values for each key
+
+Borrows RECORDS from above example.
+
+Register a :keyend handler which prints the given key and value.
+
+```ruby
+Keybreak.execute_with_controller do |c|
+  c.on(:keyend) {|key, value| puts "#{key}:#{value}"}
+
+  RECORDS.each_line do |line|
+    key, value = line.split("\t")
+    c.feed(key, value)
+  end
+end
+```
+
+The result will be:
+
+```
+a:1
+b:3
+c:6
+d:7
+e:9
+```
+
+### Print sum of values for each key
+
+Clear sum when a key starts.
+Print sum when the key ends.
+
+```ruby
+Keybreak.execute_with_controller do |c, sum|
+  c.on(:keystart) {sum = 0}
+  c.on(:keyend) {|key| puts "#{key}:#{sum}"}
+
+  RECORDS.each_line do |line|
+    key, value = line.split("\t")
+    c.feed(key)
+    sum += value.to_i
+  end
+end
+```
+
+The result will be:
+
+```
+a:1
+b:5
+c:15
+d:7
+e:17
+```
+
+
+### Print sum of values for each key and sub key
+
+Nest Keybreak.execute_with_controller.
+
+Call flush() for sub key in the :keyend handler of the key
+so that an end of key triggers an end of sub key.
+
+```ruby
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+b	b2	3
+c	c1	4
+c	c1	5
+c	c2	6
+d	d1	7
+e	e1	8
+e	e1	9
+EOD
+
+Keybreak.execute_with_controller do |c, sum|
+  Keybreak.execute_with_controller do |sub_c, sub_sum|
+    c.on(:keystart) {sum = 0}
+    c.on(:keyend) do |key|
+      sub_c.flush
+      puts "total #{key}:#{sum}"
+    end
+  
+    sub_c.on(:keystart) {sub_sum = 0}
+    sub_c.on(:keyend) do |key|
+      puts "#{key}:#{sub_sum}"
+      sum += sub_sum
+    end
+
+    RECORDS.each_line do |line|
+      key, sub_key, value = line.split("\t")
+      c.feed(key)
+      sub_c.feed(sub_key)
+      sub_sum += value.to_i
+    end
+  end
+end
+```
+
+The result will be:
+
+```
+a1:1
+total a:1
+b1:2
+b2:3
+total b:5
+c1:9
+c2:6
+total c:15
+d1:7
+total d:7
+e1:17
+total e:17
+```
+
+### Print sum of values for each key where empty key means continuation
+
+Sometimes we face the empty keys which mean to continue the value in the previous record.
+The pivot table of MS Excel is an example.
+Keybreak module can handle this case by providing a block for detecting a keybreak.
+
+```ruby
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+	b2	3
+c	c1	4
+		5
+	c2	6
+d	d1	7
+e	e1	8
+		9
+EOD
+
+Keybreak.execute_with_controller do |c, sum|
+  Keybreak.execute_with_controller do |sub_c, sub_sum|
+    c.on(:detection) {|key| !key.empty?}
+    c.on(:keystart) {sum = 0}
+    c.on(:keyend) do |key|
+      sub_c.flush
+      puts "total #{key}:#{sum}"
+    end
+  
+    sub_c.on(:detection) {|key| !key.empty?}
+    sub_c.on(:keystart) {sub_sum = 0}
+    sub_c.on(:keyend) do |key|
+      puts "#{key}:#{sub_sum}"
+      sum += sub_sum
+    end
+ 
+    RECORDS.each_line do |line|
+      key, sub_key, value = line.split("\t")
+      c.feed(key)
+      sub_c.feed(sub_key)
+      sub_sum += value.to_i
+    end
+  end
+end
+```
+
+The result will be the same as the previous example.
+
+By default, the below block is used for the key break detections.
+
+```
+{|key, prev_key| key != prev_key}
+```
+
+## Development
+
+
+### Test
+
+Run the tests in spec directory:
+
+```
+$ cd keybreak
+$ rake spec
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hashimoton/keybreak.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/examples/{empty_key.rb → empty_keys.rb}

@@ -30,22 +30,25 @@ e	e1	8
 EOD
 
 Keybreak.execute_with_controller do |c, sum|
-  c.on(:detection) {|key| !key.empty?}
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "total #{key}:#{sum}"}
- 
   Keybreak.execute_with_controller do |sub_c, sub_sum|
-    sub_c.on(:detection) {|keys| !keys.all? {|key| key.empty?}}
+    c.on(:detection) {|key| !key.empty?}
+    c.on(:keystart) {sum = 0}
+    c.on(:keyend) do |key|
+      sub_c.flush
+      puts "total #{key}:#{sum}"
+    end
+  
+    sub_c.on(:detection) {|key| !key.empty?}
     sub_c.on(:keystart) {sub_sum = 0}
-    sub_c.on(:keyend) do |keys|
-      puts "#{keys[1]}:#{sub_sum}"
+    sub_c.on(:keyend) do |key|
+      puts "#{key}:#{sub_sum}"
       sum += sub_sum
     end
  
     RECORDS.each_line do |line|
       key, sub_key, value = line.split("\t")
-      sub_c.feed([key, sub_key])
       c.feed(key)
+      sub_c.feed(sub_key)
       sub_sum += value.to_i
     end
   end

data/examples/nested_keys.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+# Print start and end of each key and sub key
+# =>
+# a START
+#   a1 START
+#   a1 END
+# a END
+# b START
+#   b1 START
+#   b1 END
+#   b2 START
+#   b2 END
+# b END
+# c START
+#   c1 START
+#   c1 END
+#   c2 START
+#   c2 END
+# c END
+# d START
+#   d1 START
+#   d1 END
+# d END
+# e START
+#   e1 START
+#   e1 END
+# e END
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "keybreak"
+
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+b	b2	3
+c	c1	4
+c	c1	5
+c	c2	6
+d	d1	7
+e	e1	8
+e	e1	9
+EOD
+
+Keybreak.execute_with_controller do |c|
+  Keybreak.execute_with_controller do |sub_c|
+    c.on(:keystart) {|key| puts "#{key} START"}
+    c.on(:keyend) do |key|
+      sub_c.flush
+      puts "#{key} END"
+    end
+  
+    sub_c.on(:keystart) {|key| puts "  #{key} START"}
+    sub_c.on(:keyend) do |key|
+      puts "  #{key} END"
+    end
+
+    RECORDS.each_line do |line|
+      key, sub_key, value = line.split("\t")
+      c.feed(key)
+      sub_c.feed(sub_key)
+    end
+  end
+end
+
+# EOF

data/examples/nested_keys2.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+# Print start and end of each key and sub key
+# =>
+# a START
+#   a1 START
+#   a1 END
+# a END
+# b START
+#   b1 START
+#   b1 END
+#   b2 START
+#   b2 END
+# b END
+# c START
+#   c1 START
+#   c1 END
+#   c2 START
+#   c2 END
+# c END
+# d START
+#   d1 START
+#   d1 END
+# d END
+# e START
+#   e1 START
+#   e1 END
+# e END
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "keybreak"
+
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+b	b2	3
+c	c1	4
+c	c1	5
+c	c2	6
+d	d1	7
+e	e1	8
+e	e1	9
+EOD
+
+c = Keybreak::Controller.new
+sub_c = Keybreak::Controller.new
+
+c.on(:keystart) {|key| puts "#{key} START"}.
+  on(:keyend) do |key|
+    sub_c.flush
+    puts "#{key} END"
+  end
+
+sub_c.on(:keystart) {|key| puts "  #{key} START"}.
+  on(:keyend) {|key| puts "  #{key} END" }
+
+c.execute do
+  RECORDS.each_line do |line|
+    key, sub_key, value = line.split("\t")
+    feed(key)
+    sub_c.feed(sub_key)
+  end
+end
+
+# EOF

data/examples/nested_sum.rb

@@ -1,52 +1,55 @@
-# coding: utf-8
-# Print sum of values for each key and sub key
-# =>
-# a1:1
-# total a:1
-# b1:2
-# b2:3
-# total b:5
-# c1:9
-# c2:6
-# total c:15
-# d1:7
-# total d:7
-# e1:17
-# total e:17
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require "keybreak"
-
-RECORDS =<<EOD
-a	a1	1
-b	b1	2
-b	b2	3
-c	c1	4
-c	c1	5
-c	c2	6
-d	d1	7
-e	e1	8
-e	e1	9
-EOD
-
-Keybreak.execute_with_controller do |c, sum|
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "total #{key}:#{sum}"}
- 
-  Keybreak.execute_with_controller do |sub_c, sub_sum|
-    sub_c.on(:keystart) {sub_sum = 0}
-    sub_c.on(:keyend) do |keys|
-      puts "#{keys[1]}:#{sub_sum}"
-      sum += sub_sum
-    end
-    
-    RECORDS.each_line do |line|
-      key, sub_key, value = line.split("\t")
-      sub_c.feed([key, sub_key])
-      c.feed(key)
-      sub_sum += value.to_i
-    end
-  end
-end
-
-# EOF
+# coding: utf-8
+# Print sum of values for each key and sub key
+# =>
+# a1:1
+# total a:1
+# b1:2
+# b2:3
+# total b:5
+# c1:9
+# c2:6
+# total c:15
+# d1:7
+# total d:7
+# e1:17
+# total e:17
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "keybreak"
+
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+b	b2	3
+c	c1	4
+c	c1	5
+c	c2	6
+d	d1	7
+e	e1	8
+e	e1	9
+EOD
+
+Keybreak.execute_with_controller do |c, sum|
+  Keybreak.execute_with_controller do |sub_c, sub_sum|
+    c.on(:keystart) {sum = 0}
+    c.on(:keyend) do |key|
+      sub_c.flush
+      puts "total #{key}:#{sum}"
+    end
+  
+    sub_c.on(:keystart) {sub_sum = 0}
+    sub_c.on(:keyend) do |key|
+      puts "#{key}:#{sub_sum}"
+      sum += sub_sum
+    end
+
+    RECORDS.each_line do |line|
+      key, sub_key, value = line.split("\t")
+      c.feed(key)
+      sub_c.feed(sub_key)
+      sub_sum += value.to_i
+    end
+  end
+end
+
+# EOF

data/examples/nested_sum2.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+# Print sum of values for each key and sub key
+# =>
+# a1:1
+# total a:1
+# b1:2
+# b2:3
+# total b:5
+# c1:9
+# c2:6
+# total c:15
+# d1:7
+# total d:7
+# e1:17
+# total e:17
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "keybreak"
+
+RECORDS =<<EOD
+a	a1	1
+b	b1	2
+b	b2	3
+c	c1	4
+c	c1	5
+c	c2	6
+d	d1	7
+e	e1	8
+e	e1	9
+EOD
+
+c = Keybreak::Controller.new
+sub_c = Keybreak::Controller.new
+
+sum = 0
+c.on(:keystart) {sum = 0}
+c.on(:keyend) do |key|
+  sub_c.flush
+  puts "total #{key}:#{sum}"
+end
+
+sub_sum = 0
+sub_c.on(:keystart) {sub_sum = 0}
+sub_c.on(:keyend) do |key|
+  puts "#{key}:#{sub_sum}"
+  sum += sub_sum
+end
+
+c.execute do
+  RECORDS.each_line do |line|
+    key, sub_key, value = line.split("\t")
+    c.feed(key)
+    sub_c.feed(sub_key)
+    sub_sum += value.to_i
+  end
+end
+
+# EOF

data/keybreak.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["nhashimoto01@gmail.com"]
 
   spec.summary       = %q{Keybreak is a utility module for key break processing in Ruby.}
+  spec.description   = %q{Keybreak module may assist you to make your key break processing code simpler.}
   spec.homepage      = "https://github.com/hashimoton/keybreak"
   spec.license       = "MIT"
 

data/lib/keybreak/controller.rb

@@ -20,8 +20,10 @@ module Keybreak
     #   :keystart
     #   :keyend
     #   :detection
+    # Returns self instance so that registrations can be chained.
     def on(event, &block)
       @handlers[event] = block
+      return self
     end
     
     

data/lib/keybreak/version.rb

@@ -1,5 +1,5 @@
 module Keybreak
   # Version.
   #   MAJOR.MINOR.PATCH
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keybreak
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - hashimoton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description: Keybreak module may assist you to make your key break processing code
+  simpler.
 email:
 - nhashimoto01@gmail.com
 executables: []
@@ -68,10 +69,13 @@ files:
 - README.md
 - Rakefile
 - examples/count.rb
-- examples/empty_key.rb
+- examples/empty_keys.rb
 - examples/first_value.rb
 - examples/last_value.rb
+- examples/nested_keys.rb
+- examples/nested_keys2.rb
 - examples/nested_sum.rb
+- examples/nested_sum2.rb
 - examples/sum.rb
 - keybreak.gemspec
 - lib/keybreak.rb