depends-client 0.1

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright [2012] [Business Intelligence Associates, Inc.]
+
+   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.

data/README.md

@@ -0,0 +1,75 @@
+Depends
+=======
+Depends is a basic dependency management system _inspired_ by bundler. The basic idea is that you have some
+dependencies that need to be put in place in order to begin developing your application. Our use case is that we have
+a number of libraries such as OpenSSL, xsd, qt, etc... that we want to precompile and link the results at (our)
+application build time. We _don't_ want to check these into source countrol, but we want them to be versioned along-side
+source control.
+
+Introducting Depends
+--------------------
+Depends is quite simple.
+
+1. Install depends (I am assuming that ruby is already installed)
+
+```bash
+gem install depends-client
+```
+
+2. Define a Depends file at the root of your source repository. The format is as follows:
+
+    ```ruby
+
+    source :depends
+
+    depend 'Qt', :version => '4', :destination => 'External/Qt'
+    depend 'SevenZipSharp', :version => '4', :destination => 'External/SevenZipSharp'
+    depend 'Sqlite', :version => '4', :destination => 'External/Sqlite'
+    depend 'Xerces', :version => '4', :destination => 'External/Xerces'
+    depend 'Xsd', :version => '4', :destination => 'External/Xsd'
+
+    ```
+
+    _source_ defines that location of the depends server. Currently :local, :depends, or a string to some other depends
+    server, i.e. http://example.com.
+
+    _depend_ defines what the dependency is, the version to install and the path to unpack it to
+
+3. Execute Depends
+```bash
+depend
+```
+
+4. Add your Depends file to source control
+
+_We also recomend that you add depends destinations to your gitignore and hgignore files._
+
+Your done, packages are download, extracted and installed per the instructions in your gem file
+
+
+Uploading A Dependency
+----------------------
+This tutorial does not cover installing a depends server, but asuming that you have a depends server setup, adding a new
+dependency is simple.
+
+1. Install Depends
+
+    ```bash
+    gem install depends
+    ````
+2. Setup a directory that models what you want to upload. I.e. Create /tmp/openssl and add some files to it.
+3. Package and upload
+
+    ```bash
+    depend upload -s /tmp/openssl -d 'depends' -n "OpenSSL" -v '1.2.3b'
+    ```
+
+That's it, your package is created and uploaded to the depends server.
+
+The Future
+==========
+* Polish the client a bit further
+* Better error handling
+* Auto Updating of .gitignore and .hgignore files based on your Depends
+* Windows support
+* Rake tasks

data/bin/depend

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'depends'
+time = Benchmark.realtime do
+  begin
+    a = Depends::CommandFactory.build.new
+    a.run
+  rescue Depends::Exceptions::SubCommandMissing => e
+    Depends::Log.debug ("Exception: #{e.inspect}")
+    Depends::Log.fatal ("SubCommand is not defined #{e.message}")
+    Process.exit 1
+  end
+end
+
+Depends::Log.debug ":total_runtime => #{time*1000} milliseconds"
+
+

data/lib/depends/command_factory.rb

@@ -0,0 +1,31 @@
+module Depends
+  module CommandFactory
+    class << self
+      def build
+        subcommand_class
+      end
+
+      private
+      def subcommand_class
+        command_words = ARGV.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+        if command_words.empty?
+          return Depends::Commands::Install
+        end
+        command_words.collect! {|word| word.titleize }
+        command_options = []
+        subcommand_class = nil
+
+        while ( !subcommand_class ) && ( !command_words.empty? )
+          constant_case_name = command_words.join('')
+          command_options << constant_case_name
+          command_constant = Depends::Commands.constants.select { |i| i.eql? constant_case_name.to_sym}
+          unless command_constant.empty?
+            return "Depends::Commands::#{constant_case_name}".constantize
+          end
+          command_words.pop
+        end
+        raise Depends::Exceptions::SubCommandMissing, "Possible SubCommands: #{command_options} "
+      end
+    end
+  end
+end

data/lib/depends/commands/base.rb

@@ -0,0 +1,87 @@
+module Depends
+  module Commands
+    class Base
+
+      include Mixlib::CLI
+
+      def initialize
+        super
+
+        trap("TERM") do
+          Depends::Commands::Base.fatal!("SIGTERM received, stopping", 1)
+        end
+
+        trap("INT") do
+          Depends::Commands::Base.fatal!("SIGINT received, stopping", 2)
+        end
+
+        processor, platform, *rest = RUBY_PLATFORM.split("-")
+
+        unless platform == 'mswin32'
+          trap("QUIT") do
+            Depends::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
+          end
+
+          trap("HUP") do
+            Depends::Log.info("SIGHUP received, reconfiguring")
+            reconfigure
+          end
+        end
+
+      end
+
+      def reconfigure
+        parse_options
+        configure_depends
+        configure_logging
+      end
+
+      def run
+        reconfigure
+        setup_application
+        run_application
+      end
+
+
+      private
+      def configure_depends
+
+        if File.exist?('~/.depends')
+          Depends::Log.info "Loading config file from '~/.depends'"
+          Depends::Config.from_file('~/.depends')
+        end
+
+        FileUtils.mkdir_p Depends::Config.cache
+      end
+
+      def configure_logging
+        Depends::Log.formatter = Depends::Log::Formatter.new
+        Depends::Log.level = config[:log_level] || Logger::INFO
+      end
+
+      # Called prior to starting the application, by the run method
+      def setup_application
+        raise Depends::Exceptions::Application, "#{self.to_s}: you must override setup_application"
+      end
+
+      # Actually run the application
+      def run_application
+        raise Depends::Exceptions::Application, "#{self.to_s}: you must override run_application"
+      end
+
+      class << self
+
+        # Log a fatal error message to both STDERR and the Logger, exit the application
+        def fatal!(msg, err = -1)
+          Depends::Log.fatal(msg)
+          Process.exit err
+        end
+
+        def exit!(msg, err = -1)
+          Depends::Log.debug(msg)
+          Process.exit err
+        end
+      end
+    end
+  end
+end

data/lib/depends/commands/install.rb

@@ -0,0 +1,93 @@
+require 'benchmark'
+module Depends
+  module Commands
+    class Install < Depends::Commands::Base
+
+      banner "Install dependencies"
+
+      option :log_level,
+             :short => "-l LEVEL",
+             :long  => "--log_level LEVEL",
+             :description => "Set the log level (debug, info, warn, error, fatal)",
+             :proc => Proc.new { |l| l.downcase.to_sym }
+
+      def setup_application
+        Log.info "Installing dependencies..."
+      end
+
+      def run_application
+
+        time = Benchmark.realtime do
+          check_for_file
+        end
+        Depends::Log.debug ":check_for_file => #{time*1000} milliseconds"
+
+        time = Benchmark.realtime do
+          load_depends_file
+        end
+        Depends::Log.debug ":load_depends_file => #{time*1000} milliseconds"
+
+        time = Benchmark.realtime do
+          download_extract
+        end
+        Depends::Log.debug ":download_extract => #{time*1000} milliseconds"
+
+        time = Benchmark.realtime do
+          link
+        end
+        Depends::Log.debug ":link => #{time*1000} milliseconds"
+
+      end
+
+      private
+      def check_for_file
+        unless Dir.entries(Dir.pwd).include?('Depends')
+          Depends::Log.error "Missing Depends file"
+          exit 1
+        end
+      end
+
+      def load_depends_file
+        Depends::Log.info "Loading Dependencies..."
+        @def = Depends::DSL::Depend.evaluate('Depends')
+        unless @def.unmet_dependencies.empty?
+          Depends::Log.fatal "You have unmet dependencies in your sources, #{@def.unmet_dependencies.inspect}"
+          Process.exit 1
+        end
+      end
+
+
+      def download_extract
+        Depends::Log.info "Downloading and extracting missing dependencies..."
+        @def.dependencies.each do |dep|
+          cache_file =  File.join(Depends::Config.cache,File.basename(dep["file"]))
+          cache_directory = File.join(Depends::Config.cache,File.basename(dep["file"],'.zip'))
+
+          unless File.exist?(cache_file) # and Digest::SHA1.file(cache_file).to_s.eql? dep["sha1"]
+            Depends::Log.info "Downloading #{dep[:name]}..."
+            just_downloaded = true
+            dep[:source].download_depend_version(dep[:name],dep["number"])
+          end
+
+          if just_downloaded or not File.exist? cache_directory
+            Depends::Log.info "Extracting #{cache_file}"
+            Util.un_zip(cache_file,cache_directory) unless config[:dry_run]
+          end
+
+        end
+      end
+
+      def link
+        @def.dependencies.each do |dep|
+          source = File.join(Depends::Config.cache,File.basename(dep["file"],'.zip'))
+          base_dir = File.dirname(dep[:destination])
+          FileUtils.mkdir_p(base_dir) unless File.exist? base_dir
+          FileUtils.rm(dep[:destination]) if File.directory? dep[:destination]
+          Depends::Log.info "Linking #{source} to #{dep[:destination]}"
+          FileUtils.symlink(source, dep[:destination])
+        end
+      end
+
+    end
+  end
+end

data/lib/depends/commands/upload.rb

@@ -0,0 +1,85 @@
+module Depends
+  module Commands
+    class Upload < Depends::Commands::Base
+
+      class UploadConfig
+        extend(Mixlib::Config)
+      end
+
+      banner "Upload a dependency to a depends server"
+
+      option :source,
+             :short => "-s source",
+             :long  => "--source source",
+             :description => "Source directory for dependency",
+             :required => true
+
+      option :name,
+             :short => "-n name",
+             :long  => "--name name",
+             :description => "Dependency Name",
+             :required => true
+
+      option :version,
+             :short => "-v version",
+             :long  => "--version version",
+             :description => "Version to publish",
+             :required => true
+
+      option :destination,
+             :short => "-d destination",
+             :long  => "--destination destination",
+             :description => "Destination to publish depend to",
+             :default => 'https://depends.io',
+             :proc => Proc.new { |o|
+               Depends::Util.depends_source o
+             }
+
+      option :log_level,
+             :short => "-l LEVEL",
+             :long  => "--log_level LEVEL",
+             :description => "Set the log level (debug, info, warn, error, fatal)",
+             :proc => Proc.new { |l| l.downcase.to_sym }
+
+      def setup_application
+
+      end
+
+      def run_application
+        client = Depends::RestClient.new(config[:destination])
+
+        begin
+          @dep = client.get_depend(config[:name])
+        rescue Nestful::ResourceNotFound => e
+          @dep = client.create_depend(config[:name])
+        end
+
+        file = build_package
+        sha1 = Digest::SHA1.file(file).to_s
+
+        if @dep['versions'].select { |v| v.eql? config[:version] }.empty?
+          client.create_version(@dep['name'], :file => file, :sha1 => sha1, :version => config[:version])
+        end
+      end
+
+      private
+
+      def build_package
+        upload_dir = File.join(Depends::Config.cache,'upload')
+        FileUtils.mkdir_p upload_dir unless File.exist? upload_dir
+        dest_file = File.join(upload_dir, "#{config[:name]}-#{config[:version]}.zip")
+        FileUtils.rm dest_file if File.exist? dest_file
+        source_path = File.expand_path(config[:source])
+        Zip::ZipFile.open(dest_file, Zip::ZipFile::CREATE) { |zipfile|
+          Dir["#{source_path}/**/*"].each do |file|
+            relative_path = file.to_s.gsub(source_path, '')
+            relative_path.gsub! /^\//,''
+
+            zipfile.add relative_path, file
+          end
+        }
+        dest_file
+      end
+    end
+  end
+end

data/lib/depends/config.rb

@@ -0,0 +1,7 @@
+module Depends
+  class Config
+    extend(Mixlib::Config)
+
+    cache File.expand_path('~/.depends_cache')
+  end
+end

data/lib/depends/definition.rb

@@ -0,0 +1,45 @@
+module Depends
+
+  class Definition
+    
+    attr_reader :sources
+    attr_reader :dependencies
+    attr_reader :unmet_dependencies
+
+    def initialize(sources,dependencies, options ={})
+      @sources = sources
+      map(dependencies)
+    end
+
+    def map(deps)
+      @dependencies = []
+      @unmet_dependencies = []
+      Log.debug " :definition => #{@def.inspect}"
+      deps.each do |dep|
+        dependency_met = false
+        sources.each do |source|
+          begin
+            server_dep = source.get_dep_version(dep[:name], dep[:version] )
+            server_dep[:source] = source
+            server_dep[:destination] = dep[:destination]
+            server_dep[:name] = dep[:name]
+            Log.debug ":server_dep => #{server_dep}"
+            @dependencies << server_dep
+            dependency_met = true
+          rescue Nestful::ResourceNotFound => e
+            Log.debug ":resource_not_found => #{e.inspect}"
+          end
+        end
+
+        @unmet_dependencies << dep unless dependency_met
+      end
+
+
+    end
+
+    def inspect
+      "#{self} sources=> #{sources} dependencies => #{dependencies}"
+    end
+
+  end
+end

data/lib/depends/dsl/depend.rb

@@ -0,0 +1,52 @@
+module Depends
+  module DSL
+    class Depend
+      def self.evaluate(dependsfile)
+        depends = new
+        unless File.exist? dependsfile.to_s
+          raise IOError, "Depends files does not exist #{dependsfile}"
+        end
+
+        depends.instance_eval(File.read(dependsfile.to_s), dependsfile.to_s, 1)
+
+        depends.to_definition
+      end
+
+      def initialize
+        @sources         = []
+        @dependencies    = []
+      end
+
+      def depend(name,options = {})
+        version = options[:version] || :latest
+        unless options[:destination]
+          raise Exceptions::DslError, "Destination is a required attribute"
+        end
+
+        destination = options[:destination]
+
+
+        @dependencies.push(
+            HashWithIndifferentAccess.new ({  :name => name.downcase,
+                                              :version => version,
+                                              :destination => destination }))
+      end
+
+      def source(source, options = {})
+          depends_source Depends::Util.depends_source(source)
+      end
+
+      def to_definition
+        @sources.uniq!
+        raise DslError, "No source specified! Try source :bigdepends" unless @sources.length > 0
+        Depends::Definition.new(@sources, @dependencies)
+      end
+
+      private
+      def depends_source(source)
+        @sources << Depends::RestClient.new(source)
+      end
+
+    end
+  end
+end

data/lib/depends/exceptions.rb

@@ -0,0 +1,8 @@
+module Depends
+  module Exceptions
+    class DslError < StandardError; end
+    class Application < StandardError; end
+    class SubCommandMissing < StandardError; end
+    class DependencyNotMet < StandardError; end
+  end
+end

data/lib/depends/log/formatter.rb

@@ -0,0 +1,41 @@
+require 'logger'
+require 'time'
+
+module Depends
+  class Log
+    class Formatter < Logger::Formatter
+      @@show_time = false
+
+      COLOR_MAP = {'DEBUG' =>'0;37', 'INFO'=>'32', 'WARN'=>'33', 'ERROR'=>'31', 'FATAL'=>'31', 'UNKNOWN'=>'37'}
+
+      def self.show_time=(show=false)
+        @@show_time = show
+      end
+
+      def call(severity, time, progname, msg)
+        color = COLOR_MAP[severity]
+
+        if @@show_time
+          sprintf("\033[0;37m%s \033[0m[\033[#{color}m%s\033[0m]: \033[0m%s\n", time.rfc2822(), severity, msg2str(msg))
+        else
+          sprintf("\033[#{color}m%s\033[0;37m: \033[0m%s\n", severity, msg2str(msg))
+        end
+      end
+      
+      # Converts some argument to a Logger.severity() call to a string.  Regular strings pass through like
+      # normal, Exceptions get formatted as "message (class)\nbacktrace", and other random stuff gets 
+      # put through "object.inspect"
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{ msg.message } (#{ msg.class })\n" <<
+            (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end

data/lib/depends/log.rb

@@ -0,0 +1,6 @@
+module Depends 
+  class Log
+    extend Mixlib::Log
+  end
+end
+

data/lib/depends/rest_client.rb

@@ -0,0 +1,73 @@
+require 'nestful'
+module Depends
+  class RestClient
+
+    attr_accessor :source_url
+    attr_reader :cache
+
+    def initialize(source)
+      @source_url = source
+      cache_path = File.join(Depends::Config.cache,'rest',URI.parse(source).hostname )
+      Depends::Log.debug ":cache_path => #{cache_path}"
+      @cache = ActiveSupport::Cache::FileStore.new(cache_path, :expires_in => 1.day)
+    end
+
+    def create_version(name,options = {})
+      Nestful.post "#{source_url}/dependency/#{name}/versions", :format => :multipart, :timeout => 3600, :params => {:version => options[:version] , :file => File.open(options[:file]), :sha1 => options[:sha1] }
+    end
+
+    def create_depend(name)
+      Nestful.post "#{source_url}/dependency",  :format => :json, :params => {:name => name}
+    end
+
+    def get_depend(name)
+      uri = "#{source_url}/dependency/#{name}"
+      depend = cache.read(uri)
+      if depend.nil?
+        depend = Nestful.get uri, :format => :json
+        cache.write(uri,depend.to_json)
+      else
+        depend = ::MultiJson.load(depend)
+      end
+      depend
+    end
+
+    def download_depend_version(name,version)
+      dest_file = File.join(Depends::Config.cache, "#{name}-#{version}.zip")
+      file_buffer = Nestful.get "#{source_url}/dependency/#{name}/versions/#{version}/download" , :allow_redirect => true, :buffer => true
+      FileUtils.move file_buffer, dest_file
+      dest_file
+    end
+
+    def list(options = {})
+      params = {}
+
+      if params[:depends_list]
+        Nestful.post "#{source_url}/dependency/search", :params => params, :format => :json
+      else
+        Nestful.get "#{source_url}/dependency", :format => :json
+      end
+
+    end
+
+    def get_latest_version(name)
+      JSON.parse( Nestful.get "#{source_url}/dependency/#{name}/versions/latest" )
+    end
+
+
+    def get_dep_version(name,version)
+      Depends::Log.debug "[get] :ver => #{version}"
+      uri = "#{source_url}/dependency/#{name}/versions/#{version}"
+      depend = cache.read(uri)
+      if depend.nil?
+        depend = Nestful.get uri, :format => :json
+        cache.write(uri,depend.to_json)
+      else
+        depend = ::MultiJson.load(depend)
+      end
+      depend
+    end
+
+
+  end
+end

data/lib/depends/util.rb

@@ -0,0 +1,36 @@
+require 'zip/zip'
+
+module Depends
+  module Util
+
+    def self.un_zip(source,destination, options = {})
+      options.reverse_merge!({:overwrite => true})
+      Log.debug "Opening #{source}"
+      Zip::ZipFile.open(source) do |zip|
+        zip.each do |entry|
+          Log.debug (":entry => #{entry.name}")
+          path = ::File.join(destination, entry.name)
+          FileUtils.mkdir_p(::File.dirname(path))
+          if options[:overwrite] && ::File.exists?(path) && !::File.directory?(path)
+            Log.debug("Removing #{path}")
+            FileUtils.rm(path)
+          end
+          zip.extract(entry, path)
+        end
+      end
+
+    end
+
+    def self.depends_source(source)
+      source = source.downcase.to_sym if source.is_a? String
+      case source
+        when :local
+          "http://localhost:8080"
+        when :depends
+          "http://depends.io"
+        else
+          source
+      end
+    end
+  end
+end

data/lib/depends.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'json'
+require 'fileutils'
+require 'logger'
+require 'mixlib/log'
+require 'mixlib/config'
+require 'mixlib/cli'
+require 'digest/sha1'
+require 'multi_json'
+
+
+require 'depends/exceptions'
+require 'depends/config'
+require 'depends/util'
+require 'depends/rest_client'
+require 'depends/dsl/depend'
+require 'depends/definition'
+require 'depends/log/formatter'
+require 'depends/log'
+require 'depends/command_factory'
+
+require 'depends/commands/base'
+require 'depends/commands/install'
+require 'depends/commands/upload'

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: depends-client
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roby
+- Paul Morton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mixlib-log
+  requirement: &70141195519980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195519980
+- !ruby/object:Gem::Dependency
+  name: nestful
+  requirement: &70141195519180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195519180
+- !ruby/object:Gem::Dependency
+  name: mixlib-config
+  requirement: &70141195516600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195516600
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: &70141195516060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195516060
+- !ruby/object:Gem::Dependency
+  name: mixlib-cli
+  requirement: &70141195515520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195515520
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70141195543660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195543660
+- !ruby/object:Gem::Dependency
+  name: rack-cache
+  requirement: &70141195541840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195541840
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70141195539300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70141195539300
+description: 
+email:
+- croby@biaprotect.com
+- pmorton@biaprotect.com
+executables:
+- depend
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/depend
+- lib/depends/command_factory.rb
+- lib/depends/commands/base.rb
+- lib/depends/commands/install.rb
+- lib/depends/commands/upload.rb
+- lib/depends/config.rb
+- lib/depends/definition.rb
+- lib/depends/dsl/depend.rb
+- lib/depends/exceptions.rb
+- lib/depends/log/formatter.rb
+- lib/depends/log.rb
+- lib/depends/rest_client.rb
+- lib/depends/util.rb
+- lib/depends.rb
+- LICENSE
+- README.md
+homepage: http://github.com/BIAINC/depends
+licenses: []
+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.15
+signing_key: 
+specification_version: 3
+summary: A simple dependency manager
+test_files: []