fmt 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55fc16022e0fcb4b8815d6e7242106018e5786a9d610f38f8040cbb31cadb1a0
-  data.tar.gz: 185f056e8450fb1facfe15c7c637e9b49d2a19a2270689b8e12953c664393e10
+  metadata.gz: 7aded878eeff57ab27f37b6e76bc34281d94000c95c5d0ae77dde2bee5ab5989
+  data.tar.gz: 0d6390579afbfa629f0e53a127c25b60c04548b831e8ec13b9ebd8ed0880a238
 SHA512:
-  metadata.gz: 707ed8686b167ecba644d7a2358cf179670656cd9a7eb77f6d9408b7b8d5f07a9c204ca94fcd928e8630ca5633ce716c0fb600c4bca8d8e6992a1f682fcd76dc
-  data.tar.gz: 4b350d2ce4dd9ceeca3b7640d392b806c9698607bae33db99f18a39248898dbeef10100040f2d78dfc66f95d78839a982cf9a1cb3391129c70347f68f043bf4d
+  metadata.gz: 1235f7508b608760ce2f984cdcb321c01ac2a1cd3d7d5b9d1b586b45614e3b79c38bf900264b569fa469c17e34d2b6e1999984715a9b51c8caa792ee7d080aa9
+  data.tar.gz: '012095a10cbeac34f3457bf18ebe9135513a774984139cd1c7c300cd00d774590eff1826f7af137adbb32acd77f2eb8bffa1d52b48c579422fe43a2e7c3769cf'

data/README.md

@@ -1,6 +1,35 @@
+<p align="center">
+  <a href="http://blog.codinghorror.com/the-best-code-is-no-code-at-all/">
+    <img alt="Lines of Code" src="https://img.shields.io/badge/loc-347-47d299.svg" />
+  </a>
+  <a href="https://github.com/testdouble/standard">
+    <img alt="Ruby Style" src="https://img.shields.io/badge/style-standard-168AFE?logo=ruby&logoColor=FE1616" />
+  </a>
+  <a href="https://github.com/sponsors/hopsoft">
+    <img alt="Sponsors" src="https://img.shields.io/github/sponsors/hopsoft?color=eb4aaa&logo=GitHub%20Sponsors" />
+  </a>
+  <a href="https://twitter.com/hopsoft">
+    <img alt="Twitter Follow" src="https://img.shields.io/twitter/url?label=%40hopsoft&style=social&url=https%3A%2F%2Ftwitter.com%2Fhopsoft">
+  </a>
+</p>
+
 # Fmt
 
-Fmt is a simple template engine based on native Ruby String formatting mechanics.
+#### A simple template engine based on native Ruby String formatting mechanics
+
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+  - [Why?](#why)
+  - [Setup](#setup)
+  - [Usage](#usage)
+    - [Formatting](#formatting)
+    - [Filters](#filters)
+    - [Embeds](#embeds)
+  - [Sponsors](#sponsors)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
 
 ## Why?
 
@@ -9,7 +38,7 @@ I'm currenly using this to help build beautiful CLI applications with Ruby. Plus
 ## Setup
 
 ```
-bundle add rainbow # optional
+bundle add rainbow # <- optional
 bundle add fmt
 ```
 
@@ -35,7 +64,7 @@ Also, you can use Rainbow filters like `bold`, `cyan`, `underline`, et al. if yo
 
 **You can even [register your own filters](#filters).**
 
-### Rendering
+### Formatting
 
 Basic example:
 
@@ -43,8 +72,11 @@ Basic example:
 require "rainbow"
 require "fmt"
 
+Fmt.add_rainbow_filters
+
 template = "Hello %{name}cyan|bold"
-result = Fmt(template, name: "World")
+Fmt template, name: "World"
+
 #=> "Hello \e[36m\e[1mWorld\e[0m"
 ```
 
@@ -56,8 +88,11 @@ Mix and match native formatting with Rainbow formatting:
 require "rainbow"
 require "fmt"
 
+Fmt.add_rainbow_filters
+
 template = "Date: %{date}.10s|magenta"
-result = Fmt(template, date: Time.now)
+Fmt template, date: Time.now
+
 #=> "Date: \e[35m2024-07-26\e[0m"
 ```
 
@@ -69,6 +104,8 @@ Multiline example:
 require "rainbow"
 require "fmt"
 
+Fmt.add_rainbow_filters
+
 template = <<~T
   Date: %{date}.10s|underline
 
@@ -77,7 +114,8 @@ template = <<~T
   %{message}strip|green
 T
 
-result = Fmt(template, date: Time.now, name: "Hopsoft", message: "This is neat!")
+Fmt template, date: Time.now, name: "Hopsoft", message: "This is neat!"
+
 #=> "Date: \e[4m2024-07-26\e[0m\n\nGreetings, \e[1mHOPSOFT\e[0m\n\n\e[32mThis is neat!\e[0m\n"
 ```
 
@@ -92,16 +130,63 @@ The block accepts a string and should return a replacement string.
 require "rainbow"
 require "fmt"
 
-Fmt.add_filter(:repeat20) { |str| str * 20 }
+Fmt.add_rainbow_filters
+Fmt.add_filter(:ljust) { |val| "".ljust 14, val.to_s }
 
 template = <<~T
-  %{head}repeat20|faint
+  %{head}ljust|faint
   %{message}bold
-  %{tail}repeat20|faint
+  %{tail}ljust|faint
 T
 
-result = Fmt(template, head: "#", message: "Give it a try!", tail: "#")
-#=> "\e[2m####################\e[0m\n\e[1mGive it a try!\e[0m\n\e[2m####################\e[0m\n"
+Fmt template, head: "#", message: "Give it a try!", tail: "#"
+
+#=> "\e[2m##############\e[0m\n\e[1mGive it a try!\e[0m\n\e[2m##############\e[0m\n"
 ```
 
 ![CleanShot 2024-07-26 at 01 46 26@2x](https://github.com/user-attachments/assets/bd1d67c6-1182-428b-be05-756f3d330f67)
+
+### Embeds
+
+Templates can be embedded or nested within other templates... as deep as needed!
+Just wrap the embedded template in double curly braces: `{{EMBEDDED TEMPLATE HERE}}`
+
+```ruby
+require "rainbow"
+require "fmt"
+
+Fmt.add_rainbow_filters
+
+template = "%{value}lime {{%{embed_value}red|bold|underline}}"
+Fmt template, value: "Outer", embed_value: "Inner"
+
+#=> "\e[38;5;46mOuter\e[0m \e[31m\e[1m\e[4mInner\e[0m"
+```
+
+![CleanShot 2024-07-29 at 02 42 19@2x](https://github.com/user-attachments/assets/f67dd215-b848-4a23-bd73-72822cb7d970)
+
+```ruby
+template = <<~T
+  |--%{value}yellow|bold|underline
+  |  |--{{%{inner_value}green|bold|underline
+  |  |  |--{{%{deep_value}blue|bold|underline
+  |  |  |  |-- We're in deep!}}}}
+T
+
+Fmt template, value: "Outer", inner_value: "Inner", deep_value: "Deep"
+
+#=> "|--\e[33m\e[1m\e[4mOuter\e[0m\n|  |--\e[32m\e[1m\e[4mInner\e[0m\n|  |  |--\e[34m\e[1m\e[4mDeep\e[0m\n|  |  |  |-- We're in deep!\n"
+```
+
+![CleanShot 2024-07-29 at 02 45 27@2x](https://github.com/user-attachments/assets/1b933bf4-a62d-4913-b817-d6c69b0e7028)
+
+## Sponsors
+
+<p align="center">
+  <em>Proudly sponsored by</em>
+</p>
+<p align="center">
+  <a href="https://www.clickfunnels.com?utm_source=hopsoft&utm_medium=open-source&utm_campaign=fmt">
+    <img src="https://images.clickfunnel.com/uploads/digital_asset/file/176632/clickfunnels-dark-logo.svg" width="575" />
+  </a>
+</p>

data/lib/fmt/embed.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Fmt
+  class Embed
+    def initialize(string)
+      @string = string
+    end
+
+    attr_reader :string
+
+    def placeholder
+      "{{#{string}}}"
+    end
+
+    def format(**locals)
+      Fmt(string, **locals)
+    end
+  end
+end

data/lib/fmt/filter_groups/filter_group.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "monitor"
+require_relative "../filter"
+
+module Fmt
+  class FilterGroup
+    include Enumerable
+    include MonitorMixin
+
+    def initialize
+      super
+      @data = {}
+    end
+
+    def [](name)
+      synchronize { data[name.to_sym] }
+    end
+
+    def add(name, filter_proc = nil, &block)
+      raise ArgumentError, "filter_proc and block are mutually exclusive" if filter_proc && block
+      raise ArgumentError, "filter_proc must be a Proc" unless block || filter_proc.is_a?(Proc)
+      synchronize do
+        data[name.to_sym] = Fmt::Filter.new(name.to_sym, filter_proc || block)
+      end
+    end
+
+    def each(&block)
+      synchronize { data.each(&block) }
+    end
+
+    def fetch(name, default = nil)
+      synchronize { data.fetch name.to_sym, default }
+    end
+
+    def key?(name)
+      synchronize { data.key? name.to_sym }
+    end
+
+    alias_method :added?, :key?
+    alias_method :include?, :key?
+
+    def merge!(other)
+      synchronize { data.merge! other.to_h }
+      self
+    end
+
+    def to_h
+      data.dup
+    end
+
+    protected
+
+    attr_reader :data
+  end
+end

data/lib/fmt/filter_groups/rainbow_filter_group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "filter_group"
+
+module Fmt
+  class RainbowFilterGroup < FilterGroup
+    def initialize
+      super
+
+      if defined? Rainbow
+        methods = Rainbow::Presenter.public_instance_methods(false).select do |method|
+          Rainbow::Presenter.public_instance_method(method).arity == 0
+        end
+
+        method_names = methods
+          .map { |m| m.name.to_sym }
+          .concat(Rainbow::X11ColorNames::NAMES.keys)
+
+        method_names.each do |name|
+          add(name) { |string| Rainbow(string).public_send name }
+        end
+      end
+    rescue => error
+      puts "Error adding Rainbow filters! #{error.inspect}"
+    end
+  end
+end

data/lib/fmt/filter_groups/string_filter_group.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "filter_group"
+
+module Fmt
+  class StringFilterGroup < FilterGroup
+    def initialize
+      super
+
+      # rubocop:disable Layout/ExtraSpacing AllowForAlignment
+      add :capitalize,        ->(s) { s.capitalize }
+      add :chomp,             ->(s) { s.chomp }
+      add :chop,              ->(s) { s.chop }
+      add :downcase,          ->(s) { s.downcase }
+      add :lstrip,            ->(s) { s.lstrip }
+      add :reverse,           ->(s) { s.reverse }
+      add :rstrip,            ->(s) { s.rstrip }
+      add :shellescape,       ->(s) { s.shellescape }
+      add :strip,             ->(s) { s.strip }
+      add :succ,              ->(s) { s.succ }
+      add :swapcase,          ->(s) { s.swapcase }
+      add :undump,            ->(s) { s.undump }
+      add :unicode_normalize, ->(s) { s.unicode_normalize }
+      add :upcase,            ->(s) { s.upcase }
+      # rubocop:enable Layout/ExtraSpacing AllowForAlignment
+    end
+  end
+end

data/lib/fmt/formatter.rb

@@ -1,20 +1,26 @@
 # frozen_string_literal: true
 
 require "singleton"
-require_relative "filters"
+require_relative "filter_groups/filter_group"
+require_relative "filter_groups/rainbow_filter_group"
+require_relative "filter_groups/string_filter_group"
+require_relative "scanners"
 require_relative "transformer"
 
 module Fmt
   class Formatter
     include Singleton
 
-    OPEN = /%\{/
-    CLOSE = /\}/
-    KEY = /\w+(?=\})/
-    FILTERS = /[^\s]+(?=\s|$)/
-
     attr_reader :filters
 
+    def add_rainbow_filters
+      filters.merge! Fmt::RainbowFilterGroup.new.to_h
+    end
+
+    def add_filter(...)
+      filters.add(...)
+    end
+
     def format(string, **locals)
       result = string.to_s
       transformer = next_transformer(result)
@@ -31,31 +37,24 @@ module Fmt
 
     def initialize
       super
-      @filters = Fmt::Filters.new
+      @filters = Fmt::FilterGroup.new.merge!(Fmt::StringFilterGroup.new)
     end
 
     def next_transformer(string)
-      scanner = StringScanner.new(string)
+      embed_scanner = Fmt::EmbedScanner.new(string)
+      embed_scanner.scan
 
-      # 1. advance to the opening delimiter
-      scanner.skip_until(OPEN)
+      key_scanner = Fmt::KeyScanner.new(string)
+      key = key_scanner.scan
+      return nil unless key
 
-      # 2. extract the key to be transformed
-      key = scanner.scan(KEY)
-
-      # 3. advance to the closing delimiter
-      scanner.skip_until(CLOSE) if key
-
-      # 4. scan for the filters
-      filter_string = scanner.scan(FILTERS) if key
-
-      return nil if key.nil? || filter_string.nil?
-
-      mapped_filters = filter_string.split(Fmt::Filters::DELIMITER).map do |name|
-        filters.fetch name.to_sym, Fmt::Filter.new(name, name)
-      end
+      filter_scanner = Fmt::FilterScanner.new(key_scanner.rest, registered_filters: filters)
+      filter_string = filter_scanner.scan
 
-      Fmt::Transformer.new(key.to_sym, *mapped_filters, placeholder: "%{#{key}}#{filter_string}".strip)
+      Fmt::Transformer.new key.to_sym,
+        embeds: embed_scanner.embeds,
+        filters: filter_scanner.filters,
+        placeholder: "%{#{key}}#{filter_string}".strip
     end
   end
 end

data/lib/fmt/scanners/base_scanner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "strscan"
+
+module Fmt
+  class BaseScanner
+    extend Forwardable
+
+    def initialize(string)
+      @string_scanner = StringScanner.new(string)
+    end
+
+    def_delegators :string_scanner, :string, :rest
+    attr_reader :value
+
+    def performed?
+      !!@performed
+    end
+
+    def reset
+      @performed = false
+      string_scanner.reset
+    end
+
+    def scan
+      return if performed?
+      @performed = true
+      perform
+      value
+    end
+
+    protected
+
+    attr_reader :string_scanner
+
+    def perform
+      raise NotImplementedError
+    end
+  end
+end

data/lib/fmt/scanners/embed_scanner.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base_scanner"
+require_relative "../embed"
+
+module Fmt
+  class EmbedScanner < BaseScanner
+    def initialize(string, root: nil)
+      super(string)
+      @root ||= root || self
+      @embeds = []
+    end
+
+    def embeds
+      root? ? @embeds : root.embeds
+    end
+
+    attr_reader :root
+
+    def root?
+      root == self
+    end
+
+    protected
+
+    def includes_embed?(string)
+      string.match?(/[{]{2}/)
+    end
+
+    def next_scanner(string)
+      Fmt::EmbedScanner.new string, root: root
+    end
+
+    def scan_embeds(string)
+      return unless includes_embed?(string)
+
+      string = string[string.index(/[{]{2}/) + 2..]
+      scanner = next_scanner(string)
+      while (embed = scanner.scan)
+        embeds << Fmt::Embed.new(embed)
+        scanner = next_scanner(scanner.rest)
+      end
+    end
+
+    def perform?
+      !string.start_with?("}")
+    end
+
+    def perform
+      return unless perform?
+      scan_embeds string # <------------------------------------ extract embeds
+      string_scanner.scan_until(/[{]{2}/) # <------------------- advance to start
+      @value = string_scanner.scan_until(/[^}]*(?=[}]{2})/) # <- extract value
+    end
+  end
+end

data/lib/fmt/scanners/filter_scanner.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base_scanner"
+
+module Fmt
+  class FilterScanner < BaseScanner
+    DELIMITER = "|"
+
+    def initialize(string, registered_filters:)
+      @registered_filters = registered_filters
+      @filters = []
+      super(string)
+    end
+
+    alias_method :filter_string, :value
+    attr_reader :filters
+
+    protected
+
+    attr_reader :registered_filters
+
+    def perform
+      @value = string_scanner.scan(/[^\s%]+/) # <- extract value
+      return unless string_scanner.matched?
+
+      @filters = value.split(DELIMITER)&.map do |name|
+        registered_filters.fetch name.to_sym, Fmt::Filter.new(name, name)
+      end
+    end
+  end
+end

data/lib/fmt/scanners/key_scanner.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base_scanner"
+
+module Fmt
+  class KeyScanner < BaseScanner
+    protected
+
+    def perform
+      string_scanner.skip_until(/%[{]/) # <------------------------------ advance to start
+      @value = string_scanner.scan(/\w+/) if string_scanner.matched? # <- extract value
+      string_scanner.scan(/[}]/) if string_scanner.matched? # <---------- advance to end
+    end
+  end
+end

data/lib/fmt/scanners.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "scanners", "*.rb")].each { |file| require file }

data/lib/fmt/transformer.rb

@@ -2,37 +2,56 @@
 
 module Fmt
   class Transformer
-    def initialize(key, *filters, placeholder:)
+    def initialize(key, embeds:, filters:, placeholder:)
       @key = key
+      @embeds = embeds
       @filters = filters
       @placeholder = placeholder
     end
 
-    attr_reader :key, :filters, :placeholder, :proc_filters, :string_filters
+    attr_reader :key, :embeds, :filters, :placeholder, :proc_filters, :string_filters
 
     def transform(string, **locals)
-      return string if filters.none?
+      string = transform_embeds(string, **locals)
+
+      raise Fmt::Error, "Missing key! :#{key} <string=#{string.inspect} locals=#{locals.inspect}>" unless locals.key?(key)
 
-      raise Fmt::Error, "Missing key :#{key} in #{locals.inspect}" unless locals.key?(key)
       replacement = locals[key]
 
       filters.each do |filter|
         if filter.string?
           begin
-            replacement = format("%#{filter.value}", replacement)
-          rescue => error
-            raise Fmt::Error, "Invalid filter! #{filter.inspect} Check the spelling and verify that it's registered `Fmt.add_filter(:#{filter.name}, &block)`; #{error.message}"
+            replacement = sprintf("%#{filter.value}", replacement)
+          rescue
+            raise Fmt::Error, <<~MSG
+              Invalid filter! #{filter.inspect}
+              Verify it has been properly registered. SEE: Fmt.add_filter(:#{filter.name}, &block)
+            MSG
           end
         elsif filter.proc?
           begin
             replacement = filter.value.call(replacement)
           rescue => error
-            raise Fmt::Error, "Error in filter! #{filter.inspect} #{error.message}"
+            raise Fmt::Error, <<~MSG
+              Error in filter! #{filter.inspect}
+              #{error.message}
+            MSG
           end
         end
       end
 
-      string.sub placeholder, replacement
+      result = string.sub(placeholder, replacement)
+      defined?(Rainbow) ? Rainbow(result) : result
+    end
+
+    private
+
+    def transform_embeds(string, **locals)
+      while embeds.any?
+        embed = embeds.shift
+        string = string.sub(embed.placeholder, embed.format(**locals))
+      end
+      string
     end
   end
 end

data/lib/fmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fmt
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/fmt.rb

@@ -11,8 +11,16 @@ module Fmt
       Formatter.instance
     end
 
+    def filters
+      formatter.filters
+    end
+
+    def add_rainbow_filters
+      formatter.add_rainbow_filters
+    end
+
     def add_filter(...)
-      formatter.filters.add(...)
+      formatter.add_filter(...)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fmt
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Nate Hopkins (hopsoft)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-26 00:00:00.000000000 Z
+date: 2024-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amazing_print
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tocer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -145,9 +159,17 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/fmt.rb
+- lib/fmt/embed.rb
 - lib/fmt/filter.rb
-- lib/fmt/filters.rb
+- lib/fmt/filter_groups/filter_group.rb
+- lib/fmt/filter_groups/rainbow_filter_group.rb
+- lib/fmt/filter_groups/string_filter_group.rb
 - lib/fmt/formatter.rb
+- lib/fmt/scanners.rb
+- lib/fmt/scanners/base_scanner.rb
+- lib/fmt/scanners/embed_scanner.rb
+- lib/fmt/scanners/filter_scanner.rb
+- lib/fmt/scanners/key_scanner.rb
 - lib/fmt/transformer.rb
 - lib/fmt/version.rb
 homepage: https://github.com/hopsoft/fmt
@@ -171,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A simple template engine based on native Ruby String formatting mechanics

data/lib/fmt/filters.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-require_relative "filter"
-
-module Fmt
-  class Filters
-    include Enumerable
-    include MonitorMixin
-
-    DELIMITER = "|"
-
-    NATIVE_FILTERS = %i[
-      capitalize
-      chomp
-      chop
-      downcase
-      lstrip
-      reverse
-      rstrip
-      shellescape
-      strip
-      succ
-      swapcase
-      undump
-      unicode_normalize
-      upcase
-    ]
-
-    def initialize
-      super
-      @entries = {}
-
-      NATIVE_FILTERS.each do |name|
-        add(name) { |str| str.then(&:"#{name}") }
-      end
-
-      if defined? Rainbow
-        Rainbow::Presenter.public_instance_methods(false).each do |name|
-          next unless Rainbow::Presenter.public_instance_method(name).arity == 0
-          add(name) { |str| Rainbow(str).public_send(name) }
-        end
-
-        Rainbow::X11ColorNames::NAMES.keys.each do |name|
-          add(name) { |str| Rainbow(str).public_send(name) }
-        end
-      end
-    rescue
-      # noop
-    end
-
-    def each(&block)
-      entries.each(&block)
-    end
-
-    def add(name, filter = nil, &block)
-      raise ArgumentError, "filter and block are mutually exclusive" if filter && block
-      raise ArgumentError, "filter must be a Proc" unless block || filter.is_a?(Proc)
-      entries[name.to_sym] = Filter.new(name, filter || block)
-    end
-
-    alias_method :<<, :add
-
-    def [](name)
-      synchronize { entries[name.to_sym] }
-    end
-
-    def fetch(name, default = nil)
-      synchronize { entries.fetch name.to_sym, default }
-    end
-
-    private
-
-    attr_reader :entries
-  end
-end