object-template 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56e379a6cf0a215d88542bde7bdae2ffba74fbf7
+  data.tar.gz: 6da3bba0bf52782c243023ebdd6e544a04db5d5a
+SHA512:
+  metadata.gz: 56a120f187e1439c0a40f29d56207e72036f815180b9c86327f9e8d5b4604ddb9cbde43419bedaed9030c94a2bb1f01236cff7025d33e6d6b90bbd7dfa887c8e
+  data.tar.gz: e0c16129bfb20ff2bb44977e16b7fdecd8ce928e1f96efb4ab5969c4bb694fdc30edd5a3f4aaaf9027272b572e413873339daba0ea2bfad1831f5ec7c406c736

data/COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 2013, Joel VanderWerf, vjoel@users.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,4 @@
+object-template
+===============
+
+Templates for matching objects.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake'
+require 'rake/testtask'
+
+desc "Run tests"
+Rake::TestTask.new :test do |t|
+  t.libs << "lib"
+  t.libs << "ext"
+  t.test_files = FileList["test/*.rb"]
+end
+
+desc "Run benchmarks"
+Rake::TestTask.new :bench do |t|
+  t.libs << "lib"
+  t.libs << "ext"
+  t.test_files = FileList["bench/*.rb"]
+end

data/bench/bench-match.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift File.join(__dir__, "lib")
+
+require 'bench'
+require 'object-template'
+
+ROT = RubyObjectTemplate
+POT = PortableObjectTemplate
+
+SEED = 1237
+
+def make_dataset
+  strs = ("a".."z").map {|c| "fo" + c}
+  (1..1000).map {|i| [ i, strs.sample, rand(50) ]}
+end
+
+def run_bench_on_template template, seed: nil
+  srand seed
+  objs = make_dataset
+
+  matched = 0
+  rslt = bench_rate n_sec: 1.0, notify: proc {|c| print c} do
+    matched += 1 if template === objs.sample
+  end
+
+  puts
+  puts "seed     = %8d" % seed
+  puts "matched  = %8d" % matched
+  puts "n_iter   = %8d" % rslt[:n_iter]
+  puts "n_chunk  = %8d" % rslt[:n_chunk]
+  puts "t_warmup = %12.3f sec" % rslt[:t_warmup]
+  puts "t_run    = %12.3f sec" % rslt[:t_run]
+  puts "rate     = %12.3f iter/sec" % rslt[:rate]
+  
+  rslt
+end
+
+template = POT.new [ {set: [0,1,2,*100..999]}, {regex: "foo"}, {value: 0} ]
+puts "Unoptimized:"
+r0 = run_bench_on_template template, seed: SEED
+
+puts
+puts "Optimized:"
+template.optimize!
+r1 = run_bench_on_template template, seed: SEED
+
+puts
+puts "Speed-up: %5.2f" % (r1[:rate] / r0[:rate])

data/bench/lib/bench.rb

@@ -0,0 +1,55 @@
+def bench
+  times = Process.times
+  t0 = times.utime + times.stime
+
+  yield
+
+  times = Process.times
+  t1 = times.utime + times.stime
+  t1 - t0
+end
+
+def bench_rate n_sec: 1.0, n_chunk: 1, notify: nil
+  times = Process.times
+  t_init = times.utime + times.stime
+  #puts "init at #{t_init}"
+
+  t_run = 0
+  n_iter = 0
+  t_now = nil
+  t_start = nil
+
+  while t_run < n_sec
+    n_chunk.times do
+      yield
+    end
+    
+    times = Process.times
+    t_now = times.utime + times.stime
+      
+    if t_now - t_init < n_sec/4.0 # warm up and seek stride
+      n_chunk *= 2
+      #puts "n_chunk = #{n_chunk}"
+      notify and notify.call "."
+    else
+      if not t_start
+        t_start = t_now
+        #puts "start at #{t_start}"
+      end
+      
+      notify and notify.call "0"
+      
+      n_iter += n_chunk
+      t_run = t_now - t_start
+    end
+  end
+
+  {
+    n_iter: n_iter,
+    t_warmup: t_start - t_init,
+    t_run: t_run,
+    rate: n_iter / t_run.to_f,
+    n_chunk: n_chunk
+  }
+end
+

data/lib/object-template.rb

@@ -0,0 +1,142 @@
+require 'set'
+
+# Base class for classes of templates used to match somewhat arbitrary objects.
+class ObjectTemplate
+  # A set implementation that treats the matching operator (===) as membership.
+  # Used internally by PortableObjectTemplate, but can also be used in
+  # RubyObjectTemplate or in case statements.
+  class MemberMatchingSet < Set
+    alias === member?
+  end
+
+  # The key_converter is for matching objects that, for example, have had symbol
+  # keys serialized to strings. Using a converter that round-trips through the
+  # same serialializer, symbols in keys will match strings. However, symbols in
+  # values will not.
+  def initialize spec, key_converter = nil
+    unless spec.respond_to? :size and spec.respond_to? :each
+      raise ArgumentError, "cannot be used as a template: #{spec.inspect}"
+    end
+
+    @spec = spec
+    @size = spec.size
+    @matchers = []
+    
+    if spec.respond_to? :to_hash # assume hash-like
+      @shibboleth = :to_hash
+      spec.each do |k, v|
+        kc = key_converter ? key_converter[k]: k
+          # Note: cannot use key_converter[v] because v may have class, regex,
+          # or other non-serializable object.
+        fill_matchers kc, v
+      end
+
+    else # assume array-like
+      @shibboleth = :to_ary
+      spec.each_with_index do |v, i|
+        fill_matchers i, v unless v.nil?
+      end
+    end
+  end
+
+  # Reorders the list of matchers so that easy ones come first.
+  # For example: nil, then single values (==), then patterns (===).
+  # Returns self.
+  def optimize!
+    @matchers.sort_by! do |k, v|
+      case v
+      when nil;               0
+      when Range;             2
+      when Module;            3
+      when Regexp;            4
+      when MemberMatchingSet; 4
+      when Proc;              5
+      else                    1 # assume it is a value
+      end
+    end
+    self
+  end
+
+  # True if the template matches the given object.
+  # Adapted from rinda/rinda.rb.
+  def === obj
+    return false unless obj.respond_to?(@shibboleth)
+    return false unless @size == obj.size
+    @matchers.each do |k, v|
+      begin
+        it = obj.fetch(k)
+      rescue
+        return false
+      end
+      next if v.nil?
+      next if v == it
+      next if v === it
+      return false
+    end
+    return true
+  end
+
+  def inspect
+    "<#{self.class}: #{@spec}>"
+  end
+end
+
+# Template specified by array or hash of ruby objects. The #== and #===
+# methods of entry values are used in matching. Entry values may include
+# classes, regexes, ranges, and so on, in addition to single values.
+class RubyObjectTemplate < ObjectTemplate
+  def fill_matchers k, v  # :nodoc:
+    @matchers << [k, v]
+  end
+end
+
+# Template specified by array or hash in a portable format composed of
+# strings, numbers, booleans, arrays, and hashes. Special entry values
+# correspond to wildcards and matchers of several kinds. See the unit
+# tests for examples.
+#
+# The objects matched include anything constructed out of numbers, booleans,
+# including null, and strings using hashes and arrays. In other words,
+# objects that can be serialized with json or msgpack.
+#
+class PortableObjectTemplate < ObjectTemplate
+  def fill_matchers k, v  # :nodoc:
+    case v
+    when nil
+      @matchers << [k, nil]
+        # This must be there to ensure the key exists in the hash case.
+    when Hash
+      v.each do |kk, vv|
+        case kk
+        when :value, "value"
+          @matchers << [k, vv]
+        when :set, "set"
+          @matchers << [k, MemberMatchingSet.new(vv)]
+        when :type, "type"
+          @matchers << [k, CLASS_FOR[vv.to_s]]
+        when :range, "range"
+          @matchers << [k, Range.new(*vv)]
+        when :regex, "regex"
+          @matchers << [k, Regexp.new(vv)]
+        else
+          raise ArgumentError,
+            "unrecognized match specifier: #{kk.inspect}"
+        end
+      end
+    else
+      raise ArgumentError,
+        "expected nil or Hash in template, found #{v.inspect}"
+    end
+  end
+
+  CLASS_FOR = {
+    "number" => Numeric,
+    "string" => String,
+    "list"   => Array,
+    "map"    => Hash
+  }
+
+  CLASS_FOR.default_proc = proc do |h,k|
+    raise ArgumentError, "no known class for matching type #{k.inspect}"
+  end
+end

data/test/lib/assert-threequal.rb

@@ -0,0 +1,11 @@
+module AssertThreequal
+  def assert_threequal o1, o2, msg = nil
+    msg = message(msg) { "Expected #{mu_pp(o1)} to be === #{mu_pp(o2)}" }
+    assert o1.__send__(:===, o2), msg
+  end
+  
+  def assert_not_threequal o1, o2, msg = nil
+    msg = message(msg) { "Expected #{mu_pp(o1)} to be !== #{mu_pp(o2)}" }
+    assert !(o1.__send__(:===, o2)), msg
+  end
+end

data/test/lib/eq3.rb

@@ -0,0 +1,48 @@
+require 'assert-threequal'
+
+module Eq3
+  include AssertThreequal
+  
+  ROT = RubyObjectTemplate
+  POT = PortableObjectTemplate
+  
+  KEY_CONV = proc {|x| Symbol === x ? x.to_s : x}
+  
+  FIELD_NAMES = ["zero", "one", "two", "three", "four", "five", "six"]
+
+  def mkhash ary
+    Hash[ FIELD_NAMES[0...ary.size].zip(ary) ]
+  end
+
+  def pot_for(pot)
+    POT.new(pot, KEY_CONV).optimize!
+  end
+
+  def rot_for(rot)
+    ROT.new(rot, KEY_CONV).optimize!
+  end
+
+  def eq3 literal, rot, pot
+    assert_threequal(rot_for(rot), literal)
+    assert_threequal(pot_for(pot), literal)
+
+    if literal.kind_of? Array
+      hlit = mkhash(literal)
+      hrot = mkhash(rot)
+      hpot = mkhash(pot)
+      eq3 hlit, hrot, hpot
+    end
+  end
+
+  def ne3 literal, rot, pot
+    assert_not_threequal(rot_for(rot), literal)
+    assert_not_threequal(pot_for(pot), literal)
+
+    if literal.kind_of? Array
+      hlit = mkhash(literal)
+      hrot = mkhash(rot)
+      hpot = mkhash(pot)
+      ne3 hlit, hrot, hpot
+    end
+  end
+end

data/test/test-errors.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift File.join(__dir__, "lib")
+
+require 'minitest/autorun'
+require 'object-template'
+require 'eq3'
+
+class TestErrors < Minitest::Test
+  POT = PortableObjectTemplate
+  ROT = RubyObjectTemplate
+  
+  def test_bad_type
+    assert_raises ArgumentError do
+      POT.new [ {type: "float"} ]
+    end
+  end
+
+  def test_bad_entry
+    assert_raises ArgumentError do
+      POT.new [ "number" ]
+    end
+  end
+
+  def test_bad_match_specifier
+    assert_raises ArgumentError do
+      POT.new [ {foo: 1} ]
+    end
+  end
+end

data/test/test-key-conv.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift File.join(__dir__, "lib")
+
+require 'minitest/autorun'
+require 'object-template'
+require 'assert-threequal'
+
+class TestKeyConv < Minitest::Test
+  include AssertThreequal
+
+  POT = PortableObjectTemplate
+  ROT = RubyObjectTemplate
+
+  def test_match_converted_key
+    assert_threequal(
+      POT.new(
+        {foo: {value: 1}},
+          proc {|x| Symbol === x ? x.to_s : x}),
+        {"foo" => 1}
+    )
+
+    assert_threequal(
+      ROT.new(
+        {foo: 1},
+          proc {|x| Symbol === x ? x.to_s : x}),
+        {"foo" => 1}
+    )
+  end
+
+  def test_not_match_unconverted_key
+    assert_not_threequal(
+      POT.new(
+        {foo: {value: 1}},
+          proc {|x| x}),
+        {"foo" => 1}
+    )
+
+    assert_not_threequal(
+      ROT.new(
+        {foo: 1},
+          proc {|x| x}),
+        {"foo" => 1}
+    )
+  end
+end

data/test/test-match.rb

@@ -0,0 +1,165 @@
+$LOAD_PATH.unshift File.join(__dir__, "lib")
+
+require 'minitest/autorun'
+require 'object-template'
+require 'set'
+require 'eq3'
+
+Member = ObjectTemplate::MemberMatchingSet
+
+class TestMatch < Minitest::Test
+  include Eq3
+  
+  def test_cardinality
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 1. every test that can be expressed in terms of presence of column/field
+#=    or cardinality of columns/fields, without matching values
+#=
+eq3                 [],              [],              []
+eq3       ["anything"],           [nil],           [nil]
+eq3   ["any", "thing"],      [nil, nil],      [nil, nil]
+#=========================================================
+ne3       ["anything"],              [],              []
+ne3                 [],           [nil],           [nil] # cardinality mismatch
+ne3   ["any", "thing"],           [nil],           [nil] # ditto
+ne3       ["anything"],      [nil, nil],      [nil, nil]
+#=========================================================
+#= 1a. specific to hashes
+ne3( {foo: "anything"},      {bar: nil},      {bar: nil} ) # name mismatch
+#=========================================================
+  end
+
+  def test_literal
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 2. every test that can be expressed in terms of a literal value in the
+#=    template
+#=
+literals = [
+  true, false,
+  42, -1.2e13, "baz",
+  43, 2.4507, "zap",
+  [1,2,3], {a: 1, b: 2},
+  ["a", "b"], {x: "y"}
+]
+literals.each do |x1|
+  literals.each do |x2|
+    if x1 == x2
+      eq3         [x1],            [x1],   [{value: x1}]
+    else
+      ne3         [x1],            [x2],   [{value: x2}]
+    end
+    eq3       [x1, x2],        [x1, x2],   [{value: x1}, {value: x2}]
+  end
+end
+#=========================================================
+  end
+
+  def test_set
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 3. every test that can be expressed in terms of a set of values in the
+#=    template
+#=
+eq3                [1], [Member[0,1,2]], [{set: [0,1,2]}]
+#=========================================================
+ne3                [4], [Member[0,1,2]], [{set: [0,1,2]}]
+#=========================================================
+  end
+
+  def test_range
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 4. every test that can be expressed in terms of a range in the
+#=    template
+#=
+eq3                [0],          [0..2], [{range: [0,2]}]
+eq3                [2],          [0..2], [{range: [0,2]}]
+eq3                [1],         [0...2], [{range: [0,2, true]}]
+#=========================================================
+ne3               [-1],          [0..2], [{range: [0,2]}]
+ne3                [3],          [0..2], [{range: [0,2]}]
+ne3                [2],         [0...2], [{range: [0,2, true]}]
+#=========================================================
+  end
+
+  def test_regex
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 5. every test that can be expressed in terms of a regex in the
+#=    template
+#=
+eq3            ["foo"],          [/oo/], [{regex: "oo"}]
+eq3            ["foo"],     [/[f]\w\w/], [{regex: "[f]\\w\\w"}]
+#=========================================================
+ne3            ["foo"],          [/zz/], [{regex: "zz"}]
+ne3            ["foo"],       [/o{3,}/], [{regex: "o{3,}"}]
+#=========================================================
+  end
+
+  def test_type
+#=========================================================
+#=            LITERAL |             ROT |            POT
+#=========================================================
+#= 6. every test that can be expressed in terms of a type in the
+#=    template
+#=
+eq3               [42],       [Numeric], [{type: "number"}]
+eq3            ["foo"],        [String], [{type: "string"}]
+eq3          [[1,2,3]],         [Array], [{type: "list"}]
+eq3       [{a:1, b:2}],         [Hash],  [{type: "map"}]
+#=========================================================
+ne3             ["42"],       [Numeric], [{type: "number"}]
+ne3              [123],        [String], [{type: "string"}]
+ne3       [{a:1, b:2}],         [Array], [{type: "list"}]
+ne3          [[1,2,3]],         [Hash],  [{type: "map"}]
+#=========================================================
+  end
+
+  def test_conjunction
+    ## note that ROT doesn't support conjunctions, though it would be easy
+    ## to implement.
+    eq3 ["abc"], [nil], [{type: "string", regex: "b", set: ["abc", "def"]}]
+    ne3 ["abc"],   [0], [{type: "list",   regex: "b", set: ["abc", "def"]}]
+    ne3 ["abc"],   [0], [{type: "string", regex: "d", set: ["abc", "def"]}]
+    ne3 ["abc"],   [0], [{type: "string", regex: "b", set: ["xyz", "def"]}]
+  end
+
+  # test that a mismatch in one entry makes the template match fail
+  def test_all_entries
+    eq3 [                5,           1.23,            "bar",         "baz",          [1,2],          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [            "foo",           1.23,            "bar",         "baz",          [1,2],          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [                5,           4.23,            "bar",         "baz",          [1,2],          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [                5,           1.23,          ["bar"],         "baz",          [1,2],          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [                5,           1.23,            "bar",         "bAz",          [1,2],          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [                5,           1.23,            "bar",         "baz",          {a:2},          {a: 1} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+    ne3 [                5,           1.23,            "bar",         "baz",          [1,2],          {a: 2} ],
+        [          Numeric,           1..3,           String,          /az/,          Array,          {a: 1} ],
+        [ {type: "number"}, {range: [1,3]}, {type: "string"}, {regex: "az"}, {type: "list"}, {value: {a: 1}} ]
+
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: object-template
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joel VanderWerf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-12 00:00:00.000000000 Z
+dependencies: []
+description: Templates for matching objects.
+email: vjoel@users.sourceforge.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- README.md
+- COPYING
+- Rakefile
+- lib/object-template.rb
+- bench/lib/bench.rb
+- bench/bench-match.rb
+- test/lib/assert-threequal.rb
+- test/lib/eq3.rb
+- test/test-match.rb
+- test/test-key-conv.rb
+- test/test-errors.rb
+homepage: https://github.com/vjoel/object-template
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --quiet
+- --line-numbers
+- --inline-source
+- --title
+- object-template
+- --main
+- README.md
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Templates for matching objects
+test_files:
+- test/test-match.rb
+- test/test-key-conv.rb
+- test/test-errors.rb
+has_rdoc: