fibonaccia 1.0.2

data/features/step_definitions/fibonaccia-specific.rb

@@ -0,0 +1,36 @@
+Given(%r!the internal series (?:is|has been) reset$!) do
+  @exemplar.reset
+end
+
+When(%r!^I (?:query|invoke) (?:attribute|method) ["']?([\[\]_=A-Za-z0-9?]+)["']?\((.*?)\)["']?$!) do |attr,args|
+  args		= eval("[#{args}]")
+  @return_value	= wrap_exception {
+    @exemplar.send(attr.to_sym, *args)
+  }
+end
+
+When(%r!^I (?:query|invoke) (?:attribute|method) ["']?\[(.*)\]["']?$!) do |args|
+  args		= eval("[#{args}]")
+  @return_value	= wrap_exception {
+    @exemplar.send(:[], *args)
+  }
+end
+
+When(%r!^I (?:query|invoke) (?:attribute|method):$!) do |xval|
+  @return_value	= wrap_exception {
+    eval(xval)
+  }
+end
+
+When(%r!^I (?:query|invoke) (?:attribute|method) ["']?([_A-Za-z0-9?]+)["']?$!) do |attr|
+  @return_value	= wrap_exception {
+    @exemplar.send(attr.to_sym)
+  }
+end
+
+When(%r!^I set (?:attribute|the)?\s*["']?([_A-Za-z0-9]+)["']? to (.+?)$!) do |attr,val|
+  @return_value	= wrap_exception {
+    @exemplar.send((attr. + '=').to_sym, eval(val))
+  }
+end
+

data/features/step_definitions/streams.rb

@@ -0,0 +1,53 @@
+#
+# Cucumber steps dealing with checking the content of stdout/stderr.
+#
+streams		= %w( stdout stderr )
+streams.each do |sname|
+  Then(%r!^#{sname} should contain exactly (.+)$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).to eq(eval(xval))
+  end
+  Then(%r!^#{sname} should NOT contain exactly (.+)$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).not_to eq(eval(xval))
+  end
+  Then(%r!^#{sname} should contain exactly:$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).to eq(xval)
+  end
+  Then(%r!^#{sname} should NOT contain exactly:$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).not_to eq(xval)
+  end
+  Then(%r!^#{sname} should match (.*)$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).to match(Regexp.new(xval))
+  end
+  Then(%r!^#{sname} should match:$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).to match(Regexp.new(xval))
+  end
+  Then(%r!^#{sname} should NOT match (.*)$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).not_to match(Regexp.new(xval))
+  end
+  Then(%r!^#{sname} should NOT match:$!) do |xval|
+    sval	= instance_variable_get("@#{sname}_text".to_sym)
+    expect(sval).not_to match(Regexp.new(xval))
+  end
+end                             # streams.each do
+
+#
+# This should probably go into utility.rb -- except it explicitly
+# mentions stream stuff.
+#
+When(%r!^I include the (\S+) module$!) do |xval|
+  traffic		= capture_streams(:$stdout, :$stderr) {
+    invocation		= "class #{xval}_Includer ; include #{xval} ; end"
+    @return_value	= eval(invocation)
+  }
+  @stdout_text		= traffic[:$stdout]
+  @stderr_text		= traffic[:$stderr]
+  @return_value
+end
+

data/features/step_definitions/utility.rb

@@ -0,0 +1,58 @@
+#
+# Cucumber steps of semi-general utility.
+#
+
+#
+# Run a command and record any exception.
+#
+Given(%r!^I run system\("([^"]+)"\)$!) do |xval|
+  wrap_exception do
+    system(xval)
+  end
+end
+
+Then(%r!^the return value should be a kind of (\S+)$!) do |xval|
+  expect(@return_value.kind_of?(eval(xval))).to eq(true)
+end
+
+Then(%r!^the return value should be a kind of:$!) do |xval|
+  expect(@return_value.kind_of?(eval(xval))).to eq(true)
+end
+
+Then(%r!^the return value should NOT be a kind of (\S+)$!) do |xval|
+  expect(@return_value.kind_of?(eval(xval))).not_to eq(true)
+end
+
+Then(%r!^the return value should NOT be a kind of:$!) do |xval|
+  expect(@return_value.kind_of?(eval(xval))).not_to eq(true)
+end
+
+Then(%r!^the return value should be exactly (.*)$!) do |xval|
+  expect(@return_value).to eq(eval(xval))
+end
+
+Then(%r!^the return value should be exactly:$!) do |xval|
+  debugger
+  expect(@return_value).to eq(eval(xval))
+end
+
+Then(%r!^the return value should match ['"]?(.*)['"]?$!) do |xval|
+  expect(@return_value).to match(%r!#{xval}!)
+end
+
+Then(%r!^the return value should NOT match ['"]?(.*)['"]?$!) do |xval|
+  expect(@return_value).not_to match(%r!#{xval}!)
+end
+
+Then(%r!^the return value should include (\S+)$!) do |xval|
+  expect(@return_value.include?(eval(xval))).to eq(true)
+end
+
+Then(%r!^the return value should include:$!) do |xval|
+  expect(@return_value.include?(eval(xval))).to eq(true)
+end
+
+Then(%r!^the value of attribute ["']([_A-Za-z][_A-Za-z0-9]*)["'] should be exactly (["']?.*?["']?)$!) do |mname,xval|
+  attr_value	= wrap_exception { @exemplar.send(mname) }
+  expect(attr_value).to eq(eval(xval))
+end

data/features/support/env.rb

@@ -0,0 +1,165 @@
+Proc.new {
+  libdir = File.expand_path(File.join(__FILE__, '..', '..', '..', 'lib'))
+  $:.replace($: | [ libdir ])
+}.call
+
+#
+# Must load and start simplecov before any application code
+#
+require('json')
+require('versionomy')
+
+if (Versionomy.ruby_version >= Versionomy.parse('1.9'))
+  require('simplecov')
+  SimpleCov.start do
+    add_filter('/features/')
+    add_filter('/libexec')
+    add_filter('/lib/hll_active_record/')
+    add_filter('/test/')
+    add_filter('/tmp/')
+  end
+  SimpleCov.command_name(ARGV.join(' '))
+end
+
+require('fibonaccia')
+require('aruba/cucumber')
+
+#
+# Pick the right debugging gem.
+#
+if (Versionomy.ruby_version < Versionomy.parse('1.9.0'))
+  require('ruby-debug')
+elsif (Versionomy.ruby_version >= Versionomy.parse('2.0.0'))
+  require('byebug')
+else
+  require('debugger')
+end
+
+# @private
+#
+# This module provides helper methods for the Cucumber testing suite.
+#
+module Fibonaccia_TestSupport
+
+  #
+  # Suggested by from https://github.com/codegram/spinach
+  #
+
+  #
+  # Provide helpers to wrap IO streams by temporarily redirecting them
+  # to a StringIO object.
+  #
+
+  # @private
+  #
+  # Capture IO to one or more streams during block execution.
+  #
+  # @param [Array<Symbol,String>] stms
+  #  One or more stream identifiers to be captured.  Symbols like `:$stderr`
+  #  and strings like `"$stdout"` are acceptable.
+  #
+  # @yield
+  #  Block for which stream traffic should be captured.
+  #
+  # @return [String,Hash<<String,Symbol>=>String>]
+  #  If only one stream was specified, the result will be a simple string.
+  #
+  def capture_streams(*stms, &block)
+    if (stms.any? { |o| (! (o.kind_of?(String) || o.kind_of?(Symbol))) })
+      raise(ArgumentError, 'streams must be strings or symbols')
+    end
+    ovalues	= stms.inject({}) { |memo,stm|
+      stmname	= stm.to_s
+      stmobj	= eval(stmname)
+      unless (stmobj.kind_of?(IO))
+        raise(ArgumentError, "'#{stm.inspect}' is not an IO object")
+      end
+      stat	= {
+        :persistent	=> stmobj,
+        :temporary	=> StringIO.new,
+      }
+      eval("#{stmname} = stat[:temporary]")
+      memo[stm]		= stat
+      memo
+    }
+    #
+    # Make sure we restore the streams to their original settings if an
+    # exception gets raised.  We don't care about the exception, just
+    # making sure the streams are as they were when we were called.
+    #
+    rvalues		= stms.map { |o| {o => ''} }.reduce(:merge)
+    begin
+      yield
+    ensure
+      rvalues		= ovalues.inject({}) { |memo,(stm,stat)|
+        eval("#{stm.to_s} = stat[:persistent]")
+        memo[stm]		= stat[:temporary].string
+        memo
+      }
+    end
+    rvalues = rvalues.values.first if (rvalues.count == 1)
+    return rvalues
+  end                           # def capture_streams
+
+  # @private
+  #
+  # Capture standard output activity as a string.
+  #
+  # @yield
+  #  Block during the execution of which output is to be captured.
+  #
+  # @return [String]
+  #  Returns whatever was sent to `$stdout` during the block's execution.
+  #
+  def capture_stdout(&block)
+    return capture_stream(:$stdout, &block)
+  end                           # def capture_stdout
+
+  # @private
+  #
+  # Capture standard error activity as a string.
+  #
+  # @yield (see #capture_stdout)
+  #
+  # @return [String]
+  #  Returns whatever was sent to `$stderr` during the block's execution.
+  #
+  # @see #capture_stdout
+  # @see #capture_streams
+  #
+  def capture_stderr(&block)
+    return capture_stream(:$stderr, &block)
+  end                           # def capture_stderr
+
+  # @private
+  #
+  # Wrap the specified block in a rescue block so we can capture any
+  # exceptions.
+  #
+  # @yield
+  #   Yields to the block, passing no arguments.
+  #
+  # @return [nil,Object]
+  #   Returns the exit value of the block (whatever it may be), or
+  #   `nil` if an exception was caught.
+  #
+  def wrap_exception(&block)
+    @exception_raised	= nil
+    return_value	= nil
+    begin
+      #
+      # Do this in two steps in case the block itself puts something
+      # in the @return_value ivar.
+      #
+      result		= block.call
+      return_value	||= result
+    rescue => exc
+      @exception_raised	= exc
+      return_value	= nil
+    end
+    return return_value
+  end
+
+end                             # module Fibonaccia_TestSupport
+
+include Fibonaccia_TestSupport

data/features/support/hooks.rb

@@ -0,0 +1,12 @@
+Before() do
+  @exemplar		= Fibonaccia
+  @exception_raised	= nil
+  @dirs			= [
+                           'tmp/aruba',
+                          ]
+end                             # Before
+
+Before('@reset_before') do |s|
+  debugger
+  @exemplar.reset
+end

data/fibonaccia.gemspec

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+#--
+#   Copyright © 2015 Ken Coar
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#++
+
+Proc.new {
+  libdir = File.join(File.dirname(__FILE__), 'lib')
+  xlibdir = File.expand_path(libdir)
+  $:.unshift(xlibdir) unless ($:.include?(libdir) || $:.include?(xlibdir))
+}.call
+require('fibonaccia/version')
+
+Gem::Specification.new do |s|
+  s.required_ruby_version = ">= #{Fibonaccia::MINIMUM_RUBY_VERSION.to_s}"
+  if (s.respond_to?(:required_rubygems_version=))
+    s.required_rubygems_version = Gem::Requirement.new('>= 0')
+  end
+  s.name          	= 'fibonaccia'
+  s.version       	= Fibonaccia::VERSION
+  s.authors       	= [
+                           'Ken Coar',
+                          ]
+  s.email         	= [
+                           'kcoar@redhat.com',
+                          ]
+  s.summary       	= ("#{'%s-%s' % [ s.name, s.version, ]} - " +
+                           'Easy access to Fibonacci series and related things.')
+  s.description   	= <<-EOD
+Non-mixin module providing access to terms in the Fibonacci series.
+Fetch specific terms, slice the series, check to see if an arbitrary
+value is a Fibonacci number, etc.
+  EOD
+  s.homepage      	= 'https://github.com/RoUS/rubygem-fibonaccia'
+  s.license       	= 'Apache 2.0'
+
+  s.files         	= `git ls-files -z`.split("\x0")
+  #
+  # These cause problems when building RPMs, and we don't need 'em in
+  # the gem anyway.
+  #
+  s.files.delete('.yardopts')
+  s.files.delete('.gitignore')
+  s.executables   	= s.files.grep(%r!^bin/!) { |f| File.basename(f) }
+  s.test_files    	= s.files.grep(%r!^(test|spec|features)/!)
+  s.has_rdoc		= true
+  s.extra_rdoc_files	= [
+    'README.md',
+    'Details.md',
+  ]
+  s.rdoc_options	= [
+    '--main=README.md',
+    '--charset=UTF-8',
+  ]
+  s.require_paths 	= [
+    'lib',
+  ]
+
+  #
+  # Make a hash for our dependencies, since we're using some fancy
+  # code to declare them depending upon the version of the
+  # environment.
+  #
+  requirements_all	= {
+    'bigdecimal'	=> [],
+    'bundler'		=> [
+      '~> 1.7',
+    ],
+    'versionomy'	=> [
+      '>= 0.4.3',
+    ],
+  }
+  requirements_dev	= {
+    'cucumber'		=> [],
+    'rake'		=> [
+      '~> 10.0',
+    ],
+    'rdiscount'		=> [],
+    'yard'		=> [
+      '>= 0.8.2',
+    ],
+  }
+
+  requirements_all.each do |dep,*vargs|
+    args	= [ dep ]
+    args.push(*vargs) unless (vargs.count.zero? || vargs[0].empty?)
+    s.add_dependency(*args)
+  end
+
+  #
+  # The following bit of hanky-panky was adapted from uuidtools-2.1.3.
+  #
+  if (s.respond_to?(:specification_version=))
+    s.specification_version = 3
+
+    if (Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0'))
+      depmethod	= :add_development_dependency
+    else
+      depmethod	= :add_dependency
+    end
+  else
+    depmethod	= :add_dependency
+  end
+  requirements_dev.each do |dep,*vargs|
+    args	= [ dep ]
+    args.push(*vargs) unless (vargs.count.zero? || vargs[0].empty?)
+    s.send(depmethod, *args)
+  end
+
+end                             # Gem::Specification.new