diff --git a/lib/puppet/pops/utils.rb b/lib/puppet/pops/utils.rb
index b14b5554f..fec084d38 100644
--- a/lib/puppet/pops/utils.rb
+++ b/lib/puppet/pops/utils.rb
@@ -1,104 +1,107 @@
 # Provides utility methods
 module Puppet::Pops::Utils
   # Can the given o be converted to numeric? (or is numeric already)
   # Accepts a leading '::'
   # Returns a boolean if the value is numeric
   # If testing if value can be converted it is more efficient to call {#to_n} or {#to_n_with_radix} directly
   # and check if value is nil.
   def self.is_numeric?(o)
     case o
     when Numeric, Integer, Fixnum, Float
       !!o
     else
       !!Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o.to_s))
     end
   end
 
   # To Numeric with radix, or nil if not a number.
   # If the value is already Numeric it is returned verbatim with a radix of 10.
   # @param o [String, Number] a string containing a number in octal, hex, integer (decimal) or floating point form
   # @return [Array<Number, Integer>, nil] array with converted number and radix, or nil if not possible to convert
   # @api public
   #
   def self.to_n_with_radix o
     begin
       case o
       when String
         match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
         if !match
           nil
         elsif match[3].to_s.length > 0
           # Use default radix (default is decimal == 10) for floats
           [Float(match[0]), 10]
         else
           # Set radix (default is decimal == 10)
           radix = 10
           if match[1].to_s.length > 0
             radix = 16
-          elsif match[2].to_s.length > 1 && match[2][0] == '0'
+          elsif match[2].to_s.length > 1 && match[2][0,1] == '0'
             radix = 8
           end
-          [Integer(match[0], radix), radix]
+          # Ruby 1.8.7 does not have a second argument to Kernel method that creates an
+          # integer from a string, it relies on the prefix 0x, 0X, 0 (and unsupported in puppet binary 'b')
+          # We have the correct string here, match[0] is safe to parse without passing on radix
+          [Integer(match[0]), radix]
         end
       when Numeric, Fixnum, Integer, Float
         # Impossible to calculate radix, assume decimal
         [o, 10]
       else
         nil
       end
     rescue ArgumentError
       nil
     end
   end
 
   # To Numeric (or already numeric)
   # Returns nil if value is not numeric, else an Integer or Float
   # A leading '::' is accepted (and ignored)
   #
   def self.to_n o
     begin
       case o
       when String
         match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
         if !match
           nil
         elsif match[3].to_s.length > 0
           Float(match[0])
         else
           Integer(match[0])
         end
       when Numeric, Fixnum, Integer, Float
         o
       else
         nil
       end
     rescue ArgumentError
       nil
     end
   end
 
   # is the name absolute (i.e. starts with ::)
   def self.is_absolute? name
     name.start_with? "::"
   end
 
   def self.name_to_segments name
     name.split("::")
   end
 
   def self.relativize_name name
     is_absolute?(name) ? name[2..-1] : name
   end
 
   # Finds an adapter for o or for one of its containers, or nil, if none of the containers
   # was adapted with the given adapter.
   # This method can only be used with objects that respond to `:eContainer`.
   # with true, and Adaptable#adapters.
   #
   def self.find_adapter(o, adapter)
     return nil if o.nil? || (o.is_a?(Array) && o.empty?)
     a = adapter.get(o)
     return a if a
     return find_adapter(o.eContainer, adapter)
   end
 end
diff --git a/spec/unit/pops/parser/lexer2_spec.rb b/spec/unit/pops/parser/lexer2_spec.rb
index 2fb94826a..b9bdd6eb4 100644
--- a/spec/unit/pops/parser/lexer2_spec.rb
+++ b/spec/unit/pops/parser/lexer2_spec.rb
@@ -1,372 +1,382 @@
 require 'spec_helper'
 require 'matchers/match_tokens2'
 require 'puppet/pops'
 require 'puppet/pops/parser/lexer2'
 
 module EgrammarLexer2Spec
   def tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
     tokens = lexer.fullscan[0..-2]
   end
 
   def epp_tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
     tokens = lexer.fullscan_epp[0..-2]
   end
 end
 
 describe 'Lexer2' do
   include EgrammarLexer2Spec
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :OTHER => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :DELETES => '-=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
     :PIPE => '|',
   }.each do |name, string|
     it "should lex a token named #{name.to_s}" do
       tokens_scanned_from(string).should match_tokens2(name)
     end
   end
 
   {
     "case"     => :CASE,
     "class"    => :CLASS,
     "default"  => :DEFAULT,
     "define"   => :DEFINE,
 #    "import" => :IMPORT, # done as a function in egrammar
     "if"       => :IF,
     "elsif"    => :ELSIF,
     "else"     => :ELSE,
     "inherits" => :INHERITS,
     "node"     => :NODE,
     "and"      => :AND,
     "or"       => :OR,
     "undef"    => :UNDEF,
     "false"    => :BOOLEAN,
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       tokens_scanned_from(string).should match_tokens2(name)
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:CLASSREF, string])
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'a', 'a::b', '::a', '::a::b',].each do |string|
     it "should lex a NAME on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NAME, string])
     end
   end
 
   { 'false'=>false, 'true'=>true}.each do |string, value|
     it "should lex a BOOLEAN on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:BOOLEAN, value])
     end
   end
 
   [ '0', '1', '2982383139'].each do |string|
     it "should lex a decimal integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
+  { ' 1' => '1', '1 ' => '1', ' 1 ' => '1'}.each do |string, value|
+    it "should lex a NUMBER with surrounding space '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, value])
+    end
+  end
+
   [ '0.0', '0.1', '0.2982383139', '29823.235', '10e23', '10e-23', '1.234e23'].each do |string|
     it "should lex a decimal floating point NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   [ '00', '01', '0123', '0777'].each do |string|
     it "should lex an octal integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   [ '0x0', '0x1', '0xa', '0xA', '0xabcdef', '0xABCDEF'].each do |string|
     it "should lex an hex integer NUMBER on the form '#{string}'" do
       tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
     end
   end
 
   { "''"      => '',
     "'a'"     => 'a',
     "'a\\'b'" =>"a'b",
     "'a\\r\\n\\t\\s\\$\\\"\\\\b'" => "a\\r\\n\\t\\s\\$\\\"\\\\b"
   }.each do |source, expected|
     it "should lex a single quoted STRING on the form #{source}" do
       tokens_scanned_from(source).should match_tokens2([:STRING, expected])
     end
   end
 
   { '""'      => '',
     '"a"'     => 'a',
     '"a\'b"'  => "a'b",
   }.each do |source, expected|
     it "should lex a double quoted STRING on the form #{source}" do
       tokens_scanned_from(source).should match_tokens2([:STRING, expected])
     end
   end
 
   { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
 
     '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
 
     '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
                    [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
 
     '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
                    [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
                    [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       tokens_scanned_from(source).should match_tokens2(*expected)
     end
   end
 
   it "differentiates between foo[x] and foo [x] (whitespace)" do
     tokens_scanned_from("$a[1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("$a [1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("a[1]").should match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("a [1]").should match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
     tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips whitepsace" do
     tokens_scanned_from(" if if if ").should match_tokens2(:IF, :IF, :IF)
     tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips single line comments" do
     tokens_scanned_from("if # comment\nif").should match_tokens2(:IF, :IF)
   end
 
   ["if /* comment */\nif",
     "if /* comment\n */\nif",
     "if /*\n comment\n */\nif",
     ].each do |source|
     it "skips multi line comments" do
       tokens_scanned_from(source).should match_tokens2(:IF, :IF)
     end
   end
 
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
     "("  => [:LPAREN, "( /./"],
     "["  => [:LBRACK, "[ /./"],
     "{"  => [:LBRACE, "{ /./"],
     "+"  => [:PLUS, "+ /./"],
     "-"  => [:MINUS, "- /./"],
     "*"  => [:TIMES, "* /./"],
     ";"  => [:SEMIC, "; /./"],
   }.each do |token, entry|
     it "should lex regexp after '#{token}'" do
       tokens_scanned_from(entry[1]).should match_tokens2(entry[0], :REGEX)
     end
   end
 
+  it "should lex a simple expression" do
+    tokens_scanned_from('1 + 1').should match_tokens2([:NUMBER, '1'], :PLUS, [:NUMBER, '1'])
+  end
+
   { "1"     => ["1 /./",       [:NUMBER, :DIV, :DOT, :DIV]],
     "'a'"   => ["'a' /./",     [:STRING, :DIV, :DOT, :DIV]],
     "true"  => ["true /./",    [:BOOLEAN, :DIV, :DOT, :DIV]],
     "false" => ["false /./",   [:BOOLEAN, :DIV, :DOT, :DIV]],
     "/./"   => ["/./ /./",     [:REGEX, :DIV, :DOT, :DIV]],
     "a"     => ["a /./",       [:NAME, :DIV, :DOT, :DIV]],
     "A"     => ["A /./",       [:CLASSREF, :DIV, :DOT, :DIV]],
     ")"     => [") /./",       [:RPAREN, :DIV, :DOT, :DIV]],
     "]"     => ["] /./",       [:RBRACK, :DIV, :DOT, :DIV]],
     "|>"     => ["|> /./",     [:RCOLLECT, :DIV, :DOT, :DIV]],
     "|>>"    => ["|>> /./",    [:RRCOLLECT, :DIV, :DOT, :DIV]],
     '"a$a"'  => ['"a$a" /./',  [:DQPRE, :VARIABLE, :DQPOST, :DIV, :DOT, :DIV]],
   }.each do |token, entry|
     it "should not lex regexp after '#{token}'" do
       tokens_scanned_from(entry[ 0 ]).should match_tokens2(*entry[ 1 ])
     end
   end
 
   it 'should lex assignment' do
     tokens_scanned_from("$a = 10").should match_tokens2([:VARIABLE, "a"], :EQUALS, [:NUMBER, '10'])
   end
 
 # TODO: Tricky, and heredoc not supported yet
 #  it "should not lex regexp after heredoc" do
 #    tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
 #  end
 
   it "should lex regexp at beginning of input" do
     tokens_scanned_from(" /./").should match_tokens2(:REGEX)
   end
 
   it "should lex regexp right of div" do
     tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
   context 'when lexer lexes heredoc' do
     it 'lexes tag, syntax and escapes, margin and right trim' do
       code = <<-CODE
       @(END:syntax/t)
       Tex\\tt\\n
       |- END
       CODE
       tokens_scanned_from(code).should match_tokens2([:HEREDOC, 'syntax'], [:STRING, "Tex\tt\\n"])
     end
 
     it 'lexes "tag", syntax and escapes, margin, right trim and interpolation' do
       code = <<-CODE
       @("END":syntax/t)
       Tex\\tt\\n$var After
       |- END
       CODE
       tokens_scanned_from(code).should match_tokens2(
         [:HEREDOC, 'syntax'],
         [:DQPRE, "Tex\tt\\n"],
         [:VARIABLE, "var"],
         [:DQPOST, " After"]
         )
     end
   end
 
   it 'should support unicode characters' do
     code = <<-CODE
     "x\\u2713y"
     CODE
     if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
       # Ruby 1.8.7 reports the multibyte char as several octal characters
       tokens_scanned_from(code).should match_tokens2([:STRING, "x\342\234\223y"])
     else
       # >= Ruby 1.9.3 reports \u
       tokens_scanned_from(code).should match_tokens2([:STRING, "x\u2713y"])
     end
   end
 
   context 'when lexing epp' do
     it 'epp can contain just text' do
       code = <<-CODE
       This is just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2([:RENDER_STRING, "      This is just text\n"])
     end
 
     it 'epp can contain text with interpolated rendered expressions' do
       code = <<-CODE
       This is <%= $x %> just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
       [:RENDER_STRING, "      This is "],
       [:RENDER_EXPR, nil],
       [:VARIABLE, "x"],
       [:RENDER_STRING, " just text\n"]
       )
     end
 
     it 'epp can contain text with expressions that are not rendered' do
       code = <<-CODE
       This is <% $x=10 %> just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, " just text\n"]
       )
     end
 
     it 'epp can skip leading space in tail text' do
       code = <<-CODE
       This is <% $x=10 -%>
       just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "just text\n"]
       )
     end
 
     it 'epp can skip comments' do
       code = <<-CODE
       This is <% $x=10 -%>
       <%# This is an epp comment -%>
       just text
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "just text\n"]
       )
     end
 
     it 'epp can escape epp tags' do
       code = <<-CODE
       This is <% $x=10 -%>
       <%% this is escaped epp %%>
       CODE
       epp_tokens_scanned_from(code).should match_tokens2(
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
       [:RENDER_STRING, "<% this is escaped epp %>\n"]
       )
     end
   end
 end