stal 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01f32692fdb539b8eebbc7d2964ba275aecef27b
-  data.tar.gz: a971d29478038e640c0e94fd2636e0a57edd807f
+  metadata.gz: e0c73d92dba5eab545ca813c4e47885b77c78e34
+  data.tar.gz: daf465500d116a4ead3f79d5532aabecda8a67d3
 SHA512:
-  metadata.gz: dc8a947141e7a9d84d8c78ba58097d5cdb002b2493fdbd5a9752cb98306cd661c4f49e6c2b353c4371bb28ff45f30368b255f200d56a467bfe265c69fe620bfd
-  data.tar.gz: 47e6bb79573cde80bce0ed2554ef135de38f52c45ce5303761886d41f2b14b4bb4994632d45007d342685f21c530241d111dc8abe7a2984ef2beebc4361b082d
+  metadata.gz: 6a656ad854d7bb0027d45988772d3b81dfe49775344301424f4dc876977027d6ec1a207835e9570f8cf15434abf66e402e75e646ec5fdf9ab2ebdce23443911d
+  data.tar.gz: 30851cd6f82f3072f2526359b73608a90dc07d1459944e681591453d02101f37c420feac75879b2dfcdb327bc00c799741a7147c316ed0f3048937953f4042e7

data/README.md

@@ -49,44 +49,39 @@ redis.call("SADD", "qux", "x", "y", "z")
 Now we can perform some set operations with `Stal`:
 
 ```ruby
-expr = [:union, "qux", [:diff, [:inter, "foo", "bar"], "baz"]]
+expr = [:SUNION, "qux", [:SDIFF, [:SINTER, "foo", "bar"], "baz"]]
 
 Stal.solve(redis, expr)
 #=> ["b", "x", "y", "z"]
 ```
 
-`Stal` translates the shortcuts `:union`, `:diff` and `:inter` into
-`SDIFFSTORE`, `SINTERSTORE` and `SUNIONSTORE` to perform the
-underlying operations. You can also use the explicit command
-(lowercase works too).
+`Stal` translates the internal calls to  `:SUNION`, `:SDIFF` and
+`:SINTER` into `SDIFFSTORE`, `SINTERSTORE` and `SUNIONSTORE` to
+perform the underlying operations, and it takes care of generating
+and deleting any temporary keys.
+
+Note that the only valid names for the internal commands are
+`:SUNION`, `:SDIFF` and `:SINTER`. Any other internal command will
+raise an error. The outmost command can be any set operation, for
+example:
 
 ```ruby
-expr = [:SUNIONSTORE, "qux", [:SDIFFSTORE, [:SINTERSTORE, "foo", "bar"], "baz"]]
+expr = [:SCARD, [:SINTER, "foo", "bar"]]
 
 Stal.solve(redis, expr)
-#=> ["b", "x", "y", "z"]
+#=> 2
 ```
 
 If you want to preview the commands `Stal` will send to generate
 the results, you can use `Stal.compile`:
 
 ```ruby
-Stal.compile([:inter, [:union, "foo", "bar"], "baz"])
-#  [[:SUNIONSTORE, "stal:55f631dc-...", "foo", "bar"],
-#   [:SINTERSTORE,
-#    "stal:fe5aaec9-...",
-#    "stal:55f631dc-...",
-#    "baz"],
-#   [:SMEMBERS, "stal:fe5aaec9-..."],
-#   [:DEL,
-#    "stal:fe5aaec9-...",
-#    "stal:55f631dc-..."]]
+Stal.explain([:SINTER, [:SUNION, "foo", "bar"], "baz"])
+#  [["SUNIONSTORE", "stal:0", "foo", "bar"],
+#   [:SINTER, "stal:0", "baz"]]
 ```
 
 All commands are pipelined and wrapped in a `MULTI/EXEC` transaction.
-The temporary keys, which have been shortened in the example, are
-deleted immediately.
-
 
 Installation
 ------------

data/lib/stal.rb

@@ -1,69 +1,85 @@
 # encoding: UTF-8
 
 require "redic"
-require "securerandom"
 
 module Stal
-  ALIASES = {
-    :diff        => "SDIFFSTORE",
-    :inter       => "SINTERSTORE",
-    :union       => "SUNIONSTORE",
+  class InvalidCommand < ArgumentError; end
+
+  COMMANDS = {
+    :SDIFF  => 'SDIFFSTORE',
+    :SINTER => 'SINTERSTORE',
+    :SUNION => 'SUNIONSTORE',
   }
 
-  def self.tr(term)
-    ALIASES.fetch(term, term)
+  def self.command(term)
+    COMMANDS.fetch(term) do
+      raise(InvalidCommand, term)
+    end
   end
 
-  def self.compute(expr, ids, acc)
-    id = sprintf("stal:%s", SecureRandom.uuid)
-
-    # Keys we need to clean up later
-    ids.push(id)
-
-    # Add command with destination key
-    cmd = [tr(expr[0]), id]
-
-    expr[1..-1].each do |item|
+  # Compile expression into Redis commands
+  def self.compile(expr, ids, ops)
+    expr.map do |item|
       if Array === item
-        cmd.push(compute(item, ids, acc))
+        convert(item, ids, ops)
       else
-        cmd.push(item)
+        item
       end
     end
+  end
 
-    acc.push(cmd)
+  # Transform :SDIFF, :SINTER and :SUNION commands
+  # into SDIFFSTORE, SINTERSTORE and SUNIONSTORE.
+  def self.convert(expr, ids, ops)
+    head, *tail = expr
 
-    return id
-  end
+    # Key where partial results will be stored
+    id = sprintf("stal:%s", ids.size)
 
-  def self.compile(expr)
+    # Keep a reference to clean it up later
+    ids.push(id)
 
-    # Commands to process
-    acc = []
+    # Translate into command and destination key
+    op = [command(head), id]
 
-    # Keys to cleanup
+    # Compile the rest recursively
+    op.concat(compile(tail, ids, ops))
+
+    # Append the outermost operation
+    ops.push(op)
+
+    return id
+  end
+
+  # Return commands without any wrapping added by `solve`
+  def self.explain(expr)
     ids = []
+    ops = []
 
-    id = compute(expr, ids, acc)
+    ops.push(compile(expr, ids, ops))
 
-    acc.push([:SMEMBERS, id])
-    acc.push([:DEL, *ids])
-    acc
+    return ops
   end
 
   # Evaluate expression `expr` in the Redis client `c`.
   def self.solve(c, expr)
-    operations = compile(expr)
+    ids = []
+    ops = []
 
-    c.queue("MULTI")
+    ops.push(compile(expr, ids, ops))
 
-    operations.each do |op|
-      c.queue(*op)
-    end
+    if ops.one?
+      c.call(*ops[0])
+    else
+      c.queue("MULTI")
 
-    c.queue("EXEC")
+      ops.each do |op|
+        c.queue(*op)
+      end
 
-    # Return the result of SMEMBERS
-    c.commit[-1][-2]
+      c.queue("DEL", *ids)
+      c.queue("EXEC")
+      c.commit[-1][-2]
+    end
   end
 end

data/stal.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "stal"
-  s.version = "0.0.1"
+  s.version = "0.1.0"
   s.summary = %{Set algebra solver for Redis}
   s.description = %Q{Stal receives s-expressions and resolves the set operations in Redis}
   s.authors = ["Michel Martens"]

data/test/all.rb

@@ -12,26 +12,37 @@ end
 
 test do |c|
 
-  # Shortcut syntax
-  expr = [:union, "qux", [:diff, [:inter, "foo", "bar"], "baz"]]
-
-  # Explicit syntax
-  expr = [:SUNIONSTORE, "qux", [:SDIFFSTORE, [:SINTERSTORE, "foo", "bar"], "baz"]]
+  # Example expression
+  expr = ["SUNION", "qux", [:SDIFF, [:SINTER, "foo", "bar"], "baz"]]
 
   assert_equal ["b", "x", "y", "z"], Stal.solve(c, expr).sort
 
-  # Explicit syntax with strings
-  expr = ["SUNIONSTORE", "qux", ["SDIFFSTORE", ["SINTERSTORE", "foo", "bar"], "baz"]]
+  # Commands in sub expressions must be symbols
+  expr = ["SUNION", "qux", ["SDIFF", ["SINTER", "foo", "bar"], "baz"]]
 
-  assert_equal ["b", "x", "y", "z"], Stal.solve(c, expr).sort
+  assert_raise(Stal::InvalidCommand) do
+    Stal.solve(c, expr)
+  end
 
-  # Explicit syntax with lowercase strings
-  expr = ["sunionstore", "qux", ["sdiffstore", ["sinterstore", "foo", "bar"], "baz"]]
+  # Commands without sub expressions also work
+  expr = ["SINTER", "foo", "bar"]
 
-  assert_equal ["b", "x", "y", "z"], Stal.solve(c, expr).sort
+  assert_equal ["b", "c"], Stal.solve(c, expr).sort
 
-  assert_equal ["b", "x", "y", "z"], Stal.solve(c, expr).sort
+  # Only :SUNION, :SDIFF and :SINTER are supported in sub expressions
+  expr = ["SUNION", ["DEL", "foo"]]
 
-  # Verify there's no pollution
+  assert_raise(Stal::InvalidCommand) do
+    Stal.solve(c, expr)
+  end
+
+  # Verify there's no keyspace pollution
   assert_equal ["bar", "baz", "foo", "qux"], c.call("KEYS", "*").sort
+
+  expr = ["SCARD", [:SINTER, "foo", "bar"]]
+
+  # Explain returns an array of Redis commands
+  expected = [["SINTERSTORE", "stal:0", "foo", "bar"], ["SCARD", "stal:0"]]
+
+  assert_equal expected, Stal.explain(expr)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stal
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Michel Martens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic