cc 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '092a8f09ae5339638b4fd6a296d0bb3cd67befc2584f7527e7d0646aafba9e2b'
-  data.tar.gz: b4fa984cecfcca8d16583de66edc5d17c510680c5b1594121bf6577e9c10da7e
+  metadata.gz: 1f4f552fd0a586d4321f95a788b210de1ae859f187f03ff92dff524c16021d49
+  data.tar.gz: 857478152baa7bc3ced3d103f8f8eb6797989563d7242e25dc7b7e1564b98be2
 SHA512:
-  metadata.gz: 8e547f8bf5f2f68641fce452016c71ee4099fcd9c3ea2317212d8ec241ca391f513cc14bfe075ba4a30c48bc2f5e4bf313cb59ed505c353b2107fe2a07ed3d73
-  data.tar.gz: 5943e1e78ffaa3796806a955ac0321bac05c4a1fbc38013792c0c00f88bb45fd122c66592df8eee394eab7ba33d5d5214cafddbff417e8585b0bf79bdfe10f08
+  metadata.gz: de7cb9814ffcc3b8acae9c5ad48b5a46e61d7524a28c4cd44ae7a8bd6de7ae8374bfb19474cd0cfcd7174e399c11acf1867a3bd48fb959f526bdf6cc113a8e9b
+  data.tar.gz: 81d1bcb0123efe87e9a037364cfc4da673ccf6804b0bcadab97f4da30d9385ac3c9035c5f61a65894169bde84aad2487c8f3f47e87c3c47d690714d5b2d349bf

data/cc.rb

@@ -13,7 +13,8 @@ $modlist = [
   'number',
   'regexp',
   'string',
-  'tree'
+  'tree',
+  'logic'
 ]
 
 module CC

data/enum.rb

@@ -14,6 +14,51 @@
   puts "Enumberable objects could be added head or tail:"
   pp [ 1 , [2],  3 ].unfold_head( :a, :b, :c )
   pp [[1],  2 , [3]].unfold_tail(*[:x, :y, :z])
+
+  puts "Hash could project and serialize on a subscope as a sub hash or array:"
+  {a: 1 ,b: 2,c: 3}.project(:a, :c) # => {:a=>1, :c=>3}
+  {a: 1 ,b: 2,c: 3}.serialize(:a, :c) # => [1, 3]
+
+  puts "Array could mapping with a subscope as a key-val array:"
+  a = [[1,2,3], [4,5,6], [7,8]]
+  a.mapping [:a, :b, :c] # => [{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>nil}]
+  a.mapping [:a, :d] # => [{:a=>1, :d=>2}, {:a=>4, :d=>5}, {:a=>7, :d=>8}]
+
+  puts "Building a RangeTree to query a range of records:"
+  pp(rt = RangeTree.new(records = [
+    [[1, 3], :a],
+    [[2, 4], :b],
+    [[2, 7], :c],
+    [[6],    :d],
+    [[4, 5], :e],
+    [[8],    :f],
+    [[10],   :g],
+    :y,
+    :z
+  ]))
+  # {1=>{3=>[:a]},
+  #  2=>{4=>[:b], 7=>[:c]},
+  #  6=>{6=>[:d]},
+  #  4=>{5=>[:e]},
+  #  8=>{8=>[:f]},
+  #  10=>{10=>[:g]},
+  #  0=>{0=>[:y, :z]}}
+
+  pp rt.query( Range.new(1,2) )
+  # ["complete", {[1, 3]=>[:a]}]
+
+  pp rt.query( [4,7] )
+  # ["complete", {[2, 7]=>[:c]}]
+
+  pp rt.query( 6 )
+  # ["complete", {[2, 7]=>[:c], [6, 6]=>[:d]}]
+
+  pp rt.query( [1,6] )
+  # ["partial",
+  #  {[1, 3]=>[:a], [2, 4]=>[:b], [2, 7]=>[:c], [6, 6]=>[:d], [4, 5]=>[:e]}]
+
+  pp rt.query( :a )
+  # ["unformal", {[0, 0]=>[]}]
 =end
 
 module Enumerable
@@ -75,3 +120,99 @@ class Array
     return new_records
   end
 end
+
+class RangeTree < Hash
+  attr_reader :a
+
+  # Records := [ [Range|Point, Record] | Record, ... ]
+  def initialize records
+      merge records
+  end
+
+  def merge records
+      records.each do|record|
+          head, rest = record
+          if head.is_a?(Range)
+              starter, finisher = head.min, head.max
+          elsif head.is_a?(Array)
+              starter, finisher = head.sort.first, head.sort.last
+          elsif head.is_a?(Numeric)
+              starter, finisher = head, head
+          else
+              starter, finisher, rest = 0, 0, record
+          end
+          self[starter] ||= {}
+          self[starter][finisher] ||= []
+          self[starter][finisher] << rest
+          self[starter][finisher].uniq!
+      end
+      @start_keys = self.keys.sort
+  end
+
+  def update_key
+      @start_keys = self.keys.sort
+  end
+
+  def unikey target
+      if target.is_a?(Range)
+          skey, fkey = target.min, target.max
+      elsif target.is_a?(Array)
+          skey, fkey = target.sort.first, target.sort.last
+      elsif target.is_a?(Numeric)
+          skey, fkey = target, target
+      else
+          skey, fkey = 0, 0
+      end
+      return skey, fkey
+  end
+
+  def locate target
+      skey, fkey = unikey(target)
+      keys = []
+      start_keys = self.keys.sort
+      candi_keys = start_keys.select{|sk|sk<=skey}
+      candi_keys.each do|candi_key|
+          finish_keys = self[candi_key].keys.sort
+          cand_keys = finish_keys.select{|fk|fk>=fkey}.map{|cand_key|[candi_key, cand_key]}
+          keys += cand_keys
+      end
+      return keys
+  end
+
+  def search target
+      keys = []
+      skey, fkey = unikey(target)
+      self.each do|sk, candis|
+          candis.each do|fk, cands|
+              next if fkey < sk || fk < skey
+              keys << [sk,fk]
+          end
+      end
+      return keys
+  end
+
+  def index target
+      keys = locate(target)
+      if keys.empty?
+          return 'partial', search(target)
+      elsif keys==[[0,0]]
+          return 'unformal', [[0,0]]
+      else
+          return 'complete', keys
+      end
+  end
+
+  def query target
+      result = {}
+      state, keys = index(target)
+      keys.each do|keyp|
+          sk, fk = keyp
+          result[keyp] = self[sk][fk]
+      end
+      if state=='unformal'
+          self[0] ||= {}
+          result[[0,0]] = (self[0][0]||[]).include?(target) ? target : []
+      end
+      return state, result
+  end
+end

data/logic.rb

@@ -0,0 +1,13 @@
+#coding:utf-8
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  p (1..9).map{|i|flag{[i>3, i%2==0]}}
+=end
+
+def flag op=true, &conds
+  [(conds||lambda{}).call,[]].flatten(1).reduce(op){|f,c|op==:or ? (f || c) : (f && c)}
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cc
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.5
 platform: ruby
 authors:
 - Matt
@@ -28,6 +28,7 @@ files:
 - exception.rb
 - file.rb
 - kernel.rb
+- logic.rb
 - monkey-patch.rb
 - number.rb
 - regexp.rb