ruby_token_parser 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c60c4b936d34a0388136c3585afa1726b580b256b7bb277f1323706a5bbe4e0
+  data.tar.gz: 1de41610a7b060f7ded20bd3e1d953fb6e86b21de47e01747364a7a2ce8e9364
+SHA512:
+  metadata.gz: 72ce6264df8b2154cfbe423a03d30b2972b57f05f096ec438c45a0de41057bf58a6efc0f23a4db74f09d6cd7013376104c5b4fb59c99ab759751f88277abda7e
+  data.tar.gz: 763aed054956357e20b6b983fff7e8e00ce22d466e41e421da63d7b2e1dea80d8925dc8363ed028da9d3ea6fe9097de0efce9c8190b8a7ee6a696d182965efb0

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Original Copyright (c) 2012-2014, Stefan Rusterholz <stefan.rusterholz@gmail.com>
+
+Derived work Copyright (c) 2015, "shevy" Robert A. Heiler <shevegen@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,107 @@
+README
+======
+
+
+Summary
+-------
+
+This project, called ruby_token_parser, will parse strings containing
+ruby literals and return a proper ruby object.
+
+This can be used to deconstruct a String into its constituent members
+as valid ruby objects, similar as to what IRB is doing when you let
+it evaluate the user input you supply it with.
+
+
+Features
+--------
+
+* Recognizes about all Ruby literals:
+
+  nil, true, false, Symbols, Integers, Floats, Hashes, Arrays and
+  also Ranges.
+
+* Additionally parses Constants, Dates and Times.
+
+* Simple to use through [] or .parse such as:
+
+  RubyTokenParser[]
+
+Installation
+------------
+
+`gem install ruby_token_parser`
+
+
+Usage
+-----
+
+Several examples follow next:
+
+    RubyTokenParser.parse("nil") # => nil
+    RubyTokenParser.parse(":foo") # => :foo
+    RubyTokenParser.parse("123") # => 123
+    RubyTokenParser.parse("1.5") # => 1.5
+    RubyTokenParser.parse("1.5", use_big_decimal: true) # => #<BigDecimal:…,'0.15E1',18(18)>
+    RubyTokenParser.parse("[1, 2, 3]") # => [1, 2, 3]
+    RubyTokenParser.parse("{:a => 1, :b => 2}") # => {:a => 1, :b => 2}
+    RubyTokenParser.parse("(1..15)")
+    RubyTokenParser["(1..15)"]
+
+
+License
+-------
+
+You can use this code under the {file:LICENSE.txt BSD-2-Clause License},
+free of charge.
+
+A link to the content of this license is provided here:
+
+    https://opensource.org/licenses/BSD-2-Clause
+
+Note that the original version of this gem, called "literal_parser",
+was written by apeiros (Stefan Rusterholz) - you may be able to find
+his work here at:
+
+    https://github.com/apeiros
+    https://github.com/apeiros/literal_parser
+
+If you need a different license in regards to the original literal_parser,
+please ask apeiros, not me, since it was his original code and work.
+
+My (shevy) modifications were small, mostly just cosmetic, some renaming,
+the addition of Range-objects (since I needed that in one other project
+specifically), a bit more documentation, a general restructure of the
+code to make it easier for me to read and the addition of [] as a class
+method.
+
+The BSD-2 license mandates that one has to retain the original copyright.
+
+I assume that the original copyright is the following one here:
+
+Copyright (c) 2012-2014, apeiros (Stefan Rusterholz)
+
+The link to that license can be found at:
+
+    https://github.com/apeiros/literal_parser/blob/master/LICENSE.txt
+
+Or respectively as part of apeiros' literal_parser project.
+
+This LICENSE.txt is also part of the gem here and was included in
+the literal_parser project.
+
+I will add the disclaimer as part of the license link to the readme
+here, as the original link at opensource.org also states something
+somewhat similar:
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.

data/lib/ruby_token_parser.rb

@@ -0,0 +1 @@
+require 'ruby_token_parser/ruby_token_parser.rb'

data/lib/ruby_token_parser/parse.rb

@@ -0,0 +1,74 @@
+class RubyTokenParser
+
+  # ========================================================================= #
+  # === RubyTokenParser.parse
+  #
+  # The RubyTokenParser.parse() method will parse a String, and return
+  # the (ruby) object which it contains.
+  #
+  # @usage example:
+  #
+  #   RubyTokenParser.parse(":foo") # => :foo
+  #
+  # @param [String] string
+  #
+  #   The (input) String which should be parsed.
+  #
+  # @param [nil, Hash] options
+  #
+  #   An options-hash
+  #
+  # @param [Boolean] do_raise_an_exception
+  #
+  # This boolean will determine whether we will raise an exception
+  # or whether we will not.
+  #
+  # @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 [RubyTokenParser::SyntaxError]
+  #
+  #   If the String does not contain exactly one valid literal,
+  #   a SyntaxError is raised.
+  #
+  # Usage example:
+  #   x = RubyTokenParser.parse("[1,2,3]")
+  # ========================================================================= #
+  def self.parse(
+      string,
+      options = nil,
+      do_raise_an_exception = RubyTokenParser.raise_exception?
+    )
+    # ======================================================================= #
+    # === Instantiate a new parser
+    # ======================================================================= #
+    parser  = new(string, options)
+    begin
+      value = parser.scan_value
+    rescue RubyTokenParser::SyntaxError # Must rescue things such as: @foo = foo
+      value = RubyTokenParser::SyntaxError
+    end
+    if do_raise_an_exception
+      unless parser.end_of_string? or
+             value.nil?
+        # =================================================================== #
+        # Raise the Syntax Error.
+        # =================================================================== #
+        raise SyntaxError,
+              "Unexpected superfluous data: #{parser.rest.inspect}"
+      end unless value.is_a? Range # Make an exception for Range objects.
+    end
+    value
+  end; self.instance_eval { alias [] parse } # === RubyTokenParser[]
+       # ^^^ Add an alias to it, aka [].
+end

data/lib/ruby_token_parser/requires.rb

@@ -0,0 +1,5 @@
+require 'strscan'
+require 'bigdecimal'
+require 'date'
+require 'ruby_token_parser/ruby_token_constants.rb'
+require 'ruby_token_parser/parse.rb'

data/lib/ruby_token_parser/ruby_token_constants.rb

@@ -0,0 +1,188 @@
+class RubyTokenParser
+
+# ========================================================================= #
+# === RubyTokenParser::Expressions
+#
+# @private
+#
+# All the expressions used to parse the literals will be bundled here.
+# ========================================================================= #
+module Expressions # === RubyTokenParser::Expressions
+
+  # ======================================================================= #
+  # === Match to the start of an Array
+  # ======================================================================= #
+  RArrayBegin     = /\[/                                      
+
+  # ======================================================================= #
+  # === Match whitespace between elements in an Array
+  # ======================================================================= #
+  RArrayVoid      = /\s*/
+
+  # ======================================================================= #
+  # === Match the separator of Array elements
+  #
+  # This depends on RArrayVoid having been defined before.
+  #
+  # A separator in an Array is something such as:
+  #   [1,2,3]
+  # ======================================================================= #
+  RArraySeparator = /#{RArrayVoid},#{RArrayVoid}/
+
+  # ======================================================================= #
+  # === Match to the end of an Array
+  # ======================================================================= #
+  RArrayEnd       = /\]/
+
+  # ======================================================================= #
+  # === Match to the start of a Hash
+  # ======================================================================= #
+  RHashBegin      = /\{/
+
+  # ======================================================================= #
+  # === Match whitespace between elements in a Hash
+  # ======================================================================= #
+  RHashVoid       = /\s*/
+
+  # ======================================================================= #
+  # === Match the separator of hash key/value pairs
+  # ======================================================================= #
+  RHashSeparator  = /#{RHashVoid},#{RHashVoid}/
+
+  # ======================================================================= #
+  # === Match the separator between a key and a value in a hash
+  # ======================================================================= #
+  RHashArrow      = /#{RHashVoid}=>#{RHashVoid}/
+
+  # ======================================================================= #
+  # === Match end of a Hash
+  # ======================================================================= #
+  RHashEnd        = /\}/
+
+  # ======================================================================= #
+  # === Match constant names (with nesting)
+  # ======================================================================= #
+  RConstant       = /[A-Z]\w*(?:::[A-Z]\w*)*/
+
+  # ======================================================================= #
+  # === Match to nil
+  # ======================================================================= #
+  RNil            = /nil/
+
+  # ======================================================================= #
+  # === Match false
+  # ======================================================================= #
+  RFalse          = /false/
+
+  # ======================================================================= #
+  # === Match true
+  # ======================================================================= #
+  RTrue           = /true/
+
+  # ======================================================================= #
+  # === Match an Integer in decimal notation
+  # ======================================================================= #
+  RInteger        = /[+-]?\d[\d_]*/
+
+  # ======================================================================= #
+  # === Match an Integer in binary notation
+  # ======================================================================= #
+  RBinaryInteger  = /[+-]?0b[01][01_]*/
+
+  # ======================================================================= #
+  # === Match an Integer in hexadecimal notation
+  # ======================================================================= #
+  RHexInteger     = /[+-]?0x[A-Fa-f\d][A-Fa-f\d_]*/
+
+  # ======================================================================= #
+  # === Match a decimal number (Float or BigDecimal)
+  # ======================================================================= #
+  RBigDecimal     = /#{RInteger}\.\d+/
+
+  # ======================================================================= #
+  # === Match a decimal number in scientific notation
+  # ======================================================================= #
+  RFloat          = /#{RBigDecimal}(?:f|e#{RInteger})/
+
+  # ======================================================================= #
+  # === Match a date
+  # ======================================================================= #
+  RDate           = /(\d{4})-(\d{2})-(\d{2})/
+
+  # ======================================================================= #
+  # === Match a time (without date)
+  # ======================================================================= #
+  RTime           = /(\d{2}):(\d{2}):(\d{2})(?:RTimeZone)?/
+
+  # ======================================================================= #
+  # === Match a datetime (must come after RTime was defined)
+  # ======================================================================= #
+  RDateTime       = /#{RDate}T#{RTime}/
+
+  # ======================================================================= #
+  # === Match a regular expression
+  # ======================================================================= #
+  RRegexp         = %r{/((?:[^\\/]+|\\.)*)/([imxnNeEsSuU]*)}
+
+  # ======================================================================= #
+  # === Match a double quoted string.
+  # ======================================================================= #
+  RDString        = /"(?:[^\\"]+|\\.)*"/
+
+  # ======================================================================= #
+  # === Match a single quoted string.
+  # ======================================================================= #
+  RSString        = /'(?:[^\\']+|\\.)*'/
+
+  # ======================================================================= #
+  # === Match a symbol                                         (symbol tag)
+  #
+  # Note that this depends on RSString and RDString, so these
+  # must come before that.
+  # ======================================================================= #
+  RSymbol         = /:[A-Za-z_]\w*|:#{RSString}|:#{RDString}/
+
+  # ======================================================================= #
+  # === Match a symbol used as key in a Hash
+  # ======================================================================= #
+  RHashKeySymbol  = /([A-Za-z_]\w*):/
+
+  # ======================================================================= #
+  # === Match a timezone
+  # ======================================================================= #
+  RTimeZone       = /(Z|[A-Z]{3,4}|[+-]\d{4})/
+
+  # ======================================================================= #
+  # === Match a Regex such as (1..5)
+  # ======================================================================= #
+  RRange          = /\(\d*..\d*\)/
+
+  # ======================================================================= #
+  # === Match an Integer in octal notation
+  # ======================================================================= #
+  ROctalInteger   = /[+-]?0[0-7][0-7'_,]*/
+
+  # ======================================================================= #
+  # === DoubleQuotedStringEscapes
+  #
+  # Map escape sequences in double quoted strings.
+  #
+  # This will be a really huge Hash.
+  # ======================================================================= #
+  DoubleQuotedStringEscapes  = {
+    '\\\\' => "\\",
+    "\\'"  => "'",
+    '\\"'  => '"',
+    '\t'   => "\t",
+    '\f'   => "\f",
+    '\r'   => "\r",
+    '\n'   => "\n",
+  }
+  256.times { |i|
+    DoubleQuotedStringEscapes["\\%o"    % i] = i.chr
+    DoubleQuotedStringEscapes["\\%03o"  % i] = i.chr
+    DoubleQuotedStringEscapes["\\x%02x" % i] = i.chr
+    DoubleQuotedStringEscapes["\\x%02X" % i] = i.chr
+  }
+
+end; end

data/lib/ruby_token_parser/ruby_token_parser.rb

@@ -0,0 +1,438 @@
+#!/System/Index/bin/ruby -w
+# Encoding: ISO-8859-1
+# =========================================================================== #
+# === RubyTokenParser
+#
+# require 'ruby_token_parser'; x = RubyTokenParser.parse("(1..3)")
+# require 'ruby_token_parser'; x = RubyTokenParser.parse("[1,2,3]")
+# require 'ruby_token_parser'; RubyTokenParser["(1..3)"]
+# =========================================================================== #
+require 'ruby_token_parser/requires.rb'
+
+# =========================================================================== #
+# === RubyTokenParser
+#
+# Parse Strings containing ruby literals.
+#
+# @examples
+#
+#   RubyTokenParser.parse("nil")  # => nil
+#   RubyTokenParser.parse(":foo") # => :foo
+#   RubyTokenParser.parse("123")  # => 123
+#   RubyTokenParser.parse("1.5")  # => 1.5
+#   RubyTokenParser.parse("1.5", use_big_decimal: true) # => #<BigDecimal:…,'0.15E1',18(18)>
+#   RubyTokenParser.parse("[1, 2, 3]") # => [1, 2, 3]
+#   RubyTokenParser.parse("{:a => 1, :b => 2}") # => {:a => 1, :b => 2}
+#   RubyTokenParser.parse("(1..3)")
+#
+# RubyTokenParser 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
+#     (1..20)                # Range
+#
+# @note Limitations
+#
+#   * RubyTokenParser does not support ruby 1.9's `{key: value}` syntax.
+#   * RubyTokenParser does not currently support all of rubys escape
+#     sequences in strings and symbols.
+#   * Trailing commas in Array and Hash are not supported.
+#
+# @note BigDecimals
+#
+#   You can instruct RubyTokenParser 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
+#
+#   RubyTokenParser 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 RubyTokenParser
+
+  include RubyTokenParser::Expressions
+
+  # ========================================================================= #
+  # === @do_raise_exception
+  # ========================================================================= #
+  @do_raise_exception = true
+
+  # ========================================================================= #
+  # === RubyTokenParser.set_do_raise_exception
+  # ========================================================================= #
+  def self.set_do_raise_exception(i = true)
+    @do_raise_exception = i
+  end
+
+  # ========================================================================= #
+  # === RubyTokenParser.raise_exception?
+  # ========================================================================= #
+  def self.raise_exception?
+    @do_raise_exception
+  end
+
+  # ========================================================================= #
+  # === RubyTokenParser::SyntaxError
+  #
+  # This error is raised when a String could not be parsed.
+  # ========================================================================= #
+  class SyntaxError < StandardError; end
+
+  # ========================================================================= #
+  # === initialize
+  #
+  # 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)
+    @string          = string
+    options          = options ? options.dup : {}
+    @constant_base   = options[:constant_base] # nil means toplevel
+    @use_big_decimal = options.delete(:use_big_decimal) { false }
+    @scanner         = StringScanner.new(string)
+  end
+
+  # ========================================================================= #
+  # === position?
+  #
+  # @return [Integer]
+  #
+  # The position of the scanner in the string.
+  # ========================================================================= #
+  def position?
+    @scanner.pos
+  end; alias position position? # === position
+
+  # ========================================================================= #
+  # === position=
+  #
+  # Moves the scanners position to the given character-index.
+  #
+  # @param [Integer] value
+  #
+  #   The new position of the scanner
+  # ========================================================================= #
+  def position=(i)
+    @scanner.pos = i
+  end
+
+  # ========================================================================= #
+  # === end_of_string?
+  #
+  # @return [Boolean]
+  #
+  # Whether the scanner reached the end of the string.
+  # ========================================================================= #
+  def end_of_string?
+    @scanner.eos?
+  end
+
+  # ========================================================================= #
+  # === rest
+  #
+  # @return [String] The currently unprocessed rest of the string.
+  # ========================================================================= #
+  def rest
+    @scanner.rest
+  end
+
+  # ========================================================================= #
+  # === content?
+  #
+  # Reader method over the current value of the scanner.
+  # ========================================================================= #
+  def content?
+    @scanner.string
+  end
+
+  # ========================================================================= #
+  # === use_big_decimal?
+  #
+  # @return [Boolean]
+  #
+  #   True if "1.25" should be parsed into a big-decimal,
+  #   false if it should be parsed as Float.
+  # ========================================================================= #
+  def use_big_decimal?
+    @use_big_decimal
+  end; alias use_big_decimal use_big_decimal? # === use_big_decimal
+
+  # ========================================================================= #
+  # === inspect?
+  # ========================================================================= #
+  def inspect?
+    @scanner.rest.inspect
+  end
+
+  # ========================================================================= #
+  # === constant_base?
+  #
+  # @return [Module, nil]
+  #
+  #   Where to lookup constants. Nil is toplevel (equivalent to Object).
+  # ========================================================================= #
+  def constant_base?
+    @constant_base
+  end; alias constant_base constant_base? # === constant_base
+
+  # ========================================================================= #
+  # === scan_value
+  #
+  # Scans the string for a single value and advances the parsers position.
+  #
+  # @return [Object] the scanned value
+  #
+  # @raise [RubyTokenParser::SyntaxError]
+  #
+  #   When no valid ruby object could be scanned at the given position,
+  #   a RubyTokenParser::SyntaxError is raised. Alternative you can
+  #   disable raising an error by calling:
+  #
+  #     RubyTokenParser.set_do_raise_exception(false)
+  #
+  # ========================================================================= #
+  def scan_value
+    case
+    # ======================================================================= #
+    # === Handle Ranges                               (range tag, ranges tag)
+    # ======================================================================= #
+    when (!content?.scan(RRange).empty?)
+      _ = content?.delete('(').delete(')').squeeze('.').split('.').map(&:to_i)
+      min = _.first
+      max = _.last
+      Range.new(min, max)
+    # ======================================================================= #
+    # === Handle Arrays                               (arrays tag, array tag)
+    # ======================================================================= #
+    when @scanner.scan(RArrayBegin)
+      value = []
+      @scanner.scan(RArrayVoid)
+      if @scanner.scan(RArrayEnd)
+        value
+      else
+        value << scan_value
+        while @scanner.scan(RArraySeparator)
+          value << scan_value
+        end
+        unless @scanner.scan(RArrayVoid) && @scanner.scan(RArrayEnd)
+          raise SyntaxError, 'Expected ]'
+        end
+        value
+      end
+    # ======================================================================= #
+    # === Handle Hashes
+    #
+    # This is quite complicated. We have to scan whether we may find
+    # the {} syntax or the end of a hash.
+    # ======================================================================= #
+    when @scanner.scan(RHashBegin)
+      value = {}
+      @scanner.scan(RHashVoid)
+      if @scanner.scan(RHashEnd)
+        value
+      else
+        if @scanner.scan(RHashKeySymbol)
+          key = @scanner[1].to_sym
+          @scanner.scan(RHashVoid)
+        else
+          key = scan_value
+          unless @scanner.scan(RHashArrow)
+            raise SyntaxError, 'Expected =>'
+          end
+        end
+        val = scan_value
+        value[key] = val
+        while @scanner.scan(RHashSeparator)
+          if @scanner.scan(RHashKeySymbol)
+            key = @scanner[1].to_sym
+            @scanner.scan(RHashVoid)
+          else
+            key = scan_value
+            raise SyntaxError, 'Expected =>' unless @scanner.scan(RHashArrow)
+          end
+          val = scan_value
+          value[key] = val
+        end
+        unless @scanner.scan(RHashVoid) && @scanner.scan(RHashEnd)
+          raise SyntaxError, 'Expected }'
+        end
+        value
+      end
+    # ======================================================================= #
+    # === Handle Constants
+    #
+    # eval() is evil but it may be sane due to the regex, also
+    # it's less annoying than deep_const_get.
+    #
+    # @constant_base can be set via the Hash options[:constant_base].
+    # ======================================================================= #
+    when @scanner.scan(RConstant)
+      eval("#{@constant_base}::#{@scanner.first}")
+    # ======================================================================= #
+    # === Handle Nil values
+    # ======================================================================= #
+    when @scanner.scan(RNil)
+      nil
+    # ======================================================================= #
+    # === Handle True values
+    # ======================================================================= #
+    when @scanner.scan(RTrue) # true tag
+      true
+    # ======================================================================= #
+    # === Handle False values
+    # ======================================================================= #
+    when @scanner.scan(RFalse) # false tag
+      false
+    # ======================================================================= #
+    # === Handle DateTime values
+    # ======================================================================= #
+    when @scanner.scan(RDateTime)
+      Time.mktime( # Tap into the regex pattern next.
+        @scanner[1], @scanner[2],
+        @scanner[3], @scanner[4],
+        @scanner[5], @scanner[6]
+      )
+    # ======================================================================= #
+    # === Handle Date values
+    # ======================================================================= #
+    when @scanner.scan(RDate)
+      date = @scanner[1].to_i, @scanner[2].to_i, @scanner[3].to_i
+      Date.civil(*date)
+    # ======================================================================= #
+    # === Handle RTime values
+    # ======================================================================= #
+    when @scanner.scan(RTime)
+      now = Time.now
+      Time.mktime(
+        now.year, now.month, now.day,
+        @scanner[1].to_i, @scanner[2].to_i, @scanner[3].to_i
+      )
+    # ======================================================================= #
+    # === Handle Float values
+    # ======================================================================= #
+    when @scanner.scan(RFloat)
+      Float(@scanner.matched.delete('^0-9.e-'))
+    # ======================================================================= #
+    # === Handle BigDecimal values
+    # ======================================================================= #
+    when @scanner.scan(RBigDecimal)
+      data = @scanner.matched.delete('^0-9.-')
+      @use_big_decimal ? BigDecimal(data) : Float(data)
+    # ======================================================================= #
+    # === Handle OctalInteger values
+    # ======================================================================= #
+    when @scanner.scan(ROctalInteger)
+      # ===================================================================== #
+      # We can make use of Integer to turn them into valid ruby objects.
+      # ===================================================================== #
+      Integer(@scanner.matched.delete('^0-9-'))
+    # ======================================================================= #
+    # === Handle HexInteger values
+    # ======================================================================= #
+    when @scanner.scan(RHexInteger)
+      Integer(@scanner.matched.delete('^xX0-9A-Fa-f-'))
+    # ======================================================================= #
+    # === Handle BinaryInteger values
+    # ======================================================================= #
+    when @scanner.scan(RBinaryInteger)
+      Integer(@scanner.matched.delete('^bB01-'))
+    # ======================================================================= #
+    # === Handle Integer values
+    # ======================================================================= #
+    when @scanner.scan(RInteger)
+      @scanner.matched.delete('^0-9-').to_i
+    # ======================================================================= #
+    # === Handle Regexp values
+    # ======================================================================= #
+    when @scanner.scan(RRegexp)
+      source = @scanner[1]
+      flags  = 0
+      lang   = nil
+      if @scanner[2]
+        flags |= Regexp::IGNORECASE if @scanner[2].include?('i') # Value of 1
+        flags |= Regexp::EXTENDED   if @scanner[2].include?('m') # Value of 2
+        flags |= Regexp::MULTILINE  if @scanner[2].include?('x') # Value of true
+        lang   = @scanner[2].delete('^nNeEsSuU')[-1,1]
+      end
+      Regexp.new(source, flags, lang)
+    # ======================================================================= #
+    # === Handle double-quoted string values
+    # ======================================================================= #
+    when @scanner.scan(RDString)
+      @scanner.matched[1..-2].gsub(/\\(?:[0-3]?\d\d?|x[A-Fa-f\d]{2}|.)/) { |m|
+        DStringEscapes[m]
+      }
+    # ======================================================================= #
+    # === Handle Symbol values                      (symbol tag, symbols tag)
+    # ======================================================================= #
+    when @scanner.scan(RSymbol)
+      # ===================================================================== #
+      # Next, check the first character matched.
+      # ===================================================================== #
+      case @scanner.matched[1,1] # Might be "f".
+      # ===================================================================== #
+      # If it is a '"' quote, enter here.
+      # ===================================================================== #
+      when '"'
+        @scanner.matched[2..-2].gsub(/\\(?:[0-3]?\d\d?|x[A-Fa-f\d]{2}|.)/) { |m|
+          DStringEscapes[m]
+        }.to_sym
+      # ===================================================================== #
+      # If it is a "'" quote, enter here.
+      # ===================================================================== #
+      when "'"
+        @scanner.matched[2..-2].gsub(/\\'/, "'").gsub(/\\\\/, "\\").to_sym
+      else # Default here. Match all but the leading ':'
+        @scanner.matched[1..-1].to_sym
+      end
+    # ======================================================================= #
+    # === Handle single-quoted string values
+    # ======================================================================= #
+    when @scanner.scan(RSString)
+      @scanner.matched[1..-2].gsub(/\\'/, "'").gsub(/\\\\/, "\\")
+    # ======================================================================= #
+    # === Handle everything else
+    #
+    # This can lead to a runtime error, so we must raise a SyntaxError.
+    # ======================================================================= #
+    else # else tag
+      raise SyntaxError, "Unrecognized pattern: #{inspect?}"
+    end
+  end
+
+end

data/ruby_token_parser.gemspec

@@ -0,0 +1,49 @@
+# =========================================================================== #
+# Gemspec for Project RubyTokenParser.
+# =========================================================================== #
+Gem::Specification.new { |s|
+
+  s.name    = 'ruby_token_parser'
+  s.version = '0.0.6'
+  s.date    = Time.now.strftime('%Y-%m-%d')
+
+  DESCRIPTION = <<-EOF
+
+    This project is called ruby_token_parser.
+    
+    It allows one to parse for ruby literals, which can
+    be used to return a proper ruby object.
+    
+    This project is based on apeiros' prior work, his gem
+    is called literal_parser - check it out.
+
+    If you have specific suggestions to make this gem more
+    useful for others, please drop me an email at:
+
+      shevegen@gmail.com
+
+    Thank you.
+  EOF
+
+  s.summary     = DESCRIPTION
+  s.description = DESCRIPTION
+  
+  s.extra_rdoc_files = %w()
+  
+  s.authors     = ['Robert A. Heiler']
+  s.email       = 'shevegen@gmail.com'
+  s.files       = Dir['**/*']
+  s.files      << 'README.md'
+  s.license     = 'BSD-2-Clause'
+  s.homepage    = 'https://github.com/shevegen/ruby_token_parser'
+
+  s.required_ruby_version     = '>= '+RUBY_VERSION
+  s.required_rubygems_version = '>= '+Gem::VERSION
+  s.rubygems_version          = '>= '+Gem::VERSION
+
+  # ========================================================================= #
+  # External dependencies for the project:
+  # ========================================================================= #
+  # s.add_dependency 'foo'
+
+}

data/test/testing_ruby_token_parser.rb

@@ -0,0 +1,73 @@
+#!/System/Index/bin/ruby -w
+# Encoding: ISO-8859-1
+# =========================================================================== #
+require 'pp'
+require 'cliner'
+require 'colour_e/autoinclude'
+require 'ruby_token_parser'
+
+cliner {
+  e 'We will next test the '+simp('RubyTokenParser')
+}
+# =========================================================================== #
+# === test_this_string
+# =========================================================================== #
+def test_this_string(i, optional_argument = nil)
+  e 'We will test this input next: '+simp(i)
+  x = RubyTokenParser.parse(i, optional_argument)
+  pp x
+end
+
+_ = '(1..3)'
+test_this_string(_)
+cliner
+
+_ = "[1,2,3]"
+test_this_string(_)
+cliner
+
+_ = '(1..5)'
+test_this_string(_) # => (1..5)
+cliner
+
+_ = 'nil'
+test_this_string(_) # => nil
+cliner
+
+# =========================================================================== #
+# === Handle Symbols
+# =========================================================================== #
+_ = ':foo'
+test_this_string(_) # => :foo
+cliner
+
+# =========================================================================== #
+# === Handle Integers
+# =========================================================================== #
+_ = '123'
+test_this_string(_) # => 123
+cliner
+
+_ = '1.5'
+test_this_string(_) # =>  1.5
+cliner
+
+_ = '1.5'
+test_this_string(_, use_big_decimal: true) # <BigDecimal:…,'0.15E1',18(18)>
+cliner
+
+_ = '[1, 2, 3]'
+test_this_string(_) # => [1, 2, 3]
+cliner
+
+_ = '{:a => 1, :b => 2}'
+test_this_string(_) # => {:a => 1, :b => 2}
+cliner
+
+_ = '(1..3)'
+test_this_string(_) # => (1..3)
+cliner
+
+_ = '"xyz"'
+test_this_string(_) # => 
+cliner

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: ruby_token_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Robert A. Heiler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-28 00:00:00.000000000 Z
+dependencies: []
+description: "\n    This project is called ruby_token_parser.\n    \n    It allows
+  one to parse for ruby literals, which can\n    be used to return a proper ruby object.\n
+  \   \n    This project is based on apeiros' prior work, his gem\n    is called literal_parser
+  - check it out.\n\n    If you have specific suggestions to make this gem more\n
+  \   useful for others, please drop me an email at:\n\n      shevegen@gmail.com\n\n
+  \   Thank you.\n"
+email: shevegen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/ruby_token_parser.rb
+- lib/ruby_token_parser/parse.rb
+- lib/ruby_token_parser/requires.rb
+- lib/ruby_token_parser/ruby_token_constants.rb
+- lib/ruby_token_parser/ruby_token_parser.rb
+- ruby_token_parser.gemspec
+- test/testing_ruby_token_parser.rb
+homepage: https://github.com/shevegen/ruby_token_parser
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.7
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: 'This project is called ruby_token_parser.  It allows one to parse for ruby
+  literals, which can be used to return a proper ruby object.  This project is based
+  on apeiros'' prior work, his gem is called literal_parser - check it out.  If you
+  have specific suggestions to make this gem more useful for others, please drop me
+  an email at:  shevegen@gmail.com  Thank you.'
+test_files: []