promising 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 493adbf314de9f4ead683c75a8f636473f87e1bb
+  data.tar.gz: 70b84824ed3a74f75c540ff345aad10714ae1794
+SHA512:
+  metadata.gz: dcdf423f31163f04d83de0bbbe2dd78a196a987dfc12e006a7e12c648f597bc6c87ae80dbd72158579cc7c16e3e206843d3974292c14c0367d3bf9119f8d9426
+  data.tar.gz: 0ca8863810f0ad45573a7aecff01326457a079b15037ad5a46ef74c2b5e72298b7d433709e998a1ef4f8d7aec23faf925dfd1c88707532a3b8e2e61ab65cca87

data/.gemspec

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby -rubygems
+# -*- encoding: utf-8 -*-
+
+GEMSPEC = Gem::Specification.new do |gem|
+  gem.version            = File.read('VERSION').chomp
+  gem.date               = File.mtime('VERSION').strftime('%Y-%m-%d')
+
+  gem.name               = 'promise'
+  gem.homepage           = 'http://promise.rubyforge.org/'
+  gem.license            = 'Public Domain' if gem.respond_to?(:license=)
+  gem.summary            = 'Promises and futures for Ruby'
+  gem.description = <<-EOF
+    A glimpse of a promising future in which Ruby supports delayed execution.
+    Provides global 'promise' and 'future' methods.
+  EOF
+  gem.rubyforge_project  = 'promising-future'
+
+  gem.authors            = ['Ben Lavender']
+  gem.email              = 'blavender@gmail.com'
+
+  gem.platform           = Gem::Platform::RUBY
+  gem.files              = %w(AUTHORS README UNLICENSE VERSION) + Dir.glob('lib/**/*.rb')
+  gem.bindir             = %q(bin)
+  gem.executables        = %w()
+  gem.default_executable = gem.executables.first
+  gem.require_paths      = %w(lib)
+  gem.extensions         = %w()
+  gem.test_files         = %w()
+  gem.has_rdoc           = false
+
+  gem.required_ruby_version      = '>= 1.8.2'
+  gem.requirements               = []
+  gem.add_development_dependency 'rspec', '>= 1.3.0'
+  gem.add_development_dependency 'yard' , '>= 0.5.8'
+  gem.post_install_message       = nil
+end

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.tmp
+.yardoc
+doc
+coverage
+pkg
+tmp
+*.gem
+**/*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.yardopts

@@ -0,0 +1,11 @@
+--title "Lazy and optimistic evaluation for Ruby"
+--output-dir doc/yard
+--protected
+--no-private
+--hide-void-return
+--markup markdown
+--readme README.md
+-
+AUTHORS
+UNLICENSE
+VERSION

data/AUTHORS

@@ -0,0 +1,3 @@
+* Ben Lavender <blavender@gmail.com> (Lead developer)
+* Arto Bendiken <arto.bendiken@gmail.com>
+Special thanks to Marc-André Lafortune for some excellent code review

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in promising.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 lifu
+
+MIT License
+
+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.md

@@ -0,0 +1,50 @@
+# Notice
+
+This gem is come from [Promise](https://rubygems.org/gems/promise)
+
+# Promising Future
+A glimpse of a promising future in which Ruby supports lazy evaluation.
+
+## Overview
+[Promises and futures][] both transparently defer the execution of a block.
+Promises evaluate the given block if and when its result is first needed.
+Futures evaluate the given block optimistically in another thread.
+
+    require 'promise'
+    require 'future'    # you can just require 'future' if using both
+    
+    x = promise { 1 + 2 }
+    y = future  { sleep 10 && 6 * 7 }
+    
+    puts x      #=> 3
+    sleep 5     # ... do work for 5 seconds ...
+    puts y      #=> 42, after blocking 5 seconds
+
+Note that this is pretty useless in Ruby's interactive shell `irb`, as it
+will eagerly evaluate everything as part of its read-eval-print loop,
+forcing promises and futures to yield their results.
+
+The library has been tested with Ruby 1.8.7, 1.9.1 and JRuby 1.5.0.
+YARD documentation is available at <http://promise.rubyforge.org/>
+
+## Classes
+
+ * {Promise}
+ * {Future}
+
+## Installation
+The library is distributed via [RubyGems](http://rubygems.org/):
+
+    $ gem install promise
+
+## Source
+The source is available at <http://github.com/fsword/future>
+
+## Author
+[Fsword](http://github.com/fsword)
+
+## Unlicense
+Promising Future is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+
+[Promises and futures]: http://en.wikipedia.org/wiki/Futures_and_promises

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/promising.rb

@@ -0,0 +1,35 @@
+require "promising/version"
+require "promising/promise"
+require "promising/future"
+
+module Kernel
+  ##
+  # Creates a new promise.
+  #
+  # @example Lazily evaluate an arithmetic operation
+  #   x = promise { 3 + 3 }
+  #
+  # @yield       []
+  #   A block to be lazily evaluated.
+  # @yieldreturn [Object]
+  #   The return value of the block will be the lazily evaluated value of the promise.
+  # @return      [Promise]
+  def promise(timeout:nil,&block)
+    ::Promising::Promise.new(timeout:timeout,&block)
+  end
+  
+  ##
+  # Creates a new future.
+  #
+  # @example Evaluate an operation in another thread
+  #   x = future { 3 + 3 }
+  #
+  # @yield       []
+  #   A block to be optimistically evaluated in another thread.
+  # @yieldreturn [Object]
+  #   The return value of the block will be the evaluated value of the future.
+  # @return      [Future]
+  def future(timeout:nil, &block)
+    ::Promising::Future.new(timeout:timeout, &block)
+  end
+end

data/lib/promising/future.rb

@@ -0,0 +1,51 @@
+require 'promising/promise'
+
+##
+# A delayed-execution result, optimistically evaluated in a new thread.
+#
+# @example
+#   x = future { sleep 5; 1 + 2 }
+#   # do stuff...
+#   y = x * 2     # => 6.  blocks unless 5 seconds has passed.
+#
+module Promising
+  class Future < defined?(BasicObject) ? BasicObject : Object
+    instance_methods.each { |m| undef_method m unless m =~ /^(__.*|object_id)$/ }
+  
+    ##
+    # Creates a new future.
+    #
+    # @yield  [] The block to evaluate optimistically.
+    # @see    Kernel#future
+    def initialize(timeout:nil,&block)
+      @promise = Promise.new(timeout:timeout,&block)
+      @thread  = ::Thread.new{@promise.__force__}
+    end
+  
+    ##
+    # The value of the future's evaluation.  Blocks until result available.
+    #
+    # @return [Object]
+    def __force__
+      @thread.join if @thread
+      @promise
+    end
+    alias_method :force, :__force__
+  
+    ##
+    # Does this future support the given method?
+    #
+    # @param  [Symbol]
+    # @return [Boolean]
+    def respond_to?(method, include_all=false)
+      :force.equal?(method) || :__force__.equal?(method) || __force__.respond_to?(method, include_all)
+    end
+  
+    private
+  
+    def method_missing(method, *args, &block)
+      __force__.__send__(method, *args, &block)
+    end
+  end
+end
+

data/lib/promising/promise.rb

@@ -0,0 +1,110 @@
+##
+# A delayed-execution promise.  Promises are only executed once.
+#
+# @example
+#   x = promise { factorial 20 }
+#   y = promise { fibonacci 10**6 }
+#   a = x + 1     # => factorial 20 + 1 after factorial calculates
+#   result = promise { a += y }
+#   abort ""      # whew, we never needed to calculate y
+#
+# @example
+#   y = 5
+#   x = promise { y = y + 5 }
+#   x + 5     # => 15
+#   x + 5     # => 15
+#
+require 'timeout'
+
+module Promising
+  class Promise < defined?(BasicObject) ? BasicObject : ::Object
+    NOT_SET = ::Object.new.freeze
+
+    instance_methods.each { |m| undef_method m unless m =~ /^(__.*|object_id)$/ }
+
+    ##
+    # Creates a new promise.
+    #
+    # @example Lazily evaluate a database call
+    #   result = promise { @db.query("SELECT * FROM TABLE") }
+    #
+    # @yield  [] The block to evaluate lazily.
+    # @see    Kernel#promise
+    def initialize(timeout:nil,&block)
+      if block.arity > 0
+        ::Kernel.raise ::ArgumentError, "Cannot store a promise that requires an argument"
+      end
+      @timeout = timeout
+      @block   = block
+      @mutex   = ::Mutex.new
+      @result  = NOT_SET
+      @error   = NOT_SET
+    end
+
+    ##
+    # Force the evaluation of this promise immediately
+    #
+    # @return [Object]
+    def __force__
+      @mutex.synchronize do
+        if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+          begin
+            if @timeout
+              ::Timeout.timeout(@timeout) do
+                @result = @block.call
+              end
+            else
+              @result = @block.call
+            end
+          rescue ::Exception => e
+            @error = e
+          end
+        end
+      end if @result.equal?(NOT_SET) && @error.equal?(NOT_SET)
+      # BasicObject won't send raise to Kernel
+      @error.equal?(NOT_SET) ? @result : ::Kernel.raise(@error)
+    end
+    alias_method :force, :__force__
+
+    ##
+    # Does this promise support the given method?
+    #
+    # @param  [Symbol, Boolean]
+    # @return [Boolean]
+    def respond_to?(method, include_all=false)
+      # If the promised object implements marshal_dump, Marshal will use it in
+      # preference to our _dump, so make sure that doesn't happen.
+      return false if :marshal_dump.equal?(method)
+
+      :_dump.equal?(method) ||  # for Marshal
+        :force.equal?(method) ||
+        :__force__.equal?(method) ||
+        __force__.respond_to?(method, include_all)
+    end
+
+    ##
+    # Method used by Marshal to serialize the object.  Forces evaluation.
+    #
+    # @param  [Integer] limit -- refer to Marshal doc
+    # @return [Object]
+    def _dump(limit)
+      ::Marshal.dump(__force__, limit)
+    end
+
+    ##
+    # Method used by Marshal to deserialize the object.
+    #
+    # @param  [Object]
+    # @return [Promise]
+    def self._load(obj)
+      ::Marshal.load(obj)
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      __force__.__send__(method, *args, &block)
+    end
+  end
+end
+

data/lib/promising/version.rb

@@ -0,0 +1,3 @@
+module Promising
+  VERSION = "0.3.1"
+end

data/promising.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'promising/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "promising"
+  spec.version       = Promising::VERSION
+  spec.authors       = ["fsword"]
+  spec.email         = ["li.jianye@gmail.com"]
+  spec.summary       = %q{A simple promise/future lib for ruby}
+  spec.description   = %q{Forking from bhuga/promising-future on github, so Version is started from 0.3.1}
+  spec.homepage      = "https://github.com/fsword/promising"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/future_spec.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+$:.unshift File.dirname(__FILE__)
+
+require 'time'
+require 'shared'
+module Promising
+  describe Future do
+
+    before :each do
+      @method = Kernel.method(:future)
+    end
+
+    if defined?(BasicObject)
+      it "should inherit from BasicObject if available, and not otherwise" do
+        expect(Future.ancestors).to include BasicObject
+      end
+    end
+
+    it_should_behave_like "A Promise"
+
+    it "should work in the background" do
+      start = Time.now
+      x = future { sleep 3; 5 }
+      middle = Time.now
+      y = x + 5
+      expect(y).to eq 10
+      finish = Time.now
+      expect(middle - start).to be_within(10**-2).of(0)
+      expect(finish - start).to be_within(10**-2).of(3)
+    end
+
+    it "should finished when timeout" do
+      # timeout
+      x = future(timeout:1){ sleep 2; 5 }
+      expect{x + 5}.to raise_error(::Timeout::Error)
+
+      # not timeout
+      x = future(timeout:2){ sleep 1; 5 }
+      expect(x + 5).to eq 10
+    end
+  end
+end

data/spec/promise_spec.rb

@@ -0,0 +1,72 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+$:.unshift File.dirname(__FILE__)
+
+require 'shared'
+
+module Promising
+  describe Promise do
+
+    before :each do
+      @method = Kernel.method(:promise)
+    end
+
+    if defined?(BasicObject)
+      it "should inherit from BasicObject if available, and not otherwise" do
+        expect(Promise.ancestors).to include BasicObject
+      end
+    end
+
+    it_should_behave_like "A Promise"
+
+    it "should delay execution" do
+      value = 5
+      x = @method.call { value = 10 ; value }
+      expect(value).to eq 5
+      y = x + 5
+      expect(y).to eq 15
+      expect(value).to eq 10
+    end
+
+    it "should delay execution of invalid code" do
+      expect {x = [ 1, x / 0 ]}.to raise_error
+      expect {x = [ 1, @method.call { x / 0 }]}.to_not raise_error
+    end
+
+    describe 'an object referencing a promise' do
+      class ClassResulting
+        attr_reader :value
+        def initialize(value)
+          @value = value
+        end
+        def marshal_dump
+          [@value]
+        end
+        def marshal_load(custom_struct)
+          @value = custom_struct[0]
+        end
+      end
+
+      class ClassReferencingAPromise
+        attr_reader :long_computation
+        def initialize
+          @long_computation = promise { ClassResulting.new(8) }
+        end
+      end
+
+      it 'can be marshaled and unmarshalled' do
+        clazz_ = Marshal.load(Marshal.dump(ClassReferencingAPromise.new))
+        expect(clazz_.long_computation.value).to eq 8
+      end
+
+      it "should finished when timeout" do
+        # timeout
+        x = promise(timeout:1){ sleep 2; 5 }
+        expect{x + 5}.to raise_error(::Timeout::Error)
+
+        # not timeout
+        x = promise(timeout:2){ sleep 1; 5 }
+        expect(x + 5).to eq 10
+      end
+    end
+  end
+end

data/spec/shared.rb

@@ -0,0 +1,140 @@
+require 'rspec'
+require 'promising'
+
+shared_examples_for "A Promise" do
+
+  it "should be createable" do
+    expect {x = @method.call { 3 + 5 }}.to_not raise_error
+  end
+
+  it "should not accept a block requiring arguments" do
+    expect {x = @method.call { | x | 3 + 5 }}.to raise_error
+  end
+
+  it "should be forceable" do
+    x = @method.call { 3 + 5 }
+    expect(x.__force__).to eq 8
+    expect(x).to eq 8
+  end
+
+  it "should respond_to? force" do
+    x = @method.call { 3 + 5 }
+    expect(x).to respond_to(:force)
+  end
+
+  it "should respond_to? __force__" do
+    x = @method.call { 3 + 5 }
+    expect(x).to respond_to(:__force__)
+  end
+
+  it "should respond_to? a method on the result" do
+    x = @method.call { 3 + 5 }
+    expect(x).to respond_to(:+)
+  end
+
+  it "should not respond_to? a method not on the result" do
+    x = @method.call { 3 + 5 }
+    expect(x).to_not respond_to(:asdf)
+  end
+
+  it "should evaluate to a value" do
+    expect(5 + @method.call { 1 + 2 }).to eq 8
+  end
+
+  it "should hold its value" do
+    y = 5
+    x = @method.call { y = y + 5 }
+    expect(x).to eq 10
+    expect(x).to eq 10
+  end
+
+  it "should only execute once" do
+    y = 1
+    x = @method.call { (y += 1) && false }
+    expect(x).to eq false
+    expect(x).to eq false
+    expect(y).to eq 2
+  end
+
+  it "should raise exceptions raised during execution when accessed" do
+    y = Object.new
+    y = @method.call { 1 / 0 }
+    expect { y.inspect }.to raise_error ZeroDivisionError
+    expect { y.inspect }.to raise_error ZeroDivisionError
+  end
+
+  it "should only execute once when execptions are raised" do
+    y = 1
+    x = @method.call { (y += 1) && (1 / 0) }
+    expect { x.inspect }.to raise_error ZeroDivisionError
+    expect { x.inspect }.to raise_error ZeroDivisionError
+    expect(y).to eq 2
+  end
+
+  it "should remain the same for an object reference" do
+    h = {}
+    x = Object.new
+    h[:test] = @method.call { x }
+    expect(h[:test]).to eq x
+  end
+
+  it "should be eql? for results" do
+    x = Object.new
+    y = @method.call { x }
+    expect(y).to eq x
+    # this would be ideal, but it can't be done in Ruby.  result
+    # objects that have a redefined #eql? should do fine.  
+    #x.should eql y
+  end
+
+  it "should be equal? for results" do
+    x = Object.new
+    y = @method.call { x }
+    expect(y).to eq x
+    # this would be ideal, but it can't be done in Ruby.
+    #x.should equal y
+  end
+
+  it "should be thread safe" do
+    x = @method.call { res = 1; 3.times { res = res * 5 ; sleep 1 } ; res}
+    threads = []
+    results = []
+    changeds = []
+    10.times do
+      threads << Thread.new do
+        changed = false
+        res = old_res = 125
+        10.times do |i|
+          old_res = res
+          res = x + 5
+          changed ||= res != old_res && i != 0
+          sleep 0.3
+        end
+        results << res
+        changeds << changed
+      end
+    end
+    threads.each do |t|
+      t.join
+    end
+    results.each do |result|
+      expect(result).to eq 130
+    end
+    changeds.each do |changed|
+      expect(changed).to eq false
+    end
+    expect(changeds.size).to eq 10
+  end
+
+  describe 'compatibility with Marshal' do
+    it 'should not respond_to? marshal_dump' do
+      x = @method.call { 3 + 5 }
+      expect(x).to_not respond_to(:marshal_dump)
+    end
+
+    it 'should respond_to? _dump' do
+      x = @method.call { 3 + 5 }
+      expect(x).to respond_to(:_dump)
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: promising
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- fsword
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Forking from bhuga/promising-future on github, so Version is started
+  from 0.3.1
+email:
+- li.jianye@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gemspec"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- AUTHORS
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- UNLICENSE
+- VERSION
+- lib/promising.rb
+- lib/promising/future.rb
+- lib/promising/promise.rb
+- lib/promising/version.rb
+- promising.gemspec
+- spec/future_spec.rb
+- spec/promise_spec.rb
+- spec/shared.rb
+homepage: https://github.com/fsword/promising
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple promise/future lib for ruby
+test_files:
+- spec/future_spec.rb
+- spec/promise_spec.rb
+- spec/shared.rb
+has_rdoc: