lazy_string 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7ef828d0d6e270b3c763849c5503bef8434ac156e487d517b528ec64d5c4ab4
+  data.tar.gz: 4cbba8428b89845019b048a1bbb700f2dcaeda71c853f849ef9462914e364293
+SHA512:
+  metadata.gz: ee16dc18e4c5035ee131cfa0c92e3bc1c5f6fcd1f7cacc5c9c3a8632c20fecc1683781c2498340e2a322c8c077eea2beea90238ac0bb3839a025c96fb136730c
+  data.tar.gz: '048e4f0fea648cb3655db2042b174ddc13e81d3f9933d166542e3bf61c15e1e005cf47a1b1594fb2833c88f2c1adad4c0b445a6e077a1d8ac62d95cdb75fc1f5'

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2018 Aaron Beckerman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.txt

@@ -0,0 +1,44 @@
+LazyString
+
+LazyString is a Ruby class for computing strings only when necessary -- that
+is, when #to_str or #to_s is called. This is useful when computing the string
+is expensive, but the string is unlikely to be used: an error message passed as
+a method argument, for example.
+
+Thanks to duck typing and Ruby's standard conversion protocols, you can pass
+an instance of LazyString to many methods that ask for a string.
+
+
+Usage
+
+LazyString is packaged as a RubyGem. Once you've installed it and required the
+file, you can create a lazy string by passing a block to LazyString.new:
+
+  ls = LazyString.new { "answer = #{expensive_computation}" }
+
+The block (and therefore expensive_computation) will not be called immediately.
+But later, if #to_str or #to_s is called on the lazy string, the block will be
+called with no arguments in order to create the real string.
+
+  # String interpolation calls #to_s automatically.
+  s = "Lazy string computes this: #{ls}"
+
+Once the string is computed, it will be saved, so any future invocations of
+#to_str or #to_s will not perform the computation again.
+
+
+Compatibility
+
+This works on version 1.8.7 and later of Matz's Ruby Interpreter. (At the time
+of this writing, 2.2.3 is the current version.)
+
+
+Author
+
+This software was written by Aaron Beckerman.
+
+
+License
+
+This software is distributed under the MIT License (also known as the Expat
+License). See the LICENSE.txt file for details.

data/lazy_string.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lazy_string"
+
+Gem::Specification.new do |gem|
+  gem.name = 'lazy_string'
+  gem.version = LazyString::VERSION
+  gem.authors = ['Aaron Beckerman']
+  gem.description = %q{This library provides LazyString, a class for computing strings only when necessary -- that is, when #to_str or #to_s is called. This is useful when computing the string is expensive but the string is unlikely to be used: an error message passed as a method argument, for example.}
+  gem.summary = %q{A Ruby library for lazily computing strings.}
+  gem.license = 'MIT'
+  gem.required_ruby_version = '>= 1.8.7'
+
+  gem.files = %w{LICENSE.txt README.txt lazy_string.gemspec lib/lazy_string.rb test/lazy_string_test.rb}
+  gem.executables = %w{}
+  gem.test_files = %w{test/lazy_string_test.rb}
+  gem.require_paths = %w{lib}
+end

data/lib/lazy_string.rb

@@ -0,0 +1,47 @@
+##
+# LazyString is a class for computing strings only when necessary -- that is,
+# when #to_str or #to_s is called. This is useful when computing the string is
+# expensive, but the string is unlikely to be used: an error message passed as
+# a method argument, for example.
+#
+class LazyString
+  ##
+  # The version string.
+  #
+  VERSION = '0.3.0'
+
+  ##
+  # Creates a new lazy string. The block argument will be saved for later use
+  # by #to_str. If no block argument is given, it will default to a block that
+  # returns an empty string.
+  #
+  def initialize(&block)
+    @block = block || lambda { '' }
+  end
+
+  ##
+  # A synonym for #to_str.
+  #
+  def to_s
+    to_str
+  end
+
+  ##
+  # Returns the computed string. It will compute the string by calling (with no
+  # arguments) the block passed to ::new. If the block's return value responds
+  # to the \to_str message, \to_str will be called on it to create the string.
+  # Otherwise, \to_s will be called on it. The computed string will be saved,
+  # so subsequent calls of this method will not cause the block to be called
+  # again.
+  #
+  def to_str
+    @str ||= begin
+      result = @block.call
+      if result.respond_to?(:to_str)
+        result.to_str
+      else
+        result.to_s
+      end
+    end
+  end
+end

data/test/lazy_string_test.rb

@@ -0,0 +1,55 @@
+require 'lazy_string'
+
+Class == LazyString.class or fail
+
+String == LazyString::VERSION.class or fail
+
+lambda do
+  obj = Object.new
+  LazyString.new { obj.freeze }
+  !obj.frozen? or fail
+end.call
+
+LazyString.new.respond_to?(:to_str) or fail
+
+LazyString.new.respond_to?(:to_s) or fail
+
+'' == LazyString.new.to_str or fail
+
+lambda do
+  obj = Object.new
+  def obj.to_str; 'to_str' end
+  def obj.to_s; 'to_s' end
+  'to_str' == LazyString.new { obj }.to_str or fail
+end.call
+
+lambda do
+  obj = Object.new
+  def obj.to_s; 'to_s' end
+  !obj.respond_to?(:to_str) or fail
+  'to_s' == LazyString.new { obj }.to_str or fail
+end.call
+
+'42' == LazyString.new { 2 * 21 }.to_s or fail
+
+lambda do
+  arr = []
+  ls = LazyString.new { arr << nil; 'foo' }
+  ls.to_str
+  'foo' == ls.to_str or fail
+  1 == arr.length or fail
+end.call
+
+lambda do
+  ex = StandardError.new
+  ls = LazyString.new { raise(ex) }
+  begin
+    ls.to_str
+  rescue
+    ex.equal?($!) or fail
+  else
+    fail
+  end
+end.call
+
+puts 'Test finished.'

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: lazy_string
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Aaron Beckerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-28 00:00:00.000000000 Z
+dependencies: []
+description: 'This library provides LazyString, a class for computing strings only
+  when necessary -- that is, when #to_str or #to_s is called. This is useful when
+  computing the string is expensive but the string is unlikely to be used: an error
+  message passed as a method argument, for example.'
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.txt
+- lazy_string.gemspec
+- lib/lazy_string.rb
+- test/lazy_string_test.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A Ruby library for lazily computing strings.
+test_files:
+- test/lazy_string_test.rb