inventory 1.3.0 → 1.4.0

data/lib/inventory-1.0/dependencies.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+
+# Contains zero or more {Dependency dependencies} of the project.  Dependencies
+# can be {#+ added}, {#require}d, {#each enumerated}, and
+# {#add_to_gem_specification added to Gem specifications}.  Dependencies are
+# set up by passing a block to {#initialize} and calling {#development},
+# {#runtime}, and {#optional} inside it.
+#
+# @example Creating a List of Dependencies
+#   Dependencies.new{
+#     development 'inventory-rake', 1, 3, 0
+#     runtime 'bar', 1, 6, 0
+#   }
+class Inventory::Dependencies
+  include Enumerable
+
+  # Creates a new list of DEPENDENCIES and allows more to be added in the
+  # optionally #instance_exec’d block by calling {#development}, {#runtime},
+  # and {#optional} inside it.
+  #
+  # @param [Array<Dependency>] dependencies
+  # @yield [?]
+  def initialize(*dependencies)
+    @dependencies = dependencies
+    instance_exec(&Proc.new) if block_given?
+  end
+
+  private
+
+  # Add a {Development} dependency on project NAME, version MAJOR, MINOR,
+  # PATCH, along with any OPTIONS.
+  #
+  # @param (see Inventory::Dependency#initialize)
+  # @option (see Inventory::Dependency#initialize)
+  def development(name, major, minor, patch, options = {})
+    dependencies << Development.new(name, major, minor, patch, options)
+    self
+  end
+
+  # Add a {Runtime} dependency on project NAME, version MAJOR, MINOR, PATCH,
+  # along with any OPTIONS.
+  #
+  # @param (see Inventory::Dependency#initialize)
+  # @option (see Inventory::Dependency#initialize)
+  def runtime(name, major, minor, patch, options = {})
+    dependencies << Runtime.new(name, major, minor, patch, options)
+    self
+  end
+
+  # Add an {Optional} dependency on project NAME, version MAJOR, MINOR, PATCH,
+  # along with any OPTIONS.
+  #
+  # @param (see Inventory::Dependency#initialize)
+  # @option (see Inventory::Dependency#initialize)
+  def optional(name, major, minor, patch, options = {})
+    dependencies << Optional.new(name, major, minor, patch, options)
+    self
+  end
+
+  public
+
+  # @return [Dependencies] The dependencies of the receiver and those of OTHER
+  def +(other)
+    self.class.new(*(dependencies + other.dependencies))
+  end
+
+  # @overload
+  #   Enumerates the dependencies.
+  #
+  #   @yieldparam [Dependency] dependency
+  # @overload
+  #   @return [Enumerator<Dependency>] An Enumerator over the dependencies
+  def each
+    return enum_for(__method__) unless block_given?
+    dependencies.each do |dependency|
+      yield dependency
+    end
+    self
+  end
+
+  # {Dependency#require Require} each dependency in turn.
+  # @return [self]
+  def require
+    map{ |dependency| dependency.require }
+    self
+  end
+
+  # {Dependency#add_to_gem_specification Add} each dependency to a Gem
+  # specification.
+  # @param [Gem::Specification] specification
+  # @return [self]
+  def add_to_gem_specification(specification)
+    each do |dependency|
+      dependency.add_to_gem_specification specification
+    end
+    self
+  end
+
+  protected
+
+  attr_reader :dependencies
+end

data/lib/inventory-1.0/dependencies/development.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+# A development dependency is one that’s needed during development of a
+# project.  It won’t be required when the library is loaded, but it will be
+# added to a Gem specification as a development dependency.
+class Inventory::Dependencies::Development
+  include Inventory::Dependency
+
+  # Do nothing.
+  # @return [nil]
+  def require
+    nil
+  end
+
+  # Add the receiver as a development dependency to SPECIFICATION.
+  # @param [Gem::Specification] specification
+  # @return [self]
+  def add_to_gem_specification(specification)
+    specification.add_development_dependency name, gem_requirement
+    self
+  end
+end

data/lib/inventory-1.0/dependencies/optional.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+# An optional dependency is one that may or may not be needed during runtime.
+# It won’t be required when the library is loaded, but it will be added to a
+# Gem specification as a runtime dependency.
+class Inventory::Dependencies::Optional
+  include Inventory::Dependency
+
+  # Do nothing.
+  # @return [nil]
+  def require
+    nil
+  end
+end

data/lib/inventory-1.0/dependencies/runtime.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+
+# A runtime dependency is one that’s needed during runtime.  It’ll be required
+# when the library is loaded and added to a Gem specification as a runtime
+# dependency.
+class Inventory::Dependencies::Runtime
+  include Inventory::Dependency
+end

data/lib/inventory-1.0/dependency.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+# Some form of dependency of this project.  A dependency can be {#require}d,
+# {#add_to_gem_specification added to a gem specification}, and has various
+# information associated with it: {#name}, {#major}, {#minor}, {#patch}, and
+# {#feature}.
+module Inventory::Dependency
+  # Sets up a dependency on project NAME, version MAJOR, MINOR, PATCH, along
+  # with any OPTIONS.  Any methods may be overridden on the instance in the
+  # optionally #instance_exec’d block, if a dependency has any non-standard
+  # requirements.
+  #
+  # @param [String] name
+  # @param [Integer] major
+  # @param [Integer] minor
+  # @param [Integer] patch
+  # @param [Hash] options
+  # @option options [String] :feature ('%s-%s.0' % [name.gsub('-', '/'),
+  #   major]) The name of the feature to load
+  def initialize(name, major, minor, patch, options = {})
+    @name, @major, @minor, @patch = name, major, minor, patch
+    @altfeature = nil
+    @feature = options.fetch(:feature){
+      @altfeature = '%s-%d.0' % [name.gsub('-', '/'), major]
+      '%s-%d.0' % [name, major]
+    }
+    instance_exec(&Proc.new) if block_given?
+  end
+
+  # @return [Boolean] The result of requiring {#feature}
+  def require
+    super feature
+  rescue LoadError => e
+    if not e.respond_to? :path or e.path.end_with? feature
+      begin
+        super @altfeature
+      rescue LoadError
+        raise e
+      end
+    end
+  end
+
+  # Add the receiver as a runtime dependency to SPECIFICATION.
+  # @param [Gem::Specification] specification
+  # @return [self]
+  def add_to_gem_specification(specification)
+    specification.add_runtime_dependency name, gem_requirement
+    self
+  end
+
+  # @return [String] The version atoms on the form {#major}.{#minor}.{#patch}
+  def to_s
+    [major, minor, patch].join('.')
+  end
+
+  # @return [String] The name of the project that this dependency pertains to
+  attr_reader :name
+
+  # @return [Integer] The major version atom of the dependency
+  attr_reader :major
+
+  # @return [Integer] The minor version atom of the dependency
+  attr_reader :minor
+
+  # @return [Integer] The patch version atom of the dependency
+  attr_reader :patch
+
+  # @return [String] The name of the feature to {#require}
+  attr_reader :feature
+
+  private
+
+  # Returns the version range to use in {#add_to_gem_specification}.  The
+  # default is to use `~>` {#major}.{#minor} if {#major} > 0 and `~>`
+  # {#major}.{#minor}.{#patch} otherwise.  The reasoning here is that the
+  # version numbers are using [semantic versioning](http://semver.org) with the
+  # unfortunate use of minor and patch as a fake major/minor combination when
+  # major is 0, which is most often the case for Ruby projects.  Start your
+  # major versions at 1 and you’ll avoid this misuse of version numbers.
+  #
+  # @return [String]
+  def gem_requirement
+    '~> %s' % (major > 0 ? '%d.%d' % [major, minor] : to_s)
+  end
+end

data/lib/inventory-1.0/extension.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+# An extension represents a sub-directory under the “ext” directory in the
+# project.  Such a directory contains source files, usually written in C, that
+# interface with the underlying Ruby implementation, and possibly other
+# low-level systems, that aren’t otherwise available to Ruby code.
+#
+# For an inventory, an extension is a set of files that should be included in
+# the project and can contain multiple extensions.
+# [Inventory-Rake](http://disu.se/software/inventory-rake/) uses information
+# found in these extensions to compile them for use from Ruby code.
+class Inventory::Extension
+  # Creates an extension named NAME.  A block may be given that’ll be
+  # \#instance_exec’d in the extension being created so that various methods may
+  # be overridden to suit the extension being created.
+  #
+  # @param [String] name
+  # @yield [?]
+  def initialize(name)
+    @name = name
+    instance_exec(&Proc.new) if block_given?
+  end
+
+  # @return [String] The sub-directory into the project that contains the
+  #   extension, the default being `ext/{#name}`
+  def directory
+    'ext/%s' % name
+  end
+
+  # @return [String] The path into the project that contains the “extconf.rb”
+  #   file for the extension, the default being `{#directory}/extconf.rb`
+  def extconf
+    '%s/extconf.rb' % directory
+  end
+
+  # @return [String] The path into the project that contains the “depend”
+  #   file for the extension, the default being `{#directory}/depend`
+  # @note This file is usually created by hand by invoking `gcc -MM *.c >
+  #   depend`
+  def depend
+    '%s/depend' % directory
+  end
+
+  # @return [Array<String>] The source files that make up the extension, the
+  #   default being empty
+  def sources
+    []
+  end
+
+  # @return [Array<String>] The complete paths of {#sources} inside the package
+  def source_files
+    sources.map{ |e| '%s/%s' % [directory, e] }
+  end
+
+  # @return [Array<String>] The complete paths to any additional files
+  def additional_files
+    []
+  end
+
+  # @return [Array<String>] All files included in the package, that is
+  #   [{#extconf}, {#depend}] + {#source_files} + {#additional_files}
+  def files
+    [extconf, depend] + source_files + additional_files
+  end
+
+  # @return [Array<String>] Whatever {#files} returns
+  def to_a
+    files
+  end
+
+  # @return [String] The receiver’s {#name}
+  def to_s
+    name
+  end
+
+  def inspect
+    '#<%s: %s %s>' % [self.class, name, directory]
+  end
+
+  # @return [String] The receiver’s {#name}
+  attr_reader :name
+end

data/lib/inventory-1.0/version.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+class Inventory
+  Version = Inventory.new(1, 4, 0){
+    def dependencies
+      Dependencies.new{
+        development 'inventory-rake', 1, 4, 0
+        development 'lookout', 3, 0, 0
+        development 'lookout-rake', 3, 0, 0
+        development 'yard', 0, 8, 5
+      }
+    end
+
+    def package_libs
+      %w[dependency.rb
+         dependencies.rb
+         dependencies/development.rb
+         dependencies/optional.rb
+         dependencies/runtime.rb
+         extension.rb]
+    end
+  }
+end

data/test/unit/inventory-1.0.rb

@@ -1,6 +1,14 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
+  expect 'a/lib/a/version.rb' do
+    Inventory.new(1, 0, 0, 'a/lib/a/version.rb').path
+  end
+
+  expect 'a' do
+    Inventory.new(1, 0, 0, 'a/lib/a/version.rb').package_path
+  end
+
   expect 'a' do
     Inventory.new(1, 0, 0, 'a/lib/a/version.rb').package
   end

data/test/unit/inventory-1.0/version.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+end

metadata

@@ -1,107 +1,329 @@
 --- !ruby/object:Gem::Specification
 name: inventory
 version: !ruby/object:Gem::Version
-  version: 1.3.0
-  prerelease: 
+  version: 1.4.0
 platform: ruby
 authors:
 - Nikolai Weibull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2013-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inventory-rake
-  requirement: &2156387080 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
   type: :development
   prerelease: false
-  version_requirements: *2156387080
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: lookout
-  requirement: &2156385940 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *2156385940
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: lookout-rake
-  requirement: &2156385020 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *2156385020
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2156384360 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.5
   type: :development
   prerelease: false
-  version_requirements: *2156384360
-description: ! "                                   Inventory\n\n  Inventory allows
-  you to create inventories of your Ruby projects.  These\n  inventories can then
-  be used to load the project, create gem specifications\n  and gems, run unit tests,
-  and verify that the project’s content is what you\n  think it is.\n"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.5
+description: |2
+                                     Inventory
+
+    Inventory keeps track of the contents of your Ruby¹ projects.  Such an
+    inventory can be used to load the project, create gem specifications and
+    gems, run unit tests, compile extensions, and verify that the project’s
+    content is what you think it is.
+
+  ¹ See http://ruby-lang.org/
+
+  § Usage
+
+      Let’s begin by discussing the project structure that Inventory expects you
+      to use.  It’s pretty much exactly the same as the standard Ruby project
+      structure¹:
+
+        ├── README
+        ├── Rakefile
+        ├── lib
+        │   ├── foo-1.0
+        │   │   ├── bar.rb
+        │   │   └── version.rb
+        │   └── foo-1.0.rb
+        └── test
+            └── unit
+                ├── foo-1.0
+                │   ├── bar.rb
+                │   └── version.rb
+                └── foo-1.0.rb
+
+      Here you see a simplified version of a project called “Foo”’s project
+      structure.  The only real difference from the standard is that the main
+      entry point into the library is named “foo-1.0.rb” instead of “foo.rb” and
+      that the root sub-directory of “lib” is similarly named “foo-1.0” instead
+      of “foo”.  The difference is the inclusion of the API version.  This must
+      be the major version of the project followed by a constant “.0”.  The
+      reason for this is that it allows concurrent installations of different
+      major versions of the project and means that the wrong version will never
+      accidentally be loaded with require.
+
+      There’s a bigger difference in the content of the files.
+      ‹Lib/foo-1.0/version.rb› will contain our inventory instead of a String:
+
+        require 'inventory-1.0'
+
+        class Foo
+          Version = Foo.new(1, 4, 0){
+            def dependencies
+              super + Dependencies.new{
+                development 'baz', 1, 3, 0
+                runtime 'goo', 2, 0, 0
+                optional 'roo-loo', 3, 0, 0, :feature => 'roo-loo'
+              }
+            end
+
+            def package_libs
+              %w[bar.rb]
+            end
+          }
+        end
+
+      We’re introducing quite a few concepts at once, and we’ll look into each in
+      greater detail, but we begin by setting the ‹Version› constant to a new
+      instance of an Inventory with major, minor, and patch version atoms 1, 4,
+      and 0.  Then we add a couple of dependencies and list the library files
+      that are included in this project.
+
+      The version numbers shouldn’t come as a surprise.  These track the version
+      of the API that we’re shipping using {semantic versioning}².  They also
+      allow the Inventory#to_s method to act as if you’d defined Version as
+      ‹'1.4.0'›.
+
+      We then extend the definition of ‹dependencies› by adding another set of
+      dependencies to ‹super›.  ‹Super› includes a dependency on the version of
+      the inventory project that’s being used with this project, so you’ll never
+      have to list that yourself.  The other three dependencies are all of
+      different kinds: development, runtime, and optional.  A development
+      dependency is one that’s required while developing the project, for
+      example, a unit-testing framework, a documentation generator, and so on.
+      Runtime dependencies are requirements of the project to be able to run,
+      both during development and when installed.  Finally, optional dependencies
+      are runtime dependencies that may or may not be required during execution.
+      The difference between runtime and optional is that the inventory won’t try
+      to automatically load an optional dependency, instead leaving that up to
+      you to do when and if it becomes necessary.  By that logic, runtime
+      dependencies will be automatically loaded, which is a good reason for
+      having dependency information available at runtime.
+
+      The version numbers of dependencies also use semantic versioning, but note
+      that the patch atom is ignored unless the major atom is 0.  You should
+      always only depend on the major and minor atoms.
+
+      As mentioned, runtime dependencies will be automatically loaded and the
+      feature they try to load is based on the name of the dependency with a
+      “-X.0” tacked on the end, where ‘X’ is the major version of the dependency.
+      Sometimes, this isn’t correct, in which case the :feature option may be
+      given to specify the name of the feature.
+
+      You may also override other parts of a dependency by passing in a block to
+      the dependency, much like we’re doing for inventories.
+
+      The rest of an inventory will list the various files included in the
+      project.  This project only consists of one additional file to those that
+      an inventory automatically include (Rakefile, README, the main entry point,
+      and the version.rb file that defines the inventory itself), namely the
+      library file ‹bar.rb›.  Library files will be loaded automatically when the
+      main entry point file loads the inventory.  Library files that shouldn’t be
+      loaded may be listed under a different heading, namely “additional_libs”.
+      Both these sets of files will be used to generate a list of unit test files
+      automatically, so each library file will have a corresponding unit test
+      file in the inventory.  We’ll discuss the different headings of an
+      inventory in more detail later on.
+
+      Now that we’ve written our inventory, let’s set it up so that it’s content
+      gets loaded when our main entry point gets loaded.  We add the following
+      piece of code to ‹lib/foo-1.0.rb›:
+
+        module Foo
+          load File.expand_path('../foo-1.0/version.rb', __FILE__)
+          Version.load
+        end
+
+      That’s all there’s to it.
+
+      The inventory can also be used to great effect from a Rakefile using a
+      separate project called Inventory-Rake³.  Using it’ll give us tasks for
+      cleaning up our project, compiling extensions, installing dependencies,
+      installing and uninstalling the project itself, and creating and pushing
+      distribution files to distribution points.
+
+        require 'inventory-rake-1.0'
+
+        load File.expand_path('../lib/foo-1.0/version.rb', __FILE__)
+
+        Inventory::Rake::Tasks.define Foo::Version, :gem => proc{ |_, s|
+          s.author = 'Your Name'
+          s.email = 'you@example.com'
+          s.homepage = 'https://example.com/'
+        }
+
+        Inventory::Rake::Tasks.unless_installing_dependencies do
+          require 'lookout-rake-3.0'
+          Lookout::Rake::Tasks::Test.new
+        end
+
+      It’s ‹Inventory::Rake::Tasks.define› that does the heavy lifting.  It takes
+      our inventory and sets up the tasks mentioned above.  We also do some
+      additional customization of the gem specification.
+
+      As we want to be able to use our Rakefile to install our dependencies for
+      us, the rest of the Rakefile is inside the conditional
+      #unless_installing_dependencies, which, as the name certainly implies,
+      executes its block unless the task being run is the one that installs our
+      dependencies.  This becomes relevant when we set up Travis⁴ integration
+      next.  The only conditional set-up we do in our Rakefile is creating our
+      test task via Lookout-Rake⁵, which also uses our inventory to find the unit
+      tests to run when executed.
+
+      Travis integration is straightforward.  Simply put
+
+        before_script:
+          - gem install inventory-rake -v '~> VERSION' --no-rdoc --no-ri
+          - rake gem:deps:install
+
+      in the project’s ‹.travis.yml› file, replacing ‹VERSION› with the version
+      of Inventory-Rake that you require.  This’ll make sure that Travis installs
+      all development, runtime, and optional dependencies that you’ve listed in
+      your inventory before running any tests.
+
+      You might also need to put
+
+        env:
+          - RUBYOPT=rubygems
+
+      in your ‹.travis.yml› file, depending on how things are set up.
+
+  ¹ Ruby project structure: http://guides.rubygems.org/make-your-own-gem/
+  ² Semantic versioning: http://semver.org/
+  ³ Inventory-Rake: http://disu.se/software/inventory-rake/
+  ⁴ Travis: http://travis-ci.org/
+  ⁵ Lookout-Rake: http://disu.se/software/lookout-rake/
+
+  § API
+
+      If the guide above doesn’t provide you with all the answers you seek, you
+      may refer to the API¹ for more answers.
+
+  ¹ See http://disu.se/software/inventory/api/inventory/
+
+  § Financing
+
+      Currently, most of my time is spent at my day job and in my rather busy
+      private life.  Please motivate me to spend time on this piece of software
+      by donating some of your money to this project.  Yeah, I realize that
+      requesting money to develop software is a bit, well, capitalistic of me.
+      But please realize that I live in a capitalistic society and I need money
+      to have other people give me the things that I need to continue living
+      under the rules of said society.  So, if you feel that this piece of
+      software has helped you out enough to warrant a reward, please PayPal a
+      donation to now@disu.se¹.  Thanks!  Your support won’t go unnoticed!
+
+  ¹ Send a donation:
+    https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=now%40disu%2ese&item_name=Nikolai%20Weibull%20Software%20Services
+
+  § Reporting Bugs
+
+      Please report any bugs that you encounter to the {issue tracker}¹.
+
+    ¹ See https://github.com/now/inventory/issues
+
+  § Authors
+
+      Nikolai Weibull wrote the code, the tests, the documentation, and this
+      README.
 email: now@bitwi.se
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/inventory/dependency.rb
-- lib/inventory/dependencies.rb
-- lib/inventory/dependencies/development.rb
-- lib/inventory/dependencies/optional.rb
-- lib/inventory/dependencies/runtime.rb
+- lib/inventory-1.0/dependency.rb
+- lib/inventory-1.0/dependencies.rb
+- lib/inventory-1.0/dependencies/development.rb
+- lib/inventory-1.0/dependencies/optional.rb
+- lib/inventory-1.0/dependencies/runtime.rb
+- lib/inventory-1.0/extension.rb
 - lib/inventory-1.0.rb
-- lib/inventory/version.rb
-- test/unit/inventory/dependency.rb
-- test/unit/inventory/dependencies.rb
-- test/unit/inventory/dependencies/development.rb
-- test/unit/inventory/dependencies/optional.rb
-- test/unit/inventory/dependencies/runtime.rb
+- lib/inventory-1.0/version.rb
+- test/unit/inventory-1.0/dependency.rb
+- test/unit/inventory-1.0/dependencies.rb
+- test/unit/inventory-1.0/dependencies/development.rb
+- test/unit/inventory-1.0/dependencies/optional.rb
+- test/unit/inventory-1.0/dependencies/runtime.rb
+- test/unit/inventory-1.0/extension.rb
 - test/unit/inventory-1.0.rb
-- test/unit/inventory/version.rb
+- test/unit/inventory-1.0/version.rb
 - README
 - Rakefile
 homepage: https://github.com/now/inventory
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
-summary: Inventory allows you to create inventories of your Ruby projects.
+specification_version: 4
+summary: Inventory keeps track of the contents of your Ruby¹ projects.
 test_files: []