fibonaccia 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b5052b89b8d22c7a2aa2f693d6833163bd9e471
+  data.tar.gz: 2bd4231043ff7f5a058cfff7c9a667c378bdac80
+SHA512:
+  metadata.gz: 7991693751b1582cbc22db692ba68d7986f67a96a35b0be260b9afbf55b216f20b8c7b96a7d9e7a96b3a5373d234a75c5cb7d5a546e4d721710a2c69aeb80715
+  data.tar.gz: a16b49e6134a7b897235363126930c9ba3e2c4110f20bda992e05ce0659526d9a2529b395b7daf5a1539af94935e427a9d6baf24ead4401419e1336551a64e8f

data/.tito/custom/gemtagger.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Copyright © (c) 2015 Ken Coar
+#
+# This software is licensed to you under the GNU General Public License,
+# version 2 (GPLv2). There is NO WARRANTY for this software, express or
+# implied, including the implied warranties of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
+# along with this software; if not, see
+# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+#
+# Based on
+# https://github.com/dgoodwin/tito/blob/master/src/tito/tagger/main.py
+#
+"""
+Code for tagging Ruby gems based on their <gemname>::VERSION constant.
+"""
+
+import os
+import re
+import rpm
+import shutil
+import subprocess
+import tempfile
+import textwrap
+import sys
+
+from string import Template
+
+from time import strftime
+
+from tito.common import (debug, error_out, run_command,
+                         find_file_with_extension, find_spec_file,
+                         get_project_name, get_latest_tagged_version,
+                         get_spec_version_and_release,
+                         replace_version, tag_exists_locally,
+                         tag_exists_remotely, head_points_to_tag,
+                         undo_tag, increase_version, reset_release,
+                         increase_zstream, BUILDCONFIG_SECTION,
+                         get_relative_project_dir_cwd)
+from tito.compat import *
+from tito.exception import TitoException
+from tito.config_object import ConfigObject
+from tito.tagger import VersionTagger
+
+class RubyGemTagger(VersionTagger):
+    """
+    Releases will be tagged by obtaining the value of the VERSION constant
+    from the gem.
+    """
+
+    def __init__(self, config=None, keep_version=False, offline=False, user_config=None):
+        VersionTagger.__init__(self, config=config)
+        self.gemspec_file_name = find_file_with_extension(suffix=".gemspec")
+        new_version = subprocess.check_output(
+            [
+                "ruby",
+                "-e",
+                "gspec = eval(File.read('" + self.gemspec_file_name + "')); " +
+                "print(gspec.version)"
+            ])
+        regex = re.compile("^(\d+(?:\.\d+)*)-?(.*)$")
+        match = re.match(regex, new_version)
+        if match:
+            debug("Deduced version='%s' release='%s'" % (match.group(1), match.group(2)))
+            self._use_version = match.group(1)
+            """ The release value is currently parsed, but unused. """
+            self._use_release = match.group(2)
+
+    def _tag_release(self):
+        """
+        Tag a new version of the package based upon the gem version.
+        """
+        self._make_changelog()
+        self._check_tag_does_not_exist(self._get_new_tag(self._use_version))
+        self._update_changelog(self._use_version)
+        self._update_setup_py(self._use_version)
+        self._update_package_metadata(self._use_version)
+        self._bump_version(force=True)
+
+    def release_type(self):
+        """ return short string which explain type of release.
+            e.g. 'minor release
+            Child classes probably want to override this.
+        """
+        return "release"
+
+
+class ReleaseTagger(VersionTagger):
+    """
+    Tagger which increments the spec file release instead of version.
+
+    Used for:
+      - Packages we build from a tarball checked directly into git.
+      - Satellite packages built on top of Spacewalk tarballs.
+    """
+
+    def _tag_release(self):
+        """
+        Tag a new release of the package. (i.e. x.y.z-r+1)
+        """
+        self._make_changelog()
+        new_version = self._bump_version(release=True)
+
+        self._check_tag_does_not_exist(self._get_new_tag(new_version))
+        self._update_changelog(new_version)
+        self._update_package_metadata(new_version)
+
+    def release_type(self):
+        """ return short string "minor release" """
+        return "minor release"
+
+

data/.tito/packages/.readme

@@ -0,0 +1,3 @@
+the .tito/packages directory contains metadata files
+named after their packages. Each file has the latest tagged
+version and the project's relative directory.

data/.tito/packages/rubygem-fibonaccia

@@ -0,0 +1 @@
+1.0.0-2 ./

data/.tito/tito.props

@@ -0,0 +1,6 @@
+[buildconfig]
+builder = tito.builder.Builder
+tagger = tito.tagger.ReleaseTagger
+lib_dir = .tito/custom/
+changelog_do_not_remove_cherrypick = 0
+changelog_format = %s (%ae)

data/.travis.yml

@@ -0,0 +1,30 @@
+--- 
+#
+# Try using the container mechanism.
+#
+sudo: false
+
+#
+# Package info.
+#
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+
+gemfile:
+  - Gemfile
+
+notifications:
+  email:
+    - RoUS@redhat.com
+
+before_install:
+  - gem install bundler
+  - gem install versionomy
+
+script:
+  - bundle exec rake features
+  - bundle exec rake yard

data/CONTRIBUTORS.md

@@ -0,0 +1,7 @@
+# CONTRIBUTORS:
+-------------
+
+* Ken Coar `<The.Rodent.of.Unusual.Size near GMail.Com>`
+  Initial creator, author, and maintainer.
+* [Michael Trout](https://www.patreon.com/foundup),
+  [Patreon sponsor](https://www.patreon.com/theRoUS)

data/Changelog

@@ -0,0 +1,3 @@
+```
+%changelog
+```

data/Details.md

@@ -0,0 +1,304 @@
+# Fibonaccia Details
+
+[![Gem Version](https://badge.fury.io/rb/fibonaccia.svg)](http://badge.fury.io/rb/fibonaccia)
+
+*As though there weren't enough Ruby gems for dealing with the
+Fibonacci sequence.. here's another one!*
+
+---
+### <a name="TOC">Table of Contents</a>
+
+* [Introduduction](#Introduction)
+* [Internals](#Internals)
+  * [Automatic Growth](#Automatic_Growth)
+* [Usage](#Usage)
+  * [Querying](#Querying)
+  * [Metadata](#Metadata)
+  * [Fibonacci-ness](#Fibonacci-ness)
+  * [Constants](#Constants)
+  * [Memory considerations](#Memory_considerations)
+* [Licence and Copyright](#Licence_and_Copyright)
+
+---
+
+## <a name="Introduction">Introduction</a>
+
+`Fibonaccia` is a very simple package for accessing the series of
+[Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number).
+It's implemented as a set of methods and constants wrapped in the `Fibonaccia`
+namespace.  All methods are module methods; it is *not* intended for
+use as a mix-in; although attempting to import it with `include` will
+do no harm, it won't accomplish much other than generating a warning
+on `$stdout`.
+
+`Fibonaccia` also provides the irrational constant
+[`PHI` (`φ`)](#Constants), which represents the
+[Golden Ratio](https://en.wikipedia.org/wiki/Golden_ratio) but which isn't in
+Ruby's own *Math* module.  `φ` is provided in both `Float` precision
+and as a `BigDecimal` ( *q.v.*) value.
+
+---
+
+<a name="Zero-based">**Note:**</a> `Fibonaccia` uses Ruby semantics
+for dealing with the series.  Most importantly, remember when querying
+it that it is **zero-based** -- that is, the first term has index **`0`**.
+
+---
+
+## <a name="Internals">Internals</a>
+
+`Fibonaccia` internally maintains an array of the Fibonacci sequence
+covering whatever terms have been accessed through its API.  That is,
+if you requested the one-thousandth term, the internal array would
+contain *at least* 1000 elements.
+
+This internal array is referred to as the **internal series** in the
+API documentation.  It is not directly accessible from outside the
+module; the {Fibonaccia.series} method returns a copy.
+
+### <a name="Automatic_Growth">Automatic Growth and Controlling the Size of the Series</a>
+
+If you refer to a term that does not [yet] exist in the internal
+series, the series will be automatically extended to include it.  It
+is never trimmed automatically, so memory consumption may be a concern
+-- expecially if you use the {Fibonaccia.series} method, since that
+will make an additional copy of the array.
+
+The following example illustrates this:
+
+```ruby
+Fibonaccia.series
+=> [ 0, 1, 1 ]
+Fibonaccia.terms
+=> 3
+Fibonaccia[12]
+=> 144
+Fibonaccia.series
+=> [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 ]
+Fibonaccia.terms
+=> 13
+Fibonaccia[8]
+=> 21
+Fibonaccia.series
+=> [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 ]
+Fibonaccia.terms
+=> 13
+```
+
+You can explicitly control the size of the internal series with the
+following methods:
+
+* {Fibonaccia.reset}
+  -- Resets the internal series to the basic default set of terms (see below).
+* {Fibonaccia.grow}( *n*)
+  -- Extends the internal series by *`n`* terms.
+* {Fibonaccia.shrink}( *n*)
+  -- Shrinks the internal series by removing *`n`* terms from the end.
+* {Fibonaccia.terms=} *n*
+  -- Sets the total number of terms in the internal series, which will
+     be grown or shrunk as needed.
+
+The internal series **always** includes the first three Fibonacci terms:
+`[ 0, 1, 1 ]`.  You cannot shrink or set the number of terms to fewer than
+3.
+
+## <a name="Usage">Usage</a>
+
+All of the methods of the public API are documented in the usual
+manner and places; this section is intended to provide a little more
+detail about them than just the bare calling sequence.
+
+### <a name="Slicing_Indexing">Slicing/Indexing</a>
+
+The internal series can be queried for single terms or slices of
+consecutive ones, using either the {Fibonaccia.slice} method or the
+shorthand (and possibly more readable) alias {Fibonaccia.[]}.
+
+You can request a specific term in the Fibonacci series:
+
+```ruby
+thirty_fifth = Fibonaccia[34]                   # remember: zero-based!
+```
+
+or a slice:
+
+```ruby
+fourth_through_seventh = Fibonaccia[3,3]        # remember: zero-based!
+fourth_through_seventh = Fibonaccia.slice(3,3)
+```
+
+If any of the terms you request are beyond the end of the internal
+series' current list of values, it will
+[automatically be grown](#Automatic_Growth)
+to include them.
+
+The normal `Array` method semantics are available; for example:
+
+```ruby
+Fibonaccia[-1]                                  # return the last term in the internal series
+Fibonaccia[-3,3]                                # return the last 3 terms
+```
+
+Most of the methods provided by the `Enumerable` mix-in ( *q.v.*) are
+available and apply to the internal series:
+
+```ruby
+Fibonaccia.reset
+Fibonaccia.last
+=> 1
+Fibonaccia.include?(144)
+=> false                                        # internal series not extended far enough yet
+Fibonaccia.terms = 13
+Fibonaccia.include?(144)
+=> true
+Fibonaccia.series.reduce(:+)                    # cumulative sum of internal series
+=> 376
+```
+
+Although it might seem appropriate to have `#include?` and `#member?`
+return `true` if their arguments exist somewhere in the Fibonacci
+series, that would conflict with their canonical meanings.
+Consequently, the
+'[is this arbitrary number in the Fibonacci series](#Fibonacci-ness)'
+test has its own method, {Fibonaccia.is_fibonacci?}.
+
+### <a name="Metadata">Metadata</a>
+
+Although the internal series is not directly accessible by user code,
+you can obtain a *copy* using the {Fibonaccia.series} method:
+
+```ruby
+series_so_far = Fibonaccia.series
+```
+
+Querying the {Fibonaccia.terms} attribute will return the number of
+terms currently in the internal series:
+
+```ruby
+term_count = Fibonaccia.terms
+```
+
+### <a name="Fibonacci-ness">Fibonacci-ness</a>
+or check to see if an arbitrary integer is a Fibonacci number:
+
+```ruby
+Fibonaccia.is_fibonacci?(354224848179261915075)
+=> true
+Fibonaccia.is_fibonacci?(354224848179261915075 + 1)
+=> false
+```
+
+If memory becomes a concern (see
+[Memory considerations](#Memory_considerations)),
+you can trim the internal series back to the initial three terms:
+
+```ruby
+Fibonaccia.reset
+Fibonaccia.terms
+=> 3
+```
+
+You can grow or shrink the list by any number of terms (although you
+**cannot** shrink it to fewer than 3):
+
+```ruby
+Fibonaccia.terms
+=> 3
+Fibonaccia.grow(20)
+=> 23
+Fibonaccia.terms
+=> 23
+Fibonaccia.shrink(10)
+=> 13
+Fibonaccia.terms
+=> 13
+```
+
+or you can set the size of the series to any arbitrary number of terms
+(again, you cannot set the series to fewer than 3 terms):
+
+```ruby
+Fibonaccia.reset
+Fibonaccia.terms
+=> 3
+Fibonaccia.terms = 2048
+Fibonaccia.terms
+=> 2048
+```
+
+### <a name="Constants">Constants</a>
+
+`Fibonaccia` provides only a single constant -- `PHI` (`φ`), the
+[Golden Ratio](https://en.wikipedia.org/wiki/Golden_ratio).  It
+is available as both a `Float` of implementation-specific precision
+and as an arbitrary-precision `BigDecimal` ( *q.v.*).
+
+There are two ways of accessing the constant:
+
+```ruby
+#
+# Using conventional Ruby constant syntax:
+#
+Fibonaccia::PHI                                 # Float
+Fibonaccia::PHI(false)                          # Float
+Fibonaccia::PHI(true)                           # BigDecimal
+#
+# Or as a method:
+#
+Fibonaccia.PHI                                  # Float
+Fibonaccia.PHI(false)                           # Float
+Fibonaccia.PHI(true)                            # BigDecimal
+```
+
+The latter syntax is recommended and preferred.
+
+### <a name="Memory_considerations">Memory considerations</a>
+
+Although the internal series is expanded only at need, the fact that
+it is never automatically trimmed back means that the more terms are
+requested, the more memory will be consumed by it.  Although this
+shouldn't be an issue unless you're dealing with thousands of terms,
+it *can* be a concern if you use the {Fibonaccia.series} method -- as
+each invocation thereof will return a *duplicate* of the internal
+series as it currently stands.  (That is, extending the internal
+series after making a copy with {Fibonaccia.series} does **not**
+result in the copy being extended as well.)
+
+You can use the {Fibonaccia.terms} method to determine how many terms
+are currently in the internal series, and so get an idea of how much
+of a resource impact an invocation of {Fibonaccia.series} would have.
+
+If you seed to work with the series itself rather than through the
+methods provided by the module, you can reduce the impact by obtaining
+the copy and then resetting the internal series back to its minimal
+usage:
+
+```ruby
+Fibonaccia.terms = 100000                       # internal series = 100,000 terms
+my_copy = Fibonaccia.series                     # plus a copy, also of 100,000 terms
+Fibonaccia.reset                                # now just your copy,
+                                                # plus 3 terms in the internal series
+```
+
+## <a name="Licence_and_Copyright">Licence and Copyright</a>
+
+`Fibonaccia` is copyright © 2015 by Ken Coar, and is made available
+under the terms of the Apache Licence 2.0:
+
+```
+   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.
+```
+
+Your distribution should include a copy of the `LICENCE.txt` file.