opal 0.11.0.rc1 → 0.11.0

data/spec/opal/core/language/string_spec.rb

@@ -1,44 +0,0 @@
-describe "Ruby character strings" do
-  it "are produced from character shortcuts" do
-    ?z.should == 'z'
-  end
-
-  it "should parse string into %[]" do 
-    %[foo].should == "foo"
-    %|bar|.should == "bar"
-    %'baz'.should == "baz"
-  end
-
-  it "interpolate string" do 
-    a = 1
-    %[#{a}23].should == "123"
-  end
-
-  it "should not process escape characters in single-quoted heredocs" do
-    s = <<'EOD'
-  hey\now\brown\cow
-EOD
-    s.strip.should == 'hey\now\brown\cow'
-  end
-
-  it "should ignore single-quote escapes in single-quoted heredocs" do
-    s = <<'EOD'
-  they\'re greeeeaaat!
-EOD
-    s.strip.should == 'they\\\'re greeeeaaat!'
-  end
-
-  it "should process escape characters in double quoted heredocs" do
-    s = <<"EOD"
-  hey\now\brown\cow
-EOD
-    s.strip.should == "hey\now\brown\cow"
-  end
-
-  it "should treat bare-word heredoc identifiers as double-quoted" do
-    s = <<EOD
-  hey\now\brown\cow
-EOD
-    s.strip.should == "hey\now\brown\cow"
-  end
-end

data/spec/opal/core/language/ternary_operator_spec.rb

@@ -1,20 +0,0 @@
-describe "Ternary condition operator" do
-  it "returns the second argument if the condition is true" do
-    (true ? 1 : 2).should == 1
-  end
-
-  it "returns the third argument if the condition is false" do
-    (false ? 1 : 2).should == 2
-  end
-
-  it "doesn't get confused if : follows a string literal" do
-    # this could be interpreted as a Ruby 1.9 symbol hash key
-    (true ?'str':'another str').should == 'str'
-  end
-
-  it "doesn't interpret ?? as an identifier" do
-    obj = mock("object with a query method")
-    obj.should_receive("m?").and_return(true)
-    (obj.m?? 1 : 2).should == 1
-  end
-end

data/spec/opal/core/language/versions/array_1.9.rb

@@ -1,39 +0,0 @@
-describe "Array literals" do
-  it "[] accepts a literal hash without curly braces as its last parameter" do
-    ["foo", "bar" => :baz].should == ["foo", {"bar" => :baz}]
-    [1, 2, 3 => 6, 4 => 24].should == [1, 2, {3 => 6, 4 => 24}]
-  end
-
-  it "[] treats splatted nil as no element" do
-    [*nil].should == []
-    [1, *nil].should == [1]
-    [1, 2, *nil].should == [1, 2]
-    [1, *nil, 3].should == [1, 3]
-    [*nil, *nil, *nil].should == []
-  end
-end
-
-describe "The unpacking splat operator (*)" do
-  it "when applied to a non-Array value attempts to coerce it to Array if the object respond_to?(:to_a)" do
-    obj = mock("pseudo-array")
-    obj.should_receive(:to_a).and_return([2, 3, 4])
-    [1, *obj].should == [1, 2, 3, 4]
-  end
-
-  it "when applied to a non-Array value uses it unchanged if it does not respond_to?(:to_a)" do
-    obj = Object.new
-    obj.should_not respond_to(:to_a)
-    [1, *obj].should == [1, obj]
-  end
-
-  it "can be used before other non-splat elements" do
-    a = [1, 2]
-    [0, *a, 3].should == [0, 1, 2, 3]
-  end
-
-  it "can be used multiple times in the same containing array" do
-    a = [1, 2]
-    b = [1, 0]
-    [*a, 3, *a, *b].should == [1, 2, 3, 1, 2, 1, 0]
-  end
-end

data/spec/opal/core/language/versions/case_1.9.rb

@@ -1,20 +0,0 @@
-describe "The 'case'-construct" do
-  it "takes multiple expanded arrays" do
-    a1 = ['f', 'o', 'o']
-    a2 = ['b', 'a', 'r']
-
-    case 'f'
-      when *a1, *['x', 'y', 'z']
-        "foo"
-      when *a2, *['x', 'y', 'z']
-        "bar"
-    end.should == "foo"
-
-    case 'b'
-      when *a1, *['x', 'y', 'z']
-        "foo"
-      when *a2, *['x', 'y', 'z']
-        "bar"
-    end.should == "bar"
-  end
-end

data/spec/opal/core/language/versions/def_2_0_spec.rb

@@ -1,58 +0,0 @@
-# TODO: this should be loaded from rubyspec instead
-
-describe "An instance method with keyword arguments" do
-  context "when there is a single keyword argument" do
-    before do
-      def foo(a: 1)
-        a
-      end
-    end
-
-    it "evaluates to the default when a value isn't provided" do
-      foo.should == 1
-    end
-
-    it "evaluates to the provided value" do
-      foo(a: 20).should == 20
-      foo(a: nil).should be_nil
-    end
-
-    it "raises an argument error when a non-keyword argument is provided" do
-      lambda { foo(1) }.should raise_error(ArgumentError)
-    end
-  end
-
-  it "treats a sole hash argument correctly" do
-    def foo(a, b: 10)
-      [a, b]
-    end
-    foo(b: "b").should == [{:b => "b"}, 10]
-    foo("a", b: "b").should == ["a", "b"]
-  end
-
-  it "correctly distinguishes between optional and keyword arguments" do
-    def foo(a = true, b: 10)
-      [a, b]
-    end
-    foo(b: 42).should == [true, 42]
-    foo(false, b: 42).should == [false, 42]
-  end
-
-  it "correctly distinguishes between rest and keyword arguments" do
-    def foo(*a, b: 10)
-      [a, b]
-    end
-    foo(1, 2, 3, 4).should == [[1, 2, 3, 4], 10]
-    foo(1, 2, 3, 4, b: 42).should == [[1, 2, 3, 4], 42]
-    foo(b: 42).should == [[], 42]
-  end
-
-  it "should allow keyword rest arguments" do
-    def foo(a: 1, **b)
-      [a, b]
-    end
-    foo(b: 2, c: 3, d: 4).should == [1, {:b => 2, :c => 3, :d => 4}]
-    foo(a: 4, b: 2).should == [4, {:b => 2}]
-    foo.should == [1, {}]
-  end
-end

data/spec/opal/core/language/versions/hash_1_9_spec.rb

@@ -1,23 +0,0 @@
-describe "Hash literal" do
-  describe "new-style hash syntax" do
-    it "constructs a new hash with the given elements" do
-      {foo: 123}.should == {:foo => 123}
-      {rbx: :cool, specs: 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-    end
-
-    it "ignores a hanging comma" do
-      {foo: 123,}.should == {:foo => 123}
-      {rbx: :cool, specs: 'fail_sometimes',}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-    end
-
-    it "can mix and match syntax styles" do
-      {rbx: :cool, :specs => 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-      {'rbx' => :cool, specs: 'fail_sometimes'}.should == {'rbx' => :cool, :specs => 'fail_sometimes'}
-    end
-
-    it "accepts symbol keys using 'string': syntax" do
-      {'test': :test}.should == {test: :test}
-      {'symbol literal': :test}.should == {:'symbol literal' => :test}
-    end
-  end
-end

data/spec/opal/core/language/versions/literal_lambda_1.9.rb

@@ -1,143 +0,0 @@
-require File.join(File.dirname(__FILE__), '../fixtures/literal_lambda')
-
-describe "->(){}" do
-  it "can be specified as a literal" do
-    lambda { ->(){} }.should_not raise_error
-  end
-
-  it "returns a Proc object" do
-    ->(){}.should be_an_instance_of(Proc)
-  end
-
-  it "returns a lambda" do
-    ->(){}.lambda?.should be_true
-  end
-
-  it "can be assigned to a variable" do
-    var = ->(){}
-    var.lambda?.should be_true
-  end
-
-  it "understands a do/end block in place of {}" do
-    lambda do
-      ->() do
-      end
-    end.should_not raise_error(SyntaxError)
-  end
-
-  it "requires an associated block" do
-    lambda { eval "->()" }.should raise_error(SyntaxError)
-    lambda { eval "->" }.should raise_error(SyntaxError)
-  end
-
-  it "can be interpolated into a String" do
-    "1+2=#{->{ 1 + 2}.call}".should == "1+2=3"
-  end
-
-  it "can be be used as a Hash key" do
-    h = new_hash
-    # h[->(one=1){ one + 2}.call] = :value
-    h.key?(3).should be_true
-  end
-
-  it "can be used in method parameter lists" do
-    def glark7654(a=-> { :foo   })
-      a.call
-    end
-    glark7654.should == :foo
-  end
-
-  it "accepts an parameter list between the parenthesis" do
-    lambda { ->(a) {} }.should_not raise_error(SyntaxError)
-    lambda { ->(a,b) {} }.should_not raise_error(SyntaxError)
-  end
-
-  it "accepts an empty parameter list" do
-    lambda { ->() {} }.should_not raise_error(SyntaxError)
-  end
-
-  it "allows the parenthesis to be omitted entirely" do
-    lambda { -> {} }.should_not raise_error(SyntaxError)
-    lambda { ->{} }.should_not raise_error(SyntaxError)
-    lambda do
-      -> do
-      end
-    end.should_not raise_error(SyntaxError)
-    ->{}.should be_an_instance_of(Proc)
-  end
-
-  it "aliases each argument to the corresponding parameter" do
-    ->(a) {a}.call(:sym).should == :sym
-    ->(a,b) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
-  end
-
-  it "accepts parameters with default parameters between the parenthesis" do
-    # lambda { ->(a=1) {} }.should_not raise_error(SyntaxError)
-    # lambda { ->(x=1, b=[]) {} }.should_not raise_error(SyntaxError)
-  end
-
-  it "aliases each argument with a default value to the corresponding parameter" do
-    # ->(a=:cymbal) {a}.call(:sym).should == :sym
-    # ->(a,b=:cymbal) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
-  end
-
-  it "sets arguments to their default value if one wasn't supplied" do
-    # ->(a=:cymbal) {a}.call.should == :cymbal
-    # ->(a,b=:cymbal) {[a, b]}.call(:sym).should == [:sym, :cymbal]
-  end
-
-  it "accepts a parameter prefixed with an asterisk between the parenthesis" do
-    # lambda { ->(*a) {} }.should_not raise_error(SyntaxError)
-    # lambda { ->(x, *a) {} }.should_not raise_error(SyntaxError)
-  end
-
-  it "assigns all remaining arguments to the variable in the parameter list prefixed with an asterisk, if one exists" do
-    # ->(*a) {a}.call(:per, :cus, :si, :on).should == [:per, :cus, :si, :on]
-    # ->(a,*b) {b}.call(:per, :cus, :si, :on).should == [:cus, :si, :on]
-  end
-
-  it "accepts a parameter prefixed with an ampersand between the parenthesis" do
-    # lambda { ->(&a) {} }.should_not raise_error(SyntaxError)
-    # lambda { ->(x, &a) {} }.should_not raise_error(SyntaxError)
-  end
-
-  it "assigns the given block to the parameter prefixed with an ampersand if such a parameter exists" do
-    # l = ->(&a) { a }.call { :foo }
-    l.call.should == :foo
-  end
-
-  it "assigns nil to the parameter prefixed with an ampersand unless a block was supplied" do
-    # ->(&a) { a }.call.should be_nil
-  end
-
-  it "accepts a combination of argument types between the parenthesis" do
-    # lambda { ->(x, y={}, z  = Object.new, *a, &b) {} }.
-      should_not raise_error(SyntaxError)
-  end
-
-  it "sets parameters appropriately when a combination of parameter types is given between the parenthesis" do
-    # l = ->(x, y={}, z  = Object.new, *a, &b) { [x,y,z,a,b]}
-    l.call(1, [], [], 30, 40).should == [1, [], [], [30, 40], nil]
-    block = lambda { :lamb }
-    l.call(1, [], [], 30, 40, &block).last.should be_an_instance_of(Proc)
-    # l2 = ->(x, y={}, *a) { [x, y, a]}
-    l2.call(:x).should == [:x, {}, []]
-  end
-
-  it "uses lambda's 'rigid' argument handling" do
-    ->(a, b){}.parameters.first.first.should == :req
-    ->(a, b){}.parameters.last.first.should == :req
-    lambda { ->(a, b){}.call 1 }.should raise_error(ArgumentError)
-  end
-
-  it "does not call the associated block" do
-    @called = false
-    ->() { @called = true }
-    @called.should be_false
-  end
-
-  it "evaluates constants as normal blocks do" do
-    l = LiteralLambdaMethods.literal_lambda_with_constant
-    l.().should == "some value"
-  end
-end

data/spec/opal/core/language/versions/not_1.9.rb

@@ -1,22 +0,0 @@
-describe "not()" do
-  # not(arg).method and method(not(arg)) raise SyntaxErrors on 1.8. Here we
-  # use #inspect to test that the syntax works on 1.9
-
-  it "can be used as a function" do
-    lambda do
-      not(true).inspect
-    end.should_not raise_error(SyntaxError)
-  end
-
-  it "returns false if the argument is true" do
-    not(true).inspect.should == "false"
-  end
-
-  it "returns true if the argument is false" do
-    not(false).inspect.should == "true"
-  end
-
-  it "returns true if the argument is nil" do
-    not(nil).inspect.should == "true"
-  end
-end

data/spec/opal/core/language/versions/send_1.9.rb

@@ -1,241 +0,0 @@
-# FIXME: Add error case
-#
-require File.expand_path("../../fixtures/send_1.9.rb", __FILE__)
-require 'language/fixtures/send_1.9'
-
-specs = LangSendSpecs
-
-describe "Invoking a method" do
-  describe "with required args after the rest arguments" do
-    it "binds the required arguments first" do
-      specs.fooM0RQ1(1).should == [[], 1]
-      specs.fooM0RQ1(1,2).should == [[1], 2]
-      specs.fooM0RQ1(1,2,3).should == [[1,2], 3]
-
-      specs.fooM1RQ1(1,2).should == [1, [], 2]
-      specs.fooM1RQ1(1,2,3).should == [1, [2], 3]
-      specs.fooM1RQ1(1,2,3,4).should == [1, [2, 3], 4]
-
-      specs.fooM1O1RQ1(1,2).should == [1, 9, [], 2]
-      specs.fooM1O1RQ1(1,2,3).should == [1, 2, [], 3]
-      specs.fooM1O1RQ1(1,2,3,4).should == [1, 2, [3], 4]
-
-      specs.fooM1O1RQ2(1,2,3).should == [1, 9, [], 2, 3]
-      specs.fooM1O1RQ2(1,2,3,4).should == [1, 2, [], 3, 4]
-      specs.fooM1O1RQ2(1,2,3,4,5).should == [1, 2, [3], 4, 5]
-    end
-  end
-
-  describe "with manditory arguments after optional arguments" do
-    it "binds the required arguments first" do
-      specs.fooO1Q1(0,1).should == [0,1]
-      specs.fooO1Q1(2).should == [1,2]
-
-      specs.fooM1O1Q1(2,3,4).should == [2,3,4]
-      specs.fooM1O1Q1(1,3).should == [1,2,3]
-
-      specs.fooM2O1Q1(1,2,4).should == [1,2,3,4]
-
-      specs.fooM2O2Q1(1,2,3,4,5).should == [1,2,3,4,5]
-      specs.fooM2O2Q1(1,2,3,5).should == [1,2,3,4,5]
-      specs.fooM2O2Q1(1,2,5).should == [1,2,3,4,5]
-
-      specs.fooO4Q1(1,2,3,4,5).should == [1,2,3,4,5]
-      specs.fooO4Q1(1,2,3,5).should == [1,2,3,4,5]
-      specs.fooO4Q1(1,2,5).should == [1,2,3,4,5]
-      specs.fooO4Q1(1,5).should == [1,2,3,4,5]
-      specs.fooO4Q1(5).should == [1,2,3,4,5]
-
-      specs.fooO4Q2(1,2,3,4,5,6).should == [1,2,3,4,5,6]
-      specs.fooO4Q2(1,2,3,5,6).should == [1,2,3,4,5,6]
-      specs.fooO4Q2(1,2,5,6).should == [1,2,3,4,5,6]
-      specs.fooO4Q2(1,5,6).should == [1,2,3,4,5,6]
-      specs.fooO4Q2(5,6).should == [1,2,3,4,5,6]
-    end
-  end
-
-  it "with .() invokes #call" do
-    q = proc { |z| z }
-    q.(1).should == 1
-
-    obj = mock("paren call")
-    obj.should_receive(:call).and_return(:called)
-    obj.().should == :called
-  end
-
-  it "allows a vestigial trailing ',' in the arguments" do
-    # specs.fooM1(1,).should == [1]
-  end
-
-  it "with splat operator attempts to coerce it to an Array if the object respond_to?(:to_a)" do
-    ary = [2,3,4]
-    obj = mock("to_a")
-    obj.should_receive(:to_a).and_return(ary).twice
-    specs.fooM0R(*obj).should == ary
-    specs.fooM1R(1,*obj).should == [1, ary]
-  end
-
-  it "with splat operator * and non-Array value uses value unchanged if it does not respond_to?(:to_ary)" do
-    obj = Object.new
-    obj.should_not respond_to(:to_a)
-
-    specs.fooM0R(*obj).should == [obj]
-    specs.fooM1R(1,*obj).should == [1, [obj]]
-  end
-
-  it "accepts additional arguments after splat expansion" do
-    a = [1,2]
-    specs.fooM4(*a,3,4).should == [1,2,3,4]
-    specs.fooM4(0,*a,3).should == [0,1,2,3]
-  end
-
-  it "accepts final explicit literal Hash arguments after the splat" do
-    a = [1, 2]
-    specs.fooM0RQ1(*a, { :a => 1 }).should == [[1, 2], { :a => 1 }]
-  end
-
-  it "accepts final implicit literal Hash arguments after the splat" do
-    a = [1, 2]
-    specs.fooM0RQ1(*a, :a => 1).should == [[1, 2], { :a => 1 }]
-  end
-
-  it "accepts final Hash arguments after the splat" do
-    a = [1, 2]
-    b = { :a => 1 }
-    specs.fooM0RQ1(*a, b).should == [[1, 2], { :a => 1 }]
-  end
-
-  it "accepts mandatory and explicit literal Hash arguments after the splat" do
-    a = [1, 2]
-    specs.fooM0RQ2(*a, 3, { :a => 1 }).should == [[1, 2], 3, { :a => 1 }]
-  end
-
-  it "accepts mandatory and implicit literal Hash arguments after the splat" do
-    a = [1, 2]
-    specs.fooM0RQ2(*a, 3, :a => 1).should == [[1, 2], 3, { :a => 1 }]
-  end
-
-  it "accepts mandatory and Hash arguments after the splat" do
-    a = [1, 2]
-    b = { :a => 1 }
-    specs.fooM0RQ2(*a, 3, b).should == [[1, 2], 3, { :a => 1 }]
-  end
-
-  it "converts a final splatted explicit Hash to an Array" do
-    a = [1, 2]
-    specs.fooR(*a, 3, *{ :a => 1 }).should == [1, 2, 3, [:a, 1]]
-  end
-
-  it "calls #to_a to convert a final splatted Hash object to an Array" do
-    a = [1, 2]
-    b = { :a => 1 }
-    b.should_receive(:to_a).and_return([:a, 1])
-
-    specs.fooR(*a, 3, *b).should == [1, 2, 3, :a, 1]
-  end
-
-  it "accepts multiple splat expansions in the same argument list" do
-    a = [1,2,3]
-    b = 7
-    c = mock("pseudo-array")
-    c.should_receive(:to_a).and_return([0,0])
-
-    d = [4,5]
-    specs.rest_len(*a,*d,6,*b).should == 7
-    specs.rest_len(*a,*a,*a).should == 9
-    specs.rest_len(0,*a,4,*5,6,7,*c,-1).should == 11
-  end
-
-  it "expands an array to arguments grouped in parentheses" do
-    specs.destructure2([40,2]).should == 42
-  end
-
-  it "expands an array to arguments grouped in parentheses and ignores any rest arguments in the array" do
-    specs.destructure2([40,2,84]).should == 42
-  end
-
-  it "expands an array to arguments grouped in parentheses and sets not specified arguments to nil" do
-    specs.destructure2b([42]).should == [42, nil]
-  end
-
-  it "expands an array to arguments grouped in parentheses which in turn takes rest arguments" do
-    specs.destructure4r([1, 2, 3]).should == [1, 2, [], 3, nil]
-    specs.destructure4r([1, 2, 3, 4]).should == [1, 2, [], 3, 4]
-    specs.destructure4r([1, 2, 3, 4, 5]).should == [1, 2, [3], 4, 5]
-  end
-
-  describe "new-style hash arguments" do
-    describe "as the only parameter" do
-      it "passes without curly braces" do
-        specs.fooM1(rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "passes without curly braces or parens" do
-        (specs.fooM1 rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "handles a hanging comma without curly braces" do
-        # specs.fooM1(abc: 123,).should == [{:abc => 123}]
-        # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
-          # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-    end
-
-    describe "as the last parameter" do
-      it "passes without curly braces" do
-        specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "passes without curly braces or parens" do
-        (specs.fooM3 'abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "handles a hanging comma without curly braces" do
-        # specs.fooM3('abc', 123, abc: 123,).should == ['abc', 123, {:abc => 123}]
-        # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
-          # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-    end
-  end
-
-  describe "mixed new- and old-style hash arguments" do
-    describe "as the only parameter" do
-      it "passes without curly braces" do
-        specs.fooM1(rbx: 'cool', :specs => :fail_sometimes, non_sym: 1234).should ==
-          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "passes without curly braces or parens" do
-        (specs.fooM1 :rbx => 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "handles a hanging comma without curly braces" do
-        # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
-          # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-    end
-
-    describe "as the last parameter" do
-      it "passes without curly braces" do
-        specs.fooM3('abc', 123, rbx: 'cool', :specs => :fail_sometimes, non_sym: 1234).should ==
-          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "passes without curly braces or parens" do
-        (specs.fooM3 'abc', 123, :rbx => 'cool', specs: :fail_sometimes, non_sym: 1234).should ==
-          ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-
-      it "handles a hanging comma without curly braces" do
-        # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
-          # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
-      end
-    end
-  end
-
-end