mercury_amqp 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95133530de1763cec95808562a5e7fc63051357c
-  data.tar.gz: 0c67f736b817ae297846b28daee0ecaba4b5db44
+  metadata.gz: 4870a8839ae27cd315c1812fabf3657b83719894
+  data.tar.gz: 8f88e142bdd7353de606efb5e64952b947b8061d
 SHA512:
-  metadata.gz: 6d41a7d999b7f16ba2a19cd5a1bf625bf0899cffadfa08ae0d4a7d0db636ee37786ab752747a2e0e59a5a609d22be36bbf2ef1921aaa01edcb0c58a20ae49427
-  data.tar.gz: 31cee609bd834fc298f7879fb8ef26d65f3cd6cbe5219825c409a638049a9747fbacd9f01711d2d603d96182e611ab7f0280869d31d805bb3526b1e08d7b810a
+  metadata.gz: ca6fc752c0a82c9f35d61fafa80ceed4b1cb18577c06ca8ab49377cd471ad6c8e1b14a75962e66d54bf064b65eb0786cda19bae1a8474004e4796713932916f0
+  data.tar.gz: 322754fee9b93640f7d32f046af978f88373484b478c5a38d71a10cdc1a48b92b58e50fd0adcbef6330b6f5163d9e6c64d7606a24c1fb21becc0a35573b4d906

data/lib/mercury/cps/methods.rb

@@ -1,23 +1,25 @@
-class Cps
-  module Methods
-    def lift(&block)
-      Cps.lift(&block)
-    end
+class Mercury
+  class Cps
+    module Methods
+      def lift(&block)
+        Cps.lift(&block)
+      end
 
-    def seq(&block)
-      Cps.seq(&block)
-    end
+      def seq(&block)
+        Cps.seq(&block)
+      end
 
-    def seql(&block)
-      Cps.seql(2, &block)
-    end
+      def seql(&block)
+        Cps.seql(2, &block)
+      end
 
-    def seqp(&block)
-      Cps.seqp(&block)
-    end
+      def seqp(&block)
+        Cps.seqp(&block)
+      end
 
-    def cps(&block)
-      Cps.new(&block)
+      def cps(&block)
+        Cps.new(&block)
+      end
     end
   end
 end

data/lib/mercury/cps/seq.rb

@@ -1,19 +1,21 @@
-class Cps
+class Mercury
+  class Cps
 
-  # Syntactic sugar for and_then chains.
-  def self.seq(&block)
-    s = Seq.new
-    block.call(s.method(:chain))
-    s.m
-  end
-
-  class Seq
-    def m
-      @m ||= Cps.identity # we need an initial Cps to chain onto
+    # Syntactic sugar for and_then chains.
+    def self.seq(&block)
+      s = Seq.new
+      block.call(s.method(:chain))
+      s.m
     end
 
-    def chain(proc=nil, &block)
-      @m = m.and_then(&(proc || block))
+    class Seq
+      def m
+        @m ||= Cps.identity # we need an initial Cps to chain onto
+      end
+
+      def chain(proc=nil, &block)
+        @m = m.and_then(&(proc || block))
+      end
     end
   end
 end

data/lib/mercury/cps/seq_with_let.rb

@@ -1,67 +1,69 @@
 require 'binding_of_caller'
 
-class Cps
-  # Syntactic sugar for and_then chains.
-  def self.seql(depth=1, &block)
-    # EXPERIMENTAL
-    # The trick here is to execute the block in a context where
-    # 1. we can simulate local let-bound variables, and
-    # 2. the block can access variables and methods available
-    #    outside the call to seql.
-    #
-    # To achieve this, we instance_exec the block in a SeqWithLet
-    # object, which provides the let bound variables (as methods)
-    # and uses method_missing to proxy other methods to the parent
-    # binding.
-    #
-    # Note: parent instance variables are not available inside the block.
-    # Note: keyword arguments are not proxied to methods called in the parent binding
-    context = SeqWithLet.new(binding.of_caller(depth))
-    context.instance_exec(&block)
-    context.__chain
-  end
+class Mercury
+  class Cps
+    # Syntactic sugar for and_then chains.
+    def self.seql(depth=1, &block)
+      # EXPERIMENTAL
+      # The trick here is to execute the block in a context where
+      # 1. we can simulate local let-bound variables, and
+      # 2. the block can access variables and methods available
+      #    outside the call to seql.
+      #
+      # To achieve this, we instance_exec the block in a SeqWithLet
+      # object, which provides the let bound variables (as methods)
+      # and uses method_missing to proxy other methods to the parent
+      # binding.
+      #
+      # Note: parent instance variables are not available inside the block.
+      # Note: keyword arguments are not proxied to methods called in the parent binding
+      context = SeqWithLet.new(binding.of_caller(depth))
+      context.instance_exec(&block)
+      context.__chain
+    end
 
-  class SeqWithLet
+    class SeqWithLet
 
-    def and_then(&block)
-      @__chain = __chain.and_then(&block)
-    end
+      def and_then(&block)
+        @__chain = __chain.and_then(&block)
+      end
 
-    def and_lift(&block)
-      @__chain = __chain.and_lift(&block)
-    end
+      def and_lift(&block)
+        @__chain = __chain.and_lift(&block)
+      end
 
-    def let(name, &block)
-      and_then(&block)
-      and_then do |value|
-        __values[name] = value
-        Cps.lift{value}
+      def let(name, &block)
+        and_then(&block)
+        and_then do |value|
+          __values[name] = value
+          Cps.lift{value}
+        end
       end
-    end
 
-    def initialize(parent_binding)
-      @__parent_binding = parent_binding
-    end
+      def initialize(parent_binding)
+        @__parent_binding = parent_binding
+      end
 
-    def __chain
-      @__chain ||= Cps.identity
-    end
+      def __chain
+        @__chain ||= Cps.identity
+      end
 
-    def method_missing(name, *args, &block)
-      __values.fetch(name) { __parent_call(name.to_s, *args, &block) }
-    end
+      def method_missing(name, *args, &block)
+        __values.fetch(name) { __parent_call(name.to_s, *args, &block) }
+      end
 
-    def __parent_call(name, *args, &block)
-      @__parent_caller ||= @__parent_binding.eval <<-EOD
+      def __parent_call(name, *args, &block)
+        @__parent_caller ||= @__parent_binding.eval <<-EOD
       proc do |name, *args, &block|
         send(name, *args, &block)
       end
-      EOD
-      @__parent_caller.call(name, *args, &block)
-    end
+        EOD
+        @__parent_caller.call(name, *args, &block)
+      end
 
-    def __values
-      @__values ||= {}
+      def __values
+        @__values ||= {}
+      end
     end
   end
 end

data/lib/mercury/cps.rb

@@ -13,85 +13,87 @@ require 'mercury/utils'
 # passing. It basically wraps a CPS proc with methods for
 # composing them.
 # See http://codon.com/refactoring-ruby-with-monads
-class Cps
-  attr_reader :cps
+class Mercury
+  class Cps
+    attr_reader :cps
 
-  # @param [Proc] cps a CPS proc (signature: *args, &k)
-  def initialize(&cps)
-    @cps = cps
-  end
+    # @param [Proc] cps a CPS proc (signature: *args, &k)
+    def initialize(&cps)
+      @cps = cps
+    end
 
-  # Applies the wrapped proc. If the CPS return value
-  # is not needed, the continuation k may be omitted.
-  # Returns the return value of the continuation.
-  def run(*args, &k)
-    k ||= proc { |x| x }
-    cps.call(*args, &k)
-  end
+    # Applies the wrapped proc. If the CPS return value
+    # is not needed, the continuation k may be omitted.
+    # Returns the return value of the continuation.
+    def run(*args, &k)
+      k ||= proc { |x| x }
+      cps.call(*args, &k)
+    end
 
-  # The "bind" operation; composes two Cps
-  # @param [Proc] pm a proc that takes the output of this
-  #   Cps and returns a Cps
-  def and_then(&pm)
-    Cps.new do |*args, &k|
-      self.run(*args) do |*args2|
-        next_cps = pm.call(*args2)
-        next_cps.is_a?(Cps) or raise "'and_then' block did not return a Cps. Did you want 'and_lift'? at #{pm.source_location}"
-        next_cps.run(&k)
+    # The "bind" operation; composes two Cps
+    # @param [Proc] pm a proc that takes the output of this
+    #   Cps and returns a Cps
+    def and_then(&pm)
+      Cps.new do |*args, &k|
+        self.run(*args) do |*args2|
+          next_cps = pm.call(*args2)
+          next_cps.is_a?(Cps) or raise "'and_then' block did not return a Cps. Did you want 'and_lift'? at #{pm.source_location}"
+          next_cps.run(&k)
+        end
       end
     end
-  end
 
-  # equivalent to: and_then { lift { ... } }
-  def and_lift(&p)
-    and_then do |*args|
-      Cps.lift { p.call(*args) }
+    # equivalent to: and_then { lift { ... } }
+    def and_lift(&p)
+      and_then do |*args|
+        Cps.lift { p.call(*args) }
+      end
     end
-  end
 
-  # Returns a Cps for a non-CPS proc.
-  def self.lift(&p)
-    new { |*args, &k| k.call(p.call(*args)) }
-  end
+    # Returns a Cps for a non-CPS proc.
+    def self.lift(&p)
+      new { |*args, &k| k.call(p.call(*args)) }
+    end
 
-  # The identity function as a Cps.
-  def self.identity
-    new { |*args, &k| k.call(*args) }
-  end
+    # The identity function as a Cps.
+    def self.identity
+      new { |*args, &k| k.call(*args) }
+    end
 
-  # Returns a Cps that executes the provided Cpses concurrently.
-  # Once all complete, their return values are passed to the continuation
-  # in an array with positions corresponding to the provided Cpses.
-  def self.concurrently(*cpss)
-    cpss = Utils.unsplat(cpss)
+    # Returns a Cps that executes the provided Cpses concurrently.
+    # Once all complete, their return values are passed to the continuation
+    # in an array with positions corresponding to the provided Cpses.
+    def self.concurrently(*cpss)
+      cpss = Utils.unsplat(cpss)
 
-    Cps.new do |*in_args, &k|
-      pending_completions = cpss
-      returned_args = []
-      cpss.each_with_index do |cps, i|
-        cps.run(*in_args) do |*out_args|
-          returned_args[i] = out_args
-          pending_completions.delete(cps)
-          if pending_completions.none?
-            k.call(returned_args)
+      Cps.new do |*in_args, &k|
+        pending_completions = cpss
+        returned_args = []
+        cpss.each_with_index do |cps, i|
+          cps.run(*in_args) do |*out_args|
+            returned_args[i] = out_args
+            pending_completions.delete(cps)
+            if pending_completions.none?
+              k.call(returned_args)
+            end
           end
         end
       end
     end
-  end
 
-  # Calls and_then for each x.
-  # @yieldparam  x     [Object]  An item from xs
-  # @yieldparam  *args [Objects] The value(s) passed from the last action
-  # @yieldreturn       [Cps]     The next action to add to the chain
-  def inject(xs, &block)
-    xs.inject(self) do |chain, x|
-      chain.and_then { |*args| block.call(x, *args) }
+    # Calls and_then for each x.
+    # @yieldparam  x     [Object]  An item from xs
+    # @yieldparam  *args [Objects] The value(s) passed from the last action
+    # @yieldreturn       [Cps]     The next action to add to the chain
+    def inject(xs, &block)
+      xs.inject(self) do |chain, x|
+        chain.and_then { |*args| block.call(x, *args) }
+      end
     end
-  end
 
-  # equivalent to Cps.identity.inject(...)
-  def self.inject(xs, &block)
-    Cps.identity.inject(xs, &block)
+    # equivalent to Cps.identity.inject(...)
+    def self.inject(xs, &block)
+      Cps.identity.inject(xs, &block)
+    end
   end
 end

data/lib/mercury/utils.rb

@@ -1,9 +1,11 @@
-class Utils
-  def self.unsplat(args)
-    if args.size == 1 and args.first.is_a?(Array)
-      args.first
-    else
-      args
+class Mercury
+  class Utils
+    def self.unsplat(args)
+      if args.size == 1 and args.first.is_a?(Array)
+        args.first
+      else
+        args
+      end
     end
   end
 end

data/lib/mercury/version.rb

@@ -1,3 +1,3 @@
 class Mercury
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/spec/lib/mercury/cps_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'mercury/cps'
 
+Cps = Mercury::Cps
+
 describe Cps do
   include Cps::Methods
 

data/spec/lib/mercury/utils_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'mercury/utils'
 
+Utils = Mercury::Utils
+
 describe Utils do
   describe '::unsplat' do
     it 'allows args to be provided in splatted form' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mercury_amqp
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Peter Winton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler