keybreak 0.1.1 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NzllZjEwM2Q1ODQzN2JkN2FkZGZmMjU3ZTUzM2ViMzY5NWVmN2FiNg==
-  data.tar.gz: !binary |-
-    NDM4YWQyZDM3NDgyMDlkM2NlMWE4NGM0NGQzNWM2ZDg5YWJkNDIwZA==
+SHA1:
+  metadata.gz: 6b9146d36f6868c36c5a167ab3b61ce8b5bb85fd
+  data.tar.gz: 6e48f6323e51eb5713a6927d5d041d0d9582dd97
 SHA512:
-  metadata.gz: !binary |-
-    ZWYyNDMyMDU3ODA1ZDdmNzk2ZjY1NTZkZTUxMjk3Njg4NGNjYWFjYjU1ZmNi
-    NTgyNDMxM2U5NGYwZGZkNmE2NTFkMjNlNWEyYWYwOWYxNjMwMGVhNDhmMDlh
-    YjZiNzcyOTQwMTBjYTc5NjJkYjBiOGQwZTM4NmYyZWI0ODNhZWE=
-  data.tar.gz: !binary |-
-    ODM0ODkwNjk5MGIxNzMyMmU5ZWZhOWM0Mzc0N2QwOGZmZjkwZTExZmJkODRh
-    ZDViZTI4OGRjMmY0YmJiZTBkYTA1M2Q2ZTVjZDUxZDE1MTk1OGRiYTU4MmRm
-    NDJjZTBkMzRlNGNkNmRlYmQzNjU2MjBhZjY1Y2U1ODY3OGIxNGQ=
+  metadata.gz: 8306abbdd10e3fb401b58ad0a8aae8b191c985dcd06ce2a91cf0013246b52193df6b356a11eb393e3bf973464a7ccc3b5b8fdb281efed721cacd056681f310fa
+  data.tar.gz: 1a8f4dcc80d4914076482267d098401b64b0db04d01950921b8b859330dbf3744e434bf907cbee738e2cd94a0b5a50b5603903d6319554bc84d3d00fc7f09a14

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+## 0.2.0 (2016-01-31)
+
+Features:
+
+  - added :detection event
+  - rewrote all examples to read data from here document instead of DATA
+
+## 0.1.1 (2016-01-29)
+
+Features:
+
+  - added Ruby version in gemspec
+
+Documentation:
+
+  - corrected comments in source files
+
+
+## 0.1.0 (2016-01-28)
+
+Features:
+
+  - initial version
+

data/README.md

@@ -1,12 +1,12 @@
 # Keybreak
 
-Keybreak is a utility module for Key break processing in Ruby.
+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 column based records which can be grouped by a column,
+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".
@@ -19,11 +19,23 @@ it is called "key break".
 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
 
-DATA.each do |line|
-  key = line.chomp.split("\t")[0]
+RECORDS.each_line do |line|
+  key = line.split("\t")[0]
   
   if !prev_key.nil? && key != prev_key
     puts "#{prev_key}:#{count}"
@@ -37,8 +49,17 @@ 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:
 
-__END__
+```ruby
+require "keybreak"
+
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -48,37 +69,18 @@ c	6
 d	7
 e	8
 e	9
-```
-
-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 is like below:
-
-```ruby
-require "keybreak"
+EOD
 
 Keybreak.execute_with_controller do |c, count|
   c.on(:keystart) {count = 0}
   c.on(:keyend) {|key| puts "#{key}:#{count}"}
 
-  DATA.each do |line|
-    key = line.chomp.split("\t")[0]
+  RECORDS.each_line do |line|
+    key = line.split("\t")[0]
     c.feed(key)
     count += 1
   end
 end
-
-__END__
-a	1
-b	2
-b	3
-c	4
-c	5
-c	6
-d	7
-e	8
-e	9
 ```
 
 You need to register event handlers as a key break consists of two events:
@@ -89,7 +91,7 @@ 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 achieves the task simply.
+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.
 
@@ -124,19 +126,10 @@ See [examples](https://github.com/hashimoton/keybreak/tree/master/examples) for
 
 ### Print first values for each key
 
-Register a keystart handler which prints the given key and value.
+Register a :keystart handler which prints the given key and value.
 
 ```ruby
-Keybreak.execute_with_controller do |c|
-  c.on(:keystart) {|key, value| puts "#{key}:#{value}"}
-
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
-    c.feed(key, value)
-  end
-end
-
-__END__
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -146,6 +139,16 @@ 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:
@@ -160,16 +163,16 @@ e:8
 
 ### Print last values for each key
 
-Borrows DATA from above example.
+Borrows RECORDS from above example.
 
-Register a keyend handler which prints the given key and value.
+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}"}
 
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
+  RECORDS.each_line do |line|
+    key, value = line.split("\t")
     c.feed(key, value)
   end
 end
@@ -195,8 +198,8 @@ Keybreak.execute_with_controller do |c, sum|
   c.on(:keystart) {sum = 0}
   c.on(:keyend) {|key| puts "#{key}:#{sum}"}
 
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
+  RECORDS.each_line do |line|
+    key, value = line.split("\t")
     c.feed(key)
     sum += value.to_i
   end
@@ -222,6 +225,18 @@ 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}"}
@@ -233,25 +248,14 @@ Keybreak.execute_with_controller do |c, sum|
       sum += sub_sum
     end
     
-    DATA.each do |line|
-      key, sub_key, value = line.chomp.split("\t")
+    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
-
-__END__
-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
 ```
 
 The result will be:
@@ -271,6 +275,56 @@ 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
 
 

data/examples/count.rb

@@ -10,18 +10,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require "keybreak"
 
-Keybreak.execute_with_controller do |c, count|
-  c.on(:keystart) {count = 0}
-  c.on(:keyend) {|key| puts "#{key}:#{count}"}
-
-  DATA.each do |line|
-    key = line.chomp.split("\t")[0]
-    c.feed(key)
-    count += 1
-  end
-end
-
-__END__
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -31,3 +20,17 @@ 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
+
+# EOF

data/examples/empty_key.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+# Print sum of values for each key where empty key means continuation
+# =>
+# 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
+	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
+
+# EOF

data/examples/first_value.rb

@@ -10,16 +10,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require "keybreak"
 
-Keybreak.execute_with_controller do |c|
-  c.on(:keystart) {|key, value| puts "#{key}:#{value}"}
-
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
-    c.feed(key, value)
-  end
-end
-
-__END__
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -29,3 +20,15 @@ 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
+
+#EOF

data/examples/last_value.rb

@@ -10,16 +10,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require "keybreak"
 
-Keybreak.execute_with_controller do |c|
-  c.on(:keyend) {|key, value| puts "#{key}:#{value}"}
-
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
-    c.feed(key, value)
-  end
-end
-
-__END__
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -29,3 +20,14 @@ c	6
 d	7
 e	8
 e	9
+EOD
+
+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
+

data/examples/nested_sum.rb

@@ -17,6 +17,18 @@
 $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}"}
@@ -28,8 +40,8 @@ Keybreak.execute_with_controller do |c, sum|
       sum += sub_sum
     end
     
-    DATA.each do |line|
-      key, sub_key, value = line.chomp.split("\t")
+    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
@@ -37,13 +49,4 @@ Keybreak.execute_with_controller do |c, sum|
   end
 end
 
-__END__
-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
+# EOF

data/examples/sum.rb

@@ -10,18 +10,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require "keybreak"
 
-Keybreak.execute_with_controller do |c, sum|
-  c.on(:keystart) {sum = 0}
-  c.on(:keyend) {|key| puts "#{key}:#{sum}"}
-
-  DATA.each do |line|
-    key, value = line.chomp.split("\t")
-    c.feed(key)
-    sum += value.to_i
-  end
-end
-
-__END__
+RECORDS =<<EOD
 a	1
 b	2
 b	3
@@ -31,3 +20,17 @@ c	6
 d	7
 e	8
 e	9
+EOD
+
+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
+
+# EOF

data/lib/keybreak/controller.rb

@@ -11,6 +11,7 @@ module Keybreak
       @handlers = {}
       @handlers[:keystart] = DO_NOTHING
       @handlers[:keyend] = DO_NOTHING
+      @handlers[:detection] = KEY_CHANGED
     end
     
     
@@ -18,6 +19,7 @@ module Keybreak
     # Valid events are:
     #   :keystart
     #   :keyend
+    #   :detection
     def on(event, &block)
       @handlers[event] = block
     end
@@ -30,7 +32,7 @@ module Keybreak
     # Use flush() to call the :keyend handler for the last fed key.
     def feed(key, *values)
       if @is_fed
-        if key != @key
+        if @handlers[:detection].call(key, @key)
           @handlers[:keyend].call(@key, *@values)
           @key = key
           @handlers[:keystart].call(key, *values)

data/lib/keybreak/version.rb

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

data/lib/keybreak.rb

@@ -9,6 +9,10 @@ module Keybreak
   DO_NOTHING = Proc.new {}
   
   
+  # The default key break detector
+  KEY_CHANGED = Proc.new {|key, prev_key| key != prev_key}
+  
+  
   # Executes the given block with a Controller instance.
   # Within the block, register your key break handlers and feed keys from your data.
   # Then the handlers will be called for all keys including the last key.

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: keybreak
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - hashimoton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-29 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 description: 
@@ -59,14 +59,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - examples/count.rb
+- examples/empty_key.rb
 - examples/first_value.rb
 - examples/last_value.rb
 - examples/nested_sum.rb
@@ -85,17 +87,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Keybreak is a utility module for key break processing in Ruby.