serializable_proc 0.3.1 → 0.4.0

data/spec/code_block/optional_arity_spec.rb

@@ -1,160 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'Extracting optional arity code block' do
-
-  extend SerializableProc::Spec::Helpers
-
-  expected_file = File.expand_path(__FILE__)
-  expected_code = "lambda { |*lvar_args| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
-
-  should_handle_proc_variable expected_file, expected_code, {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |*args|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |*args|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        proc do |*args|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |*args|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        Proc.new do |*args|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        Proc.new { |*args|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |*args|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |*args|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        proc do |*args|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |*args|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        Proc.new do |*args|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        Proc.new { |*args|
-          %w{a b}.map{|x| puts x }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |*args| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |*args| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        proc do |*args| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |*args| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        Proc.new do |*args| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        Proc.new { |*args| %w{a b}.map{|x| puts x } },
-    }
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new do |*args|
-        %w{a b}.map{|x| puts x }
-      end
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (SerializableProc.new do |*args| %w{a b}.map{|x| puts x } end).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (
-      SerializableProc.new { |*args|
-        %w{a b}.map{|x| puts x }
-      }
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (SerializableProc.new { |*args| %w{a b}.map{|x| puts x } }).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(lambda { |*args| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(lambda do |*args|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(proc { |*args| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(proc do |*args|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(Proc.new { |*args| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(Proc.new do |*args|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-
-end

data/spec/code_block/single_arity_spec.rb

@@ -1,159 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'Extracting single arity code block' do
-
-  extend SerializableProc::Spec::Helpers
-
-  expected_file = File.expand_path(__FILE__)
-  expected_code = "lambda { |lvar_arg| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
-
-  should_handle_proc_variable expected_file, expected_code, {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |arg|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        proc do |arg|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |arg|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        Proc.new do |arg|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        Proc.new { |arg|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |arg|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        proc do |arg|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |arg|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        Proc.new do |arg|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        Proc.new { |arg|
-          %w{a b}.map{|x| puts x }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |arg| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        proc do |arg| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |arg| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        Proc.new do |arg| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        Proc.new { |arg| %w{a b}.map{|x| puts x } },
-    }
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new do |arg|
-        %w{a b}.map{|x| puts x }
-      end
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (SerializableProc.new do |arg| %w{a b}.map{|x| puts x } end).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (
-      SerializableProc.new { |arg|
-        %w{a b}.map{|x| puts x }
-      }
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (SerializableProc.new { |arg| %w{a b}.map{|x| puts x } }).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(lambda { |arg| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(lambda do |arg|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(proc { |arg| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(proc do |arg|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(Proc.new { |arg| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(Proc.new do |arg|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-end

data/spec/code_block/zero_arity_spec.rb

@@ -1,159 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'Extracting zero arity code block' do
-
-  extend SerializableProc::Spec::Helpers
-
-  expected_file = File.expand_path(__FILE__)
-  expected_code = "lambda { [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
-
-  should_handle_proc_variable expected_file, expected_code, {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda {
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        proc do
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda {
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        Proc.new do
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        Proc.new {
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda {
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        proc do
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda {
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        Proc.new do
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        Proc.new {
-          %w{a b}.map{|x| puts x }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        proc do %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        Proc.new do %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        Proc.new { %w{a b}.map{|x| puts x } },
-    }
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new do
-        %w{a b}.map{|x| puts x }
-      end
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (SerializableProc.new do %w{a b}.map{|x| puts x } end).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (
-      SerializableProc.new {
-        %w{a b}.map{|x| puts x }
-      }
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (SerializableProc.new { %w{a b}.map{|x| puts x } }).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(lambda { %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(lambda do
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(proc { %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(proc do
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(Proc.new { %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(Proc.new do
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-end

data/spec/extending/new_matcher_w_multiple_arities_spec.rb

@@ -1,152 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe 'New matcher w multiple arities' do
-
-  expected_file = File.expand_path(__FILE__)
-  expected_code = "lambda { |lvar_arg1, lvar_arg2| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
-
-  describe '>> wo args' do
-
-    extend SerializableProc::Spec::Helpers
-    behaves_like 'has support for parsing Otaky.work (wo args)'
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      (
-        Otaky.work do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      (Otaky.work do |arg1, arg2| %w{a b}.map{|x| puts x } end).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      (
-        Otaky.work { |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        }
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      (Otaky.work { |arg1, arg2| %w{a b}.map{|x| puts x } }).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-      (Otaky.work(&(lambda { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(&(lambda do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-      (Otaky.work(&(proc { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(&(proc do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-      (Otaky.work(&(Proc.new { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(&(Proc.new do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-  end
-
-  describe '>> w args' do
-
-    extend SerializableProc::Spec::Helpers
-    behaves_like 'has support for parsing Otaky.work (w args)'
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(1, :a => 2, :b => 3) do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      (Otaky.work(1, :a => 2, :b => 3) do |arg1, arg2| %w{a b}.map{|x| puts x } end).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      (
-        Otaky.work(1, :a => 2, :b => 3) { |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        }
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      (Otaky.work(1, :a => 2, :b => 3) { |arg1, arg2| %w{a b}.map{|x| puts x } }).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-      (Otaky.work(1, {:a => 2, :b => 3} , &(lambda { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(1, {:a => 2, :b => 3}, &(lambda do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-      (Otaky.work(1, {:a => 2, :b => 3}, &(proc { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(1, {:a => 2, :b => 3}, &(proc do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-    should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-      (Otaky.work(1, {:a => 2, :b => 3}, &(Proc.new { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-        should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-    end
-
-    should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-      (
-        Otaky.work(1, {:a => 2, :b => 3}, &(Proc.new do |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        end))
-      ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-    end
-
-  end
-
-end