literal_parser 1.0.0

data/README.markdown

@@ -0,0 +1,53 @@
+README
+======
+
+
+Summary
+-------
+Parse Strings containing ruby literals and return a proper ruby object.
+
+
+Features
+--------
+
+* Recognizes about all Ruby literals: nil, true, false, Symbols, Integers, Floats, Hashes,
+  Arrays
+* Additionally parses Constants, Dates and Times
+* Very easy to use
+
+
+Installation
+------------
+`gem install literal_parser`
+
+
+Usage
+-----
+
+A couple of examples:
+
+    LiteralParser.parse("nil") # => nil
+    LiteralParser.parse(":foo") # => :foo
+    LiteralParser.parse("123") # => 123
+    LiteralParser.parse("1.5") # => 1.5
+    LiteralParser.parse("1.5", use_big_decimal: true) # => #<BigDecimal:…,'0.15E1',18(18)>
+    LiteralParser.parse("[1, 2, 3]") # => [1, 2, 3]
+    LiteralParser.parse("{:a => 1, :b => 2}") # => {:a => 1, :b => 2}
+
+
+
+
+Links
+-----
+
+* [Online API Documentation](http://rdoc.info/github/apeiros/literal_parser/)
+* [Public Repository](https://github.com/apeiros/literal_parser)
+* [Bug Reporting](https://github.com/apeiros/literal_parser/issues)
+* [RubyGems Site](https://rubygems.org/gems/literal_parser)
+
+
+License
+-------
+
+You can use this code under the {file:LICENSE.txt BSD-2-Clause License}, free of charge.
+If you need a different license, please ask the author.

data/Rakefile

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.expand_path('../rake/lib', __FILE__))
+Dir.glob(File.expand_path('../rake/tasks/**/*.{rake,task,rb}', __FILE__)) do |task_file|
+  begin
+    import task_file
+  rescue LoadError => e
+    warn "Failed to load task file #{task_file}"
+    warn "  #{e.class} #{e.message}"
+    warn "  #{e.backtrace.first}"
+  end
+end

data/lib/literal_parser.rb

@@ -0,0 +1,323 @@
+# encoding: utf-8
+
+
+
+require 'literal_parser/version'
+require 'strscan'
+require 'bigdecimal'
+require 'date'
+
+
+
+# LiteralParser
+#
+# Parse Strings containing ruby literals.
+#
+# @example
+#   LiteralParser.parse("nil") # => nil
+#   LiteralParser.parse(":foo") # => :foo
+#   LiteralParser.parse("123") # => 123
+#   LiteralParser.parse("1.5") # => 1.5
+#   LiteralParser.parse("1.5", use_big_decimal: true) # => #<BigDecimal:…,'0.15E1',18(18)>
+#   LiteralParser.parse("[1, 2, 3]") # => [1, 2, 3]
+#   LiteralParser.parse("{:a => 1, :b => 2}") # => {:a => 1, :b => 2}
+#
+# LiteralParser recognizes constants and the following literals:
+#
+#     nil                   # nil
+#     true                  # true
+#     false                 # false
+#     -123                  # Fixnum/Bignum (decimal)
+#     0b1011                # Fixnum/Bignum (binary)
+#     0755                  # Fixnum/Bignum (octal)
+#     0xff                  # Fixnum/Bignum (hexadecimal)
+#     120.30                # Float (optional: BigDecimal)
+#     1e0                   # Float
+#     "foo"                 # String, no interpolation, but \t etc. work
+#     'foo'                 # String, only \\ and \' are escaped
+#     /foo/                 # Regexp
+#     :foo                  # Symbol
+#     :"foo"                # Symbol
+#     2012-05-20            # Date
+#     2012-05-20T18:29:52   # DateTime
+#     [Any, Literals, Here] # Array
+#     {Any => Literals}     # Hash
+#
+#
+# @note Limitations
+#
+#   * LiteralParser does not support ruby 1.9's `{key: value}` syntax.
+#   * LiteralParser does not currently support all of rubys escape sequences in strings
+#     and symbols, e.g. "\C-…" type sequences don't work.
+#   * Trailing commas in Array and Hash are not supported.
+#
+# @note BigDecimals
+#
+#   You can instruct LiteralParser to parse "12.5" as a bigdecimal and use "12.5e" to have
+#   it parsed as float (short for "12.5e0", equivalent to "1.25e1")
+#
+# @note Date & Time
+#
+#   LiteralParser supports a subset of ISO-8601 for Date and Time which are not actual
+#   valid ruby literals. The form YYYY-MM-DD (e.g. 2012-05-20) is translated to a Date
+#   object, and YYYY-MM-DD"T"HH:MM:SS (e.g. 2012-05-20T18:29:52) is translated to a
+#   Time object.
+#
+class LiteralParser
+
+  # Raised when a String could not be parsed
+  class SyntaxError < StandardError; end
+
+  # @private
+  # All the expressions used to parse the literals
+  module Expressions
+
+    RArrayBegin     = /\[/                                     # Match begin of an array
+
+    RArrayVoid      = /\s*/                                    # Match whitespace between elements in an array
+
+    RArraySeparator = /#{RArrayVoid},#{RArrayVoid}/            # Match the separator of array elements
+
+    RArrayEnd       = /\]/                                     # Match end of an array
+
+    RHashBegin      = /\{/                                     # Match begin of a hash
+
+    RHashVoid       = /\s*/                                    # Match whitespace between elements in a hash
+
+    RHashSeparator  = /#{RHashVoid},#{RHashVoid}/              # Match the separator of hash key/value pairs
+
+    RHashArrow      = /#{RHashVoid}=>#{RHashVoid}/             # Match the separator between a key and a value in a hash
+
+    RHashEnd        = /\}/                                     # Match end of a hash
+
+    RConstant       = /[A-Z]\w*(?:::[A-Z]\w*)*/                # Match constant names (with nesting)
+
+    RNil            = /nil/                                    # Match nil
+
+    RFalse          = /false/                                  # Match false
+
+    RTrue           = /true/                                   # Match true
+
+    RInteger        = /[+-]?\d[\d_]*/                          # Match an Integer in decimal notation
+
+    RBinaryInteger  = /[+-]?0b[01][01_]*/                      # Match an Integer in binary notation
+
+    RHexInteger     = /[+-]?0x[A-Fa-f\d][A-Fa-f\d_]*/          # Match an Integer in hexadecimal notation
+
+    ROctalInteger   = /[+-]?0[0-7][0-7'_,]*/                   # Match an Integer in octal notation
+
+    RBigDecimal     = /#{RInteger}\.\d+/                       # Match a decimal number (Float or BigDecimal)
+
+    RFloat          = /#{RBigDecimal}(?:f|e#{RInteger})/       # Match a decimal number in scientific notation
+
+    RSString        = /'(?:[^\\']+|\\.)*'/                     # Match a single quoted string
+
+    RDString        = /"(?:[^\\"]+|\\.)*"/                     # Match a double quoted string
+
+    RRegexp         = %r{/((?:[^\\/]+|\\.)*)/([imxnNeEsSuU]*)} # Match a regular expression
+
+    RSymbol         = /:\w+|:#{RSString}|:#{RDString}/         # Match a symbol
+
+    RDate           = /(\d{4})-(\d{2})-(\d{2})/                # Match a date
+
+    RTimeZone       = /(Z|[A-Z]{3,4}|[+-]\d{4})/               # Match a timezone
+
+    RTime           = /(\d{2}):(\d{2}):(\d{2})(?:RTimeZone)?/  # Match a time (without date)
+
+    RDateTime       = /#{RDate}T#{RTime}/                      # Match a datetime
+
+    # Map escape sequences in double quoted strings
+    DStringEscapes  = {
+      '\\\\' => "\\",
+      "\\'"  => "'",
+      '\\"'  => '"',
+      '\t'   => "\t",
+      '\f'   => "\f",
+      '\r'   => "\r",
+      '\n'   => "\n",
+    }
+    256.times do |i|
+      DStringEscapes["\\%o" % i]    = i.chr
+      DStringEscapes["\\%03o" % i]  = i.chr
+      DStringEscapes["\\x%02x" % i] = i.chr
+      DStringEscapes["\\x%02X" % i] = i.chr
+    end
+  end
+  include Expressions
+
+  # Parse a String, returning the object which it contains.
+  #
+  # @example
+  #     LiteralParser.parse(":foo") # => :foo
+  #
+  # @param [String] string
+  #   The string which should be parsed
+  # @param [nil, Hash] options
+  #   An options-hash
+  #
+  # @option options [Boolean] :use_big_decimal
+  #   Whether to use BigDecimal instead of Float for objects like "1.23".
+  #   Defaults to false.
+  # @option options [Boolean] :constant_base
+  #   Determines from what constant other constants are searched.
+  #   Defaults to Object (nil is treated as Object too, Object is the toplevel-namespace).
+  #
+  # @return [Object] The object in the string.
+  #
+  # @raise [LiteralParser::SyntaxError]
+  #   If the String does not contain exactly one valid literal, a SyntaxError is raised.
+  def self.parse(string, options=nil)
+    parser  = new(string, options)
+    value   = parser.scan_value
+    raise SyntaxError, "Unexpected superfluous data: #{parser.rest.inspect}" unless parser.end_of_string?
+
+    value
+  end
+
+  # @return [Module, nil]
+  #   Where to lookup constants. Nil is toplevel (equivalent to Object).
+  attr_reader :constant_base
+
+  # @return [Boolean]
+  #   True if "1.25" should be parsed into a big-decimal, false if it should be parsed as
+  #   Float.
+  attr_reader :use_big_decimal
+
+  #
+  # Parse a String, returning the object which it contains.
+  #
+  # @param [String] string
+  #   The string which should be parsed
+  # @param [nil, Hash] options
+  #   An options-hash
+  #
+  # @option options [Boolean] :use_big_decimal
+  #   Whether to use BigDecimal instead of Float for objects like "1.23".
+  #   Defaults to false.
+  # @option options [Boolean] :constant_base
+  #   Determines from what constant other constants are searched.
+  #   Defaults to Object (nil is treated as Object too, Object is the toplevel-namespace).
+  def initialize(string, options=nil)
+    options = options ? options.dup : {}
+    @constant_base    = options[:constant_base] # nil means toplevel
+    @use_big_decimal  = options.delete(:use_big_decimal) { false }
+    @string           = string
+    @scanner          = StringScanner.new(string)
+  end
+
+  # @return [Integer] The position of the scanner in the string
+  def position
+    @scanner.pos
+  end
+
+  # Moves the scanners position to the given character-index.
+  #
+  # @param [Integer] value
+  #   The new position of the scanner
+  def position=(value)
+    @scanner.pos = value
+  end
+
+  # @return [Boolean] Whether the scanner reached the end of the string.
+  def end_of_string?
+    @scanner.eos?
+  end
+
+  # @return [String] The currently unprocessed rest of the string.
+  def rest
+    @scanner.rest
+  end
+
+  # Scans the string for a single value and advances the parsers position
+  #
+  # @return [Object] the scanned value
+  #
+  # @raise [LiteralParser::SyntaxError]
+  #   When no valid ruby object could be scanned at the given position, a
+  #   LiteralParser::SyntaxError is raised.
+  def scan_value
+    case
+      when @scanner.scan(RArrayBegin)    then
+        value = []
+        @scanner.scan(RArrayVoid)
+        if @scanner.scan(RArrayEnd)
+          value
+        else
+          value << scan_value
+          while @scanner.scan(RArraySeparator)
+            value << scan_value
+          end
+          raise SyntaxError, "Expected ]" unless @scanner.scan(RArrayVoid) && @scanner.scan(RArrayEnd)
+
+          value
+        end
+      when @scanner.scan(RHashBegin)    then
+        value = {}
+        @scanner.scan(RHashVoid)
+        if @scanner.scan(RHashEnd)
+          value
+        else
+          key = scan_value
+          raise SyntaxError, "Expected =>" unless @scanner.scan(RHashArrow)
+          val = scan_value
+          value[key] = val
+          while @scanner.scan(RHashSeparator)
+            key = scan_value
+            raise SyntaxError, "Expected =>" unless @scanner.scan(RHashArrow)
+            val = scan_value
+            value[key] = val
+          end
+          raise SyntaxError, "Expected }" unless @scanner.scan(RHashVoid) && @scanner.scan(RHashEnd)
+
+          value
+        end
+      when @scanner.scan(RConstant)      then eval("#{@constant_base}::#{@scanner[0]}") # yes, I know it's evil, but it's sane due to the regex, also it's less annoying than deep_const_get
+      when @scanner.scan(RNil)           then nil
+      when @scanner.scan(RTrue)          then true
+      when @scanner.scan(RFalse)         then false
+      when @scanner.scan(RDateTime)      then
+        Time.mktime(@scanner[1], @scanner[2], @scanner[3], @scanner[4], @scanner[5], @scanner[6])
+      when @scanner.scan(RDate)          then
+        date = @scanner[1].to_i, @scanner[2].to_i, @scanner[3].to_i
+        Date.civil(*date)
+      when @scanner.scan(RTime)          then
+        now = Time.now
+        Time.mktime(now.year, now.month, now.day, @scanner[1].to_i, @scanner[2].to_i, @scanner[3].to_i)
+      when @scanner.scan(RFloat)         then Float(@scanner.matched.delete('^0-9.e-'))
+      when @scanner.scan(RBigDecimal)    then
+        data = @scanner.matched.delete('^0-9.-')
+        @use_big_decimal ? BigDecimal(data) : Float(data)
+      when @scanner.scan(ROctalInteger)  then Integer(@scanner.matched.delete('^0-9-'))
+      when @scanner.scan(RHexInteger)    then Integer(@scanner.matched.delete('^xX0-9A-Fa-f-'))
+      when @scanner.scan(RBinaryInteger) then Integer(@scanner.matched.delete('^bB01-'))
+      when @scanner.scan(RInteger)       then @scanner.matched.delete('^0-9-').to_i
+      when @scanner.scan(RRegexp)        then
+        source = @scanner[1]
+        flags  = 0
+        lang   = nil
+        if @scanner[2] then
+          flags |= Regexp::IGNORECASE if @scanner[2].include?('i')
+          flags |= Regexp::EXTENDED if @scanner[2].include?('m')
+          flags |= Regexp::MULTILINE if @scanner[2].include?('x')
+          lang   = @scanner[2].delete('^nNeEsSuU')[-1,1]
+        end
+        Regexp.new(source, flags, lang)
+      when @scanner.scan(RSymbol)        then
+        case @scanner.matched[1,1]
+          when '"'
+            @scanner.matched[2..-2].gsub(/\\(?:[0-3]?\d\d?|x[A-Fa-f\d]{2}|.)/) { |m|
+              DStringEscapes[m]
+            }.to_sym
+          when "'"
+            @scanner.matched[2..-2].gsub(/\\'/, "'").gsub(/\\\\/, "\\").to_sym
+          else
+            @scanner.matched[1..-1].to_sym
+        end
+      when @scanner.scan(RSString)       then
+        @scanner.matched[1..-2].gsub(/\\'/, "'").gsub(/\\\\/, "\\")
+      when @scanner.scan(RDString)       then
+        @scanner.matched[1..-2].gsub(/\\(?:[0-3]?\d\d?|x[A-Fa-f\d]{2}|.)/) { |m| DStringEscapes[m] }
+      else raise SyntaxError, "Unrecognized pattern: #{@scanner.rest.inspect}"
+    end
+  end
+end

data/lib/literal_parser/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+begin
+  require 'rubygems/version' # newer rubygems use this
+rescue LoadError
+  require 'gem/version' # older rubygems use this
+end
+
+class LiteralParser
+
+  # The version of the LiteralParser library
+  Version = Gem::Version.new("1.0.0")
+end

data/literal_parser.gemspec

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name                      = "literal_parser"
+  s.version                   = "1.0.0"
+  s.authors                   = "Stefan Rusterholz"
+  s.email                     = "stefan.rusterholz@gmail.com"
+  s.homepage                  = "https://github.com/apeiros/literal_parser"
+
+  s.description               = <<-DESCRIPTION.gsub(/^    /, '').chomp
+    Parse Strings containing ruby literals and return a proper ruby object.
+  DESCRIPTION
+  s.summary                   = <<-SUMMARY.gsub(/^    /, '').chomp
+    Parse Strings containing ruby literals and return a proper ruby object.
+  SUMMARY
+
+  s.files                     =
+    Dir['bin/**/*'] +
+    Dir['lib/**/*'] +
+    Dir['rake/**/*'] +
+    Dir['test/**/*'] +
+    Dir['*.gemspec'] +
+    %w[
+      Rakefile
+      README.markdown
+    ]
+
+  if File.directory?('bin') then
+    executables = Dir.chdir('bin') { Dir.glob('**/*').select { |f| File.executable?(f) } }
+    s.executables = executables unless executables.empty?
+  end
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1")
+  s.rubygems_version          = "1.3.1"
+  s.specification_version     = 3
+end

data/test/lib/helper.rb

@@ -0,0 +1,31 @@
+require 'stringio'
+
+module TestSuite
+  attr_accessor :name
+end
+
+module Kernel
+  def suite(name, &block)
+    klass = Class.new(Test::Unit::TestCase, &block)
+    klass.extend TestSuite
+    klass.name = "Suite #{name}"
+
+    klass
+  end
+  module_function :suite
+end
+
+class Test::Unit::TestCase
+  def self.test(desc, &impl)
+    define_method("test #{desc}", &impl)
+  end
+
+  def capture_stdout
+    captured  = StringIO.new
+    $stdout   = captured
+    yield
+    captured.string
+  ensure
+    $stdout = STDOUT
+  end
+end

data/test/runner.rb

@@ -0,0 +1,20 @@
+# run with `ruby test/runner.rb`
+# if you only want to run a single test-file: `ruby test/runner.rb testfile.rb`
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../../test/lib', __FILE__)
+TEST_DIR    = File.expand_path('../../test', __FILE__)
+
+require 'test/unit'
+require 'helper'
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+units = ARGV.empty? ? Dir["#{TEST_DIR}/unit/**/*.rb"] : ARGV
+
+units.each do |unit|
+  load unit
+end

data/test/unit/lib/literal_parser.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'literal_parser'
+
+suite "LiteralParser" do
+  test "Parse nil" do
+    assert_equal nil, LiteralParser.parse('nil')
+  end
+  test "Parse true" do
+    assert_equal true, LiteralParser.parse('true')
+  end
+  test "Parse false" do
+    assert_equal false, LiteralParser.parse('false')
+  end
+  test "Parse Integers" do
+    assert_equal 123, LiteralParser.parse('123')
+    assert_equal -123, LiteralParser.parse('-123')
+    assert_equal 1_234_567, LiteralParser.parse('1_234_567')
+    assert_equal 0b1011, LiteralParser.parse('0b1011')
+    assert_equal 0xe3, LiteralParser.parse('0xe3')
+  end
+  test "Parse Floats" do
+    assert_equal 12.37, LiteralParser.parse('12.37')
+    assert_equal -31.59, LiteralParser.parse('-31.59')
+    assert_equal 1.2e5, LiteralParser.parse('1.2e5')
+    assert_equal 1.2e-5, LiteralParser.parse('1.2e-5')
+    assert_equal -1.2e5, LiteralParser.parse('-1.2e5')
+    assert_equal -1.2e-5, LiteralParser.parse('-1.2e-5')
+  end
+  test "Parse BigDecimals" do
+    assert_equal BigDecimal("12.37"), LiteralParser.parse('12.37', use_big_decimal: true)
+  end
+  test "Parse Symbols" do
+    assert_equal :simple_symbol, LiteralParser.parse(':simple_symbol')
+    assert_equal :"double quoted symbol", LiteralParser.parse(':"double quoted symbol"')
+    assert_equal :'single quoted symbol', LiteralParser.parse(":'single quoted symbol'")
+  end
+  test "Parse Strings" do
+    assert_equal 'Single Quoted String', LiteralParser.parse(%q{'Single Quoted String'})
+    assert_equal "Double Quoted String", LiteralParser.parse(%q{"Double Quoted String"})
+    assert_equal 'Single Quoted String \t\n\r\'\"', LiteralParser.parse(%q{'Single Quoted String \t\n\r\'\"'})
+    assert_equal "Double Quoted String \t\n\r\'\"", LiteralParser.parse(%q{"Double Quoted String \t\n\r\'\""})
+  end
+  test "Parse Regexes" do
+    assert_equal /some_regex/, LiteralParser.parse('/some_regex/')
+    assert_equal /some_regex/imx, LiteralParser.parse('/some_regex/imx')
+  end
+  test "Parse Date" do
+    assert_equal Date.civil(2012,5,20), LiteralParser.parse('2012-05-20')
+  end
+  test "Parse Time" do
+    assert_equal Time.mktime(2012,5,20,18,29,52), LiteralParser.parse('2012-05-20T18:29:52')
+  end
+  test "Parse Array" do
+    array_string    = '[nil, false, true, 123, 12.5, 2012-05-20, :sym, "str"]'
+    expected_array  = [nil, false, true, 123, 12.5, Date.civil(2012,5,20), :sym, "str"]
+    assert_equal expected_array, LiteralParser.parse(array_string)
+  end
+  test "Parse Hash" do
+    array_string    = '{nil => false, true => 123, 12.5 => 2012-05-20, :sym => "str"}'
+    expected_array  = {nil => false, true => 123, 12.5 => Date.civil(2012,5,20), :sym => "str"}
+    assert_equal expected_array, LiteralParser.parse(array_string)
+  end
+  test "Parse Constants" do
+    assert_equal Time, LiteralParser.parse('Time')
+  end
+  test "Perform manual parsing" do
+    parser = LiteralParser.new("'hello'\n12\ntrue")
+    assert_equal 0, parser.position
+    assert_equal 'hello', parser.scan_value
+    assert_equal "\n12\ntrue", parser.rest
+    assert_equal 7, parser.position
+    assert_equal false, parser.end_of_string?
+
+    parser.position += 1
+    assert_equal 8, parser.position
+    assert_equal 12, parser.scan_value
+    assert_equal "\ntrue", parser.rest
+    assert_equal 10, parser.position
+    assert_equal false, parser.end_of_string?
+
+    parser.position += 1
+    assert_equal 11, parser.position
+    assert_equal true, parser.scan_value
+    assert_equal "", parser.rest
+    assert_equal 15, parser.position
+    assert_equal true, parser.end_of_string?
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: literal_parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Rusterholz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-20 00:00:00.000000000 Z
+dependencies: []
+description: Parse Strings containing ruby literals and return a proper ruby object.
+email: stefan.rusterholz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/literal_parser/version.rb
+- lib/literal_parser.rb
+- test/lib/helper.rb
+- test/runner.rb
+- test/unit/lib/literal_parser.rb
+- literal_parser.gemspec
+- Rakefile
+- README.markdown
+homepage: https://github.com/apeiros/literal_parser
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Parse Strings containing ruby literals and return a proper ruby object.
+test_files: []
+has_rdoc: