gloo 6.3.1 → 6.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517b0f6358d83303a3e6e7536b9a16abd4a71cf9ef1649faf6abd21443fe652d
-  data.tar.gz: b43125b452393abea79914d54a2f73e7d77791891ed3e14cde8ad51e2bdb44ce
+  metadata.gz: c586639c9bf946ff078f68d28ac3c8fd676ae3e040ee181d7a65eb63a648feda
+  data.tar.gz: defbe6d74c65dfd5df9abbf3e917cdd3acb950c8d890dfab53cc37b158118772
 SHA512:
-  metadata.gz: cb9e73f9e4d4281d3ce190258bf744150176ac09c2f0e980b920f185a583015fdd3a5b64180fa0c07b6970f04f8c0eba49840495b35291846bd86e0e57dcf3d7
-  data.tar.gz: ac5e8e247415a01107fee4cc12358559eafc698ac2e5c1ffdd5ee6cc01e6c7cca54d5b9eb44fdc589a8ce692fd36367103125571d5cff038a10b6cabe27ca4ac
+  metadata.gz: 578cac3fcd5cf809fd00db651563b3a0ff8a2eef70796f9ccd4742b1086f6d4e9045ffe77db73a307be5972a46d9262f9b43a59c2fe215ecacae900fd450f478
+  data.tar.gz: 5248581d7000865535b0419cd6772e72de8c5ac1a09fe8668345e2ca2703ffcf28756fdd70b8b7e99f2fe04a88c64fbe5a9bb4ad7e204827e689eef05011ac4f

data/CLAUDE.md

@@ -58,6 +58,19 @@ Base classes: inherit from `GlooTest` (defined in `test/base_test.rb`).
 ### Gloo integration tests — `test.gloo/`
 Written in gloo itself. Each file contains `[test]` objects with `on_test` scripts using `assert` and `refute`.
 
+Run with `ruby lib/run.rb --test --quiet <paths...>` — **not** `bundle exec` (the Gemfile doesn't carry `gloo-test` / `gloo-md` / the other core-lib gems, so `[test]` and `load lib` fail under bundler; plain `ruby` uses the system gem env where they're installed).
+
+- Interpreter suite only:
+  `ruby ~/dev/gloo/lib/run.rb --test --quiet ~/dev/gloo/test.gloo/`
+- Interpreter **plus** every extension and core library:
+  ```
+  ruby ~/dev/gloo/lib/run.rb --test --quiet \
+    ~/dev/gloo/test.gloo/ \
+    ~/gloo/extensions/{alert,beep,git,ruby,slack,stats,teams}/test/ \
+    ~/dev/gloo_core_libraries/gloo-{beep,cli,db,email,md,mysql,pg,sqlite,test,web,yaml}/test/
+  ```
+  (brace expansion is shell sugar for the full explicit path list)
+
 ```
 test.gloo/
 ├── basic.test.gloo

data/docs/application.md

@@ -30,6 +30,8 @@ gloo [global option] [file]
 
 Running gloo with a file specified will run that file. Once that file is done, gloo will quit. However, by specifying `--cli`, once the file has finished, gloo will remain open in CLI mode.
 
+If a file named on the command line can't be found (a typo, the wrong folder, a missing `.gloo` extension on a full path), gloo prints `File not found: {name}` to stderr and exits with a non-zero status. Any other load or run error also exits non-zero, so a shell script calling gloo can tell a failed run from a clean one.
+
 When specifying a file there are a couple ways to reference the gloo file to open:
 
 - By Path
@@ -101,6 +103,13 @@ gloo:
   #
   list_levels: 3
 
+  #
+  # When listing the object tree, also show each object's doc (the
+  # comment declared immediately above it in its source file), if it
+  # has one.
+  #
+  list_docs: false
+
   #
   # Show debug statements in the log?
   #

data/docs/language_objects.md

@@ -3,6 +3,7 @@
 **Contents**
 
 - Object Naming
+- Nested Container Shorthand
 - Keywords
 - Literals
 - Value Conversion
@@ -39,6 +40,76 @@ naming [container] :
 
 See also: Pathname.
 
+## Nested Container Shorthand
+
+A declaration whose name is a dotted path creates a container for each
+prefix segment, then declares the real object under the last one. These
+two files are equivalent:
+
+```gloo
+page [container] :
+  core [container] :
+    users [container] :
+      list [container] :
+        title [string] : Users
+```
+
+```gloo
+page.core.users.list [container] :
+  title [string] : Users
+```
+
+- Each prefix segment (`page`, `core`, `users`) becomes a container,
+  unless a sibling object of that name already exists — in which case
+  that object is used as-is.
+- The shorthand works at any indent level; the prefix is resolved
+  relative to the current parent.
+- Several shorthand lines can share a prefix — `page.core.users [...]`
+  and `page.core.settings [...]` both reuse the same `page` and
+  `page.core` containers.
+- Indented lines below a shorthand declaration are children of the last
+  segment (`list` above), not of any prefix container.
+
+## Documenting an Object
+
+A contiguous run of whole-line comments immediately above a declaration,
+at the same indent and with no blank line in between, is that object's
+**doc** — read it back at run time with `tell {obj} to doc` or
+`check {obj} for doc` (the cleaned text lands in `it`, like any other
+value-returning message):
+
+```gloo
+#
+# The user's display name. Empty until they set it in preferences.
+#
+name [string] :
+```
+
+```gloo
+> check name for doc
+> show it
+
+The user's display name. Empty until they set it in preferences.
+
+```
+
+Each line's own leading whitespace and `#` marker (plus one space after
+it, if there is one) are stripped, and the result is dedented to its
+shallowest line — but otherwise the full block is kept exactly as
+written, blank `#` lines above and below the text included. An object
+with no leading comment — including anything created at run time rather
+than loaded from a file — has a blank doc (`''`).
+
+A comment separated from the declaration by a blank line, or at a
+different indent, is not associated with it — it's kept as its own
+floating comment in the file instead. When a name is declared in more
+than one loaded file, the first non-empty doc wins (same rule as the
+first value).
+
+`list` can show every documented object in a listed tree: turn on the
+`list_docs` setting (off by default) — see `list` and `settings` in the
+in-app help.
+
 ## Keywords
 
 Gloo doesn't reserve words the way many languages do. A verb keyword like `put` or an object type name like `string` can also be used as an object name — there's no parser conflict, because verbs are only looked up as the first word of a statement, and object type names are only looked up where a type is expected (inside the `[ ]` on a declaration). Everywhere else, the word is just a pathname segment (see Object Naming, above).
@@ -60,6 +131,11 @@ The following rules apply to literal values:
 
 - Strings
     - Can be delimited by single or double quotes. (`"` or `'`)
+    - A quote of the other kind inside needs no escaping —
+      `'{"x":1}'` is the string `{"x":1}`, which is the usual way to
+      write a JSON literal.
+    - A quote of the same kind inside is escaped with a backslash —
+      `"say \"hi\""` is the string `say "hi"`.
 - Numbers
     - Integer and decimal numbers need no delimiters.
     - To refer to a decimal with no fractional value, include `.0` to indicate a decimal value.
@@ -89,6 +165,8 @@ The following rules apply to literal values:
       show ^.s
       put "You're Awesome!" into ^.s
       show ^.s
+      put '{"lang":"gloo"}' into ^.s
+      show ^.s
 
       # Number literals
       put 1 into ^.i

data/docs/language_scripting.md

@@ -3,6 +3,7 @@
 **Contents**
 
 - Gloo Script Files
+- Comments
 - Gloo Constants
 - Line Continuation
 
@@ -26,6 +27,46 @@ hello [can] :
   on_load [script] : show 'hello world'
 ```
 
+## Comments
+
+A line whose first non-blank character is `#` is a comment. Whole-line comments
+can appear anywhere — between objects, inside a container, or inside a script
+body — and are ignored when the file runs.
+
+```gloo
+#
+# A whole-line comment.
+#
+demo [can] :
+  # a comment inside the container
+  msg [string] : hello
+  on_load [script] :
+    # a comment inside the script body
+    show demo.msg
+```
+
+A statement line may also end with an inline `# ...` comment. It is stripped
+before the statement runs, so it has no effect on execution:
+
+```gloo
+on_load [script] :
+  show 3 + 4        # prints 7
+  check demo.msg for blank?
+  show it           # prints false
+```
+
+Two things are *not* treated as inline comments, and are left alone:
+
+- a `#` inside a quoted string — `show 'a # b'`
+- a `#` with no space before it — a URL fragment such as
+  `http://example.com/page#section`
+
+An inline comment on an object declaration is also left alone — everything after
+the `:` is the object's value, so `note [string] : see item # 5` stores the
+string `see item # 5`.
+
+---
+
 ## Gloo Constants
 
 There is no gloo language construct for constants. They are simply objects. But by convention, constants are named in all caps. They might be in a container or at the root object level.

data/docs/objects.md

@@ -4,7 +4,7 @@ Everything in gloo is an object. Strings, numbers, containers, scripts, function
 
 Gloo ships with a large set of built-in object types, and core libraries and extensions can add more. This page doesn't try to cover them all — it walks through three common ones to get a feel for how objects work. For the complete list of object types, and every message each one supports, use the in-app help: enter `help` (or `?`), then `objects` to list them all, or `object {name}` for detail on one (see Application, Help).
 
-An object's **type declares which messages it can receive** — `up` and `trim` for a `string`, `inc` for an `integer`, `run` for a `script`. An object doesn't have to have a type: with none it is `untyped` (short `any`), declared with a bare colon (`slot :`), with `[any]`, or by `create` with no `as`. An untyped object still takes the messages every object understands (`blank?`, `contains?`, `responds_to?`, `reload`, `unload`) — just not the type-specific ones. Untyped is the right choice when you only need to hold, compare, or show a value: a generic result slot, a config value passed straight through, or a field whose kind of value changes over its life.
+An object's **type declares which messages it can receive** — `up` and `trim` for a `string`, `inc` for an `integer`, `run` for a `script`. An object doesn't have to have a type: with none it is `untyped` (short `any`), declared with a bare colon (`slot :`), with `[any]`, or by `create` with no `as`. An untyped object still takes the messages every object understands (`blank?`, `contains?`, `responds_to?`, `doc`, `reload`, `unload`) — just not the type-specific ones. Untyped is the right choice when you only need to hold, compare, or show a value: a generic result slot, a config value passed straight through, or a field whose kind of value changes over its life.
 
 **Contents**
 

data/docs/verbs.md

@@ -9,8 +9,9 @@ Verbs aren't just for scripts, though. They're also the interactive language of
 - Run
 - Tell
 - Put
+- Load & Save
 
-This page walks through three of the most commonly used verbs to get a feel for how they work together. For the complete list of verbs, their full syntax, and every error they can raise, use the in-app help: enter `help` (or `?`), then `verbs` to list them all, or `verb {name}` for detail on one (see Application, Help).
+This page walks through the most commonly used verbs to get a feel for how they work together. For the complete list of verbs, their full syntax, and every error they can raise, use the in-app help: enter `help` (or `?`), then `verbs` to list them all, or `verb {name}` for detail on one (see Application, Help).
 
 ## Run
 
@@ -50,6 +51,13 @@ tell {path.to.object} to {message}
 > if it then show 'it does'
 ```
 
+`doc` is one such message every object responds to: it returns the comment block declared immediately above it in its source file, cleaned up (see Language, Objects — Documenting an Object).
+
+```gloo
+> tell my.obj to doc
+> show it
+```
+
 ## Put
 
 `put` evaluates an expression and stores the result in an object.
@@ -67,6 +75,32 @@ put {expression} into {dst.path}
 
 `it` also picks up the result of the evaluation, same as with other verbs — see It.
 
+## Load & Save
+
+`load` reads a `.gloo` file into the heap and runs its `on_load` script. Give a path relative to the project folder (no extension needed) or a full path (extension required); `*` in place of a file name loads every `.gloo` file in a folder.
+
+```gloo
+> load my/project/config
+> load my/app/*
+> load ~/.my_app/settings.gloo
+```
+
+If the name can't be resolved to a file, `load` reports `File not found: {name}` — it fires `on_error` and, when the file was named on the `gloo` command line, prints the message to stderr and exits non-zero. A bad or missing file never fails silently.
+
+`save` writes loaded objects back to their files. With no argument it saves every open file; with an object it saves the file (or files) that object's tree came from; with `to {path}` it saves to a new file and remembers the mapping.
+
+```gloo
+> save                        # every open file
+> save config                 # just config's file
+> save config to backups/config
+```
+
+A save is a **rewrite, not a regeneration**: comments, blank lines, and the original spacing are kept, and only the values you actually changed are re-written. A declaration you never touched comes back byte-for-byte.
+
+Several files can contribute to one container — declare `app [container] :` in each and add different children. They merge in the heap, and each file's save only rewrites its own declarations. If two files declare the *same* object with different values, the first one loaded wins and `load` logs a warning.
+
+An object can also save itself: `tell config to save`.
+
 ---
 
-`run`, `tell`, and `put` cover a lot of ground on their own, but there are 26 more verbs — `show`, `if`, `create`, `each`, `check`, and so on — all documented in-app. Enter `help` (or `?`), then `verbs` to browse them. (This page itself is also viewable in-app: `help> doc verbs`.)
+`run`, `tell`, `put`, and `load` / `save` cover a lot of ground, but there are more than two dozen other verbs — `show`, `if`, `create`, `each`, `check`, `reload`, `unload`, and so on — all documented in-app. Enter `help` (or `?`), then `verbs` to browse them. (This page itself is also viewable in-app: `help> doc verbs`.)

data/lib/VERSION

@@ -1 +1 @@
-6.3.1
+6.5.0

data/lib/VERSION_NOTES

@@ -1,3 +1,16 @@
+6.5.0 - 2026.09.11
+  - Adds option to show comments from the list verb.
+	  - Adds message to get doc for an object.
+  - Report error if the file to load can't be found.
+  - Fixes issue with multisegment root level object.
+
+
+6.4.0 - 2026.09.06
+ - Persistance refresh with updates for loading and saving
+ - Nested container shortcut syntax
+ - Fixes a number of comment and quoting issues
+
+
 6.3.1 - 2026.09.01
  - Fixes issue with MD in a text block (# ignored as comments)
 

data/lib/gloo/app/engine.rb

@@ -134,11 +134,15 @@ module Gloo
 
       #
       # Run files specified on the CLI.
-      # Then quit.
+      # Then quit, with a non-zero exit code if any file failed to
+      # load (missing, unresolvable, or errored on load) so that a
+      # calling shell script can tell a bad run from a good one.
       #
       def run_files
         load_files
+        failed = error?
         quit
+        exit( 1 ) if failed
       end
 
       # 

data/lib/gloo/app/log.rb

@@ -167,7 +167,7 @@ module Gloo
       #
       # Write an error message to the log and set the error
       # in the engine's data heap.
-      # Also write to the console unless quiet.
+      # Also write to the console (on stderr) unless quiet.
       #
       def error( msg, ex = nil, engine = nil )
         engine&.heap&.error&.set_to( msg ) if engine
@@ -176,11 +176,11 @@ module Gloo
         if ex
           @error.error ex.message
           @error.error ex.backtrace
-          puts @theme.error( msg ) unless @quiet
-          puts @theme.error( ex.message ) unless @quiet
-          puts ex.backtrace unless @quiet
+          $stderr.puts @theme.error( msg ) unless @quiet
+          $stderr.puts @theme.error( ex.message ) unless @quiet
+          $stderr.puts ex.backtrace unless @quiet
         else
-          puts @theme.error( msg ) unless @quiet
+          $stderr.puts @theme.error( msg ) unless @quiet
         end
       end
 

data/lib/gloo/app/settings.rb

@@ -15,7 +15,7 @@ module Gloo
 
       attr_reader :user_root, :log_path,
         :config_path, :project_path, :ext_path,
-        :start_with, :list_indent, :list_levels, :tmp_path,
+        :start_with, :list_indent, :list_levels, :list_docs, :tmp_path,
         :debug_path, :debug, :theme
 
       #
@@ -41,6 +41,7 @@ module Gloo
         puts theme.accent( '   Startup with:  ' ) + theme.emphasis( @start_with.to_s )
         puts theme.accent( '   Indent in Listing:  ' ) + theme.emphasis( @list_indent.to_s )
         puts theme.accent( '   List Levels:  ' ) + theme.emphasis( @list_levels.to_s )
+        puts theme.accent( '   List Docs:  ' ) + theme.emphasis( @list_docs.to_s )
         puts theme.accent( '   Debug?  ' ) + theme.emphasis( @debug.to_s )
         puts theme.accent( '   Theme:  ' ) + theme.emphasis( @theme )
         puts theme.accent( '   Screen Lines:  ' ) + theme.emphasis( Gloo::App::Settings.lines( @engine ).to_s )
@@ -158,6 +159,7 @@ module Gloo
         @start_with = settings[ 'gloo' ][ 'start_with' ]
         @list_indent = settings[ 'gloo' ][ 'list_indent' ]
         @list_levels = settings[ 'gloo' ][ 'list_levels' ]
+        @list_docs = settings[ 'gloo' ][ 'list_docs' ] == true
 
         @debug = settings[ 'gloo' ][ 'debug' ]
 
@@ -192,6 +194,7 @@ module Gloo
             start_with:
             list_indent: 2
             list_levels: 3
+            list_docs: false
             debug: false
             theme: #{DEFAULT_THEME}
         TEXT

data/lib/gloo/core/obj.rb

@@ -12,12 +12,21 @@ module Gloo
       attr_accessor :value
       attr_reader :children, :parent
 
+      # The object's documentation: the cleaned comment block declared
+      # immediately above it in its source file (Source::ObjNode#doc),
+      # copied on at load time by FileLoader. '' for an object with no
+      # such comment, or one created at run time. Loader-set only --
+      # there's no verb/message path to change it, so it can't drift
+      # from what the file actually says.
+      attr_accessor :doc
+
       #
       # Set up the object.
       #
       def initialize( engine )
         @engine = engine
         @value = ''
+        @doc = ''
         @children = []
         @parent = nil
       end
@@ -118,6 +127,29 @@ module Gloo
         return false
       end
 
+      #
+      # Serialize this object's value for saving to a file.
+      # Returns the text that follows "name [type]" on the declaration
+      # line -- including the leading ' :' and, for a multi-line string
+      # value, the additional indented lines and the closing END marker.
+      # indent is the indentation level of the declaration line itself.
+      #
+      def serialize_value( indent )
+        return " : #{value_display}" unless value_string? && value.include?( "\n" )
+
+        return serialize_block_value( indent )
+      end
+
+      #
+      # Serialize a multi-line string value as a BEGIN/END block.
+      #
+      def serialize_block_value( indent )
+        t = "\t" * indent
+        inner = "\t" * ( indent + 1 )
+        body = value.split( "\n" ).map { |line| "#{inner}#{line}" }.join( "\n" )
+        return " : BEGIN\n#{body}\n#{t}END"
+      end
+
       #
       # Is the value a String?
       #
@@ -306,7 +338,7 @@ module Gloo
       # Get a list of message names that this object receives.
       #
       def self.messages
-        return %w[reload unload blank? contains? responds_to?]
+        return %w[save reload unload blank? contains? responds_to? doc]
       end
 
       #
@@ -356,6 +388,22 @@ module Gloo
         @engine.persist_man.unload self
       end
 
+      #
+      # Send the object the save message: tell it to save itself,
+      # rather than going through the save verb. Same rules as
+      # `save {path.to.object}` -- saves every file that owns a
+      # declaration in this object's root, or saves fresh to a default
+      # path if it isn't mapped to a file yet.
+      #
+      def msg_save
+        if self.root?
+          @engine.err 'Cannot save the root object.'
+          return
+        end
+
+        @engine.persist_man.save self.pn
+      end
+
       #
       # Send the object the reload message.
       # Note that this will only work for objects with file assoications.
@@ -406,6 +454,17 @@ module Gloo
         end
       end
 
+      #
+      # Get this object's documentation -- the comment block declared
+      # immediately above it in its source file, cleaned up. Puts the
+      # result into 'it' rather than printing, same as other
+      # value-returning messages (count, down, blank?, ...).
+      #
+      def msg_doc
+        @engine.heap.it.set_to self.doc
+        return self.doc
+      end
+
 
       # ---------------------------------------------------------------------
       #    Render

data/lib/gloo/core/parser.rb

@@ -21,7 +21,11 @@ module Gloo
       # Parse a command from the immediate execution context.
       #
       def parse_immediate( full_cmd )
-        # Break the full command into verb and params
+        # Drop an inline trailing comment first, then break the
+        # command into verb and params.
+        full_cmd = strip_comment( full_cmd )
+        return nil if full_cmd.strip.empty?
+
         cmd, params = split_params full_cmd
 
         # Params are the parenthetical part of the command at the end
@@ -35,6 +39,31 @@ module Gloo
         return nil
       end
 
+      #
+      # Remove an inline trailing comment: the first '#' that starts a
+      # word (at the start of the command, or right after whitespace)
+      # and is not inside a quoted string -- and everything after it.
+      #
+      # Left alone: a '#' inside single or double quotes (show 'a # b'),
+      # a '#' glued to preceding text (a URL fragment like
+      # http://x?id=1#frag), and a command with no such '#'. Object
+      # declaration values in a .gloo file never reach here -- they're
+      # split by LineSplitter, not the parser.
+      #
+      def strip_comment( full_cmd )
+        quote = nil
+        full_cmd.each_char.with_index do |ch, i|
+          if quote
+            quote = nil if ch == quote
+          elsif Gloo::Core::Tokens::QUOTE_CHARS.include?( ch )
+            quote = ch
+          elsif ch == '#' && ( i.zero? || full_cmd[ i - 1 ] =~ /\s/ )
+            return full_cmd[ 0...i ].rstrip
+          end
+        end
+        return full_cmd
+      end
+
       #
       # If additional params were provided, split them out
       # from the token list.

data/lib/gloo/core/tokens.rb

@@ -154,8 +154,9 @@ module Gloo
       # An inline call (invoke( ... ) / ~>( ... )) is checked for
       # first since it needs to be quote-aware in its own right (a
       # call's args can include a quoted string) - see
-      # find_call_range. Falls through to the original quote-then-
-      # plain-split handling, unchanged, when there's no call.
+      # find_call_range. Otherwise the first quoted run (whichever
+      # quote char opens first) becomes one token, and the rest is
+      # split on spaces.
       #
       def tokenize( str )
         range = find_call_range( str )
@@ -163,27 +164,52 @@ module Gloo
           tokenize( str[ 0...range.first ] ) if range.first.positive?
           @tokens << str[ range ]
           tokenize( str[ range.last + 1..-1 ] ) if range.last + 1 < str.length
-        elsif str.index( '"' )
-          i = str.index( '"' )
-          j = str.index( '"', i + 1 )
-          j ||= str.length
-
-          tokenize( str[ 0..i - 1 ] ) if i > 1
-          @tokens << str[ i..j ]
-          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
-        elsif str.index( "'" )
-          i = str.index( "'" )
-          j = str.index( "'", i + 1 )
-          j ||= str.length
-
-          tokenize( str[ 0..i - 1 ] ) if i > 1
-          @tokens << str[ i..j ]
-          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
+          return
+        end
+
+        qi, qc = first_quote( str )
+        if qi
+          close = closing_quote( str, qi, qc )
+          tokenize( str[ 0...qi ] ) if qi.positive?
+          @tokens << str[ qi..close ]
+          tokenize( str[ close + 1..-1 ] ) if close + 1 < str.length
         else
           str.strip.split( ' ' ).each { |t| @tokens << t }
         end
       end
 
+      #
+      # Find the first quote character in the string, of either kind
+      # -- returns [index, char], or [nil, nil] if there is none. The
+      # kind that opens first wins, so a " inside a '...' literal (and
+      # vice versa) is treated as ordinary content.
+      #
+      def first_quote( str )
+        found = nil
+        QUOTE_CHARS.each do |q|
+          i = str.index( q )
+          found = [ i, q ] if i && ( found.nil? || i < found[ 0 ] )
+        end
+        return found || [ nil, nil ]
+      end
+
+      #
+      # Index of the quote that closes the one opened at open_index.
+      # A backslash-escaped quote (\" or \') does not close the
+      # string. Returns str.length if it is never closed.
+      #
+      def closing_quote( str, open_index, quote_char )
+        i = open_index + 1
+        while i < str.length
+          ch = str[ i ]
+          return i if ch == quote_char
+
+          i += 1
+          i += 1 if ch == '\\'
+        end
+        return str.length
+      end
+
       #
       # Find the char range of the first top-level (not inside a
       # quoted string) invoke(...)/~>(...) call in str. Returns nil

data/lib/gloo/expr/l_string.rb

@@ -31,19 +31,23 @@ module Gloo
       end
 
       #
-      # Given a string with leading and trailing quotes,
-      # strip them out.
+      # Given a string with leading and trailing quotes, strip them
+      # out. A quote of the other kind inside needs nothing done to it
+      # ('{"x":1}' -> {"x":1}); an escaped quote of the same kind is
+      # unescaped ("say \"hi\"" -> say "hi").
       #
       def self.strip_quotes( str )
         if str.start_with?( '"' )
           str = str[ 1..-1 ]
           str = str[ 0..-2 ] if str.end_with?( '"' )
-          return str
+          return str.gsub( '\\"', '"' )
         elsif str.start_with?( "'" )
           str = str[ 1..-1 ]
           str = str[ 0..-2 ] if str.end_with?( "'" )
-          return str
+          return str.gsub( "\\'", "'" )
         end
+
+        return str
       end
 
       #