rys-bundler 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c463d41d628123e4c1e09b444a903076cd13fda6436c2a25c9ef6ff3594cae5f
+  data.tar.gz: 3c4ee5081c2789809bcb9359a5253c6b135d700174c27d75229538b082a48e02
+SHA512:
+  metadata.gz: f7d2a5463ec8bd83f2465726ef929ab6c5b697b4a4f1465ea0eb9497ea6d9a2c98ab38a36c46d2b17fd2aca5f260f3fcecf6ec0af56ab1c8d4cc01df0b4eacea
+  data.tar.gz: 6fefbbd224b6b032ee867423b1b09ddedff97713fc84246a957bd289b9ba53a2f9b8a3bbd5fc11dc665999c44ad4c49dbb690226b7e65a8722c421f85d98331f

data/README.md

@@ -0,0 +1,6 @@
+# Rys::Bundler
+
+New plugin system/platform for Redmine, EasyRedmine and EasyProject.
+
+Go to the [rys wiki](https://github.com/easysoftware/rys/wiki/Bundler) to see more details.
+

data/lib/rys/bundler/command.rb

@@ -0,0 +1,51 @@
+module Rys
+  module Bundler
+    class Command
+
+      # For now only "rys" command is available
+      def exec(command, args)
+        if args.include?('-h') || args.include?('--help')
+          print_help_and_exit
+        end
+
+        # To avoid deleting options
+        if args.first.to_s.start_with?('-')
+          action = ''
+        else
+          action = args.shift.to_s
+        end
+
+        case action
+        when 'add'
+          Commands::Add.run(args)
+        when 'build', ''
+          Commands::Build.run(args)
+        when 'ibuild'
+          Commands::BuildInteractively.run(args)
+        when 'help'
+          print_help_and_exit
+        else
+          raise "Unknow action '#{action}'"
+        end
+      end
+
+      private
+
+        def print_help_and_exit
+          puts %{USAGE: bundle rys ACTION [options]}
+          puts %{}
+          puts %{COMMANDS:}
+          puts %{   add      Add a rys gem}
+          puts %{   build    Build rys gems (download for development or deployment)}
+          puts %{   ibuild   Build rys gems interactively}
+          puts %{}
+          puts %{OPTIONS:}
+          puts %{   -h, --help}
+          puts %{       Print this help}
+          puts %{}
+          exit
+        end
+
+    end
+  end
+end

data/lib/rys/bundler/commands/add.rb

@@ -0,0 +1,14 @@
+module Rys
+  module Bundler
+    module Commands
+      class Add
+
+        def self.run(args)
+          puts 'Comming soon'
+          exit 1
+        end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/commands/base.rb

@@ -0,0 +1,57 @@
+require 'open3'
+require 'ostruct'
+require 'optparse'
+require 'tty-prompt'
+
+module Rys
+  module Bundler
+    module Commands
+      class Base
+
+        def self.run(args)
+          raise NotImplementedError
+        end
+
+        def prompt
+          @prompt ||= TTY::Prompt.new
+        end
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def ui
+          ::Bundler.ui
+        end
+
+        def run
+          raise NotImplementedError
+        end
+
+        def command(command)
+          output, status = Open3.capture2e(command)
+
+          if !status.success?
+            ui.error output
+            exit 1
+          end
+        end
+
+        def get_redmine_plugin!
+          plugins_dir = Pathname.pwd.join('plugins')
+          plugins = Pathname.glob(plugins_dir.join('*/rys.rb'))
+
+          case plugins.size
+          when 0
+            raise 'There is no redmine plugin for rys gems. Please run "rails generate rys:redmine:plugin NAME"'
+          when 1
+            return plugins.first.dirname
+          else
+            raise 'There are more than one redmine plugin for rys plugins.'
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/commands/build.rb

@@ -0,0 +1,269 @@
+require 'date'
+require 'yaml'
+
+module Rys
+  module Bundler
+    module Commands
+      class Build < Base
+
+        COMMENT_PREFIX = '# RYS_BUILDER #'
+
+        attr_reader :options
+
+        def self.run(args)
+          options = OpenStruct.new
+          options.deployment = false
+          options.submodules = false
+          options.redmine_plugin = nil
+
+          OptionParser.new do |opts|
+            opts.banner = 'Usage: bundle rys build [options]'
+
+            opts.on('-d', '--deployment', 'Prepare gems for deployment') do |value|
+              options.deployment = value
+            end
+
+            # Quite a dangerous switch so do not add a short switch!!!
+            opts.on('--revert', 'Revert build (dangerous operation)') do |value|
+              options.revert = value
+            end
+
+            opts.on('-s', '--submodules', 'Add gems as submodules (experimental)') do |value|
+              options.submodules = value
+              abort('Not yet implemented')
+            end
+
+            opts.on('-r', '--redmine-plugin PATH', 'Redmine plugin for rys gems') do |value|
+              options.redmine_plugin = Pathname.new(value)
+            end
+
+            opts.on_tail('-h', '--help', 'Show this message') do
+              puts opts
+              exit
+            end
+
+            opts.on_tail('-v', '--version', 'Show version') do
+              puts ::Rys::Bundler::VERSION
+              exit
+            end
+          end.parse(args)
+
+          if options.deployment
+            klass = BuildDeployment
+          else
+            klass = BuildLocal
+          end
+
+          instance = klass.new(options)
+
+          if options.revert
+            instance.run_revert
+          else
+            instance.run
+          end
+        end
+
+        def initialize(options)
+          @options = options
+        end
+
+        def run
+          prepare_target
+          prepare_to_copy
+          copy_dependencies
+          comment_copied
+          save_report
+
+          ui.info ''
+          ui.info 'You may want run bundle install again (just for sure)'
+        end
+
+        def run_revert
+          prepare_target
+          prepare_to_delete
+          delete_dependencies
+          uncomment_deleted
+          delete_report
+        end
+
+        private
+
+          def short_filename(path)
+            path.each_filename.to_a.last(2).join('/')
+          end
+
+          def build_yml
+            @target.join('build.yml')
+          end
+
+          def print_gem_status(name, status)
+            ui.info (name + ' ').ljust(@dependency_ljust, '.') + " #{status}"
+          end
+
+          def prepare_target
+            if options.redmine_plugin&.directory?
+              @redmine_plugin = options.redmine_plugin
+            else
+              @redmine_plugin = get_redmine_plugin!
+            end
+
+            @target = @redmine_plugin.join(default_target_dir)
+            FileUtils.mkdir_p(@target)
+          end
+
+          def prepare_to_copy
+            all_dependencies = ::Bundler.load.dependencies
+            @dependencies = all_dependencies.select do |dependency|
+              dependency.groups.include?(:rys)
+            end
+            @dependency_ljust = @dependencies.map{|d| d.name.size }.max.to_i + 4
+          end
+
+          def prepare_to_delete
+            @dependency_ljust = build_report.keys.map{|d| d.size }.max.to_i + 4
+          end
+
+          # Copy/clone/symlink/... all dependencies into proper directory
+          def copy_dependencies
+            @copied_gems = []
+
+            @dependencies.each do |dependency|
+              source = dependency.source
+              path = @target.join(dependency.name)
+
+              # This could happend if gem is loaded from `@target`
+              if path.directory?
+                print_gem_status(dependency.name, 'already exist')
+                next
+              end
+
+              case source
+              when ::Bundler::Source::Git
+                build_gem_from_git(dependency, source, path)
+                @copied_gems << dependency.name
+
+              when ::Bundler::Source::Path
+                build_gem_from_path(dependency, source, path)
+                @copied_gems << dependency.name
+
+              else
+                print_gem_status(dependency.name, 'be resolved automatically')
+              end
+            end
+          end
+
+          def delete_dependencies
+            build_report.each do |gem_name, options|
+              path = @target.join(gem_name)
+
+              if File.symlink?(path)
+                FileUtils.rm(path)
+                print_gem_status(gem_name, 'symlink removed')
+              elsif File.directory?(path)
+                FileUtils.rm_rf(path)
+                print_gem_status(gem_name, 'directory removed')
+              else
+                print_gem_status(gem_name, 'not symlink or directory')
+              end
+            end
+          end
+
+          def comment_copied
+            if @copied_gems.size == 0
+              return
+            end
+
+            ui.info ''
+            ui.info pastel.bold('Commenting gems')
+            ::Bundler.definition.gemfiles.each do |gemfile|
+              gem_names = comment_gems_in(gemfile)
+
+              if gem_names.size > 0
+                gemfile_relative = gemfile.relative_path_from(::Bundler.root)
+                gem_names.each do |name|
+                  build_report[name] = { 'origin' => gemfile_relative.to_s }
+                end
+              end
+
+              ui.info "* #{short_filename(gemfile)}: #{gem_names.size} occurrences"
+            end
+          end
+
+          def uncomment_deleted
+            ui.info ''
+            ui.info pastel.bold('Uncommenting gems')
+
+            all_origins = Hash.new { |hash, origin| hash[origin] = [] }
+
+            build_report.each do |gem_name, options|
+              all_origins[options['origin']] << gem_name
+            end
+
+            all_origins.each do |origin, gem_names|
+              origin_gemfile = ::Bundler.root.join(origin)
+
+              if origin_gemfile.exist?
+                gem_names = uncomment_gems_in(origin_gemfile, gem_names)
+                ui.info "* #{short_filename(origin_gemfile)}: #{gem_names.size} occurrences"
+              else
+                ui.info "* #{short_filename(origin_gemfile)}: not exist"
+              end
+            end
+          end
+
+          def build_report
+            @build_report ||= begin
+              if build_yml.exist?
+                YAML.load_file(build_yml)
+              else
+                {}
+              end
+            end
+          end
+
+          def save_report
+            report  = %{# This file was generated by Rys::Bundler at #{Time.now}\n}
+            report << %{# Modify file at your own risk\n}
+            report << build_report.to_yaml
+
+            build_yml.write(report)
+          end
+
+          def delete_report
+            build_yml.exist? && build_yml.delete
+          end
+
+          def comment_gems_in(path)
+            @comment_gems_pattern ||= /^(\s*)([^#|\n]*gem[ ]+["'](#{@copied_gems.join('|')})["'])/
+
+            names = []
+            content = File.binread(path)
+            content.gsub!(@comment_gems_pattern) do
+              names << $3
+              %{#{$1}#{COMMENT_PREFIX} #{$2}}
+            end
+
+            File.open(path, 'wb') { |file| file.write(content) }
+            names.uniq!
+            names
+          end
+
+          def uncomment_gems_in(path, gem_names)
+            pattern = /^(\s*)#{COMMENT_PREFIX}[ ]*(gem[ ]+["'](#{gem_names.join('|')})["'])/
+
+            names = []
+            content = File.binread(path)
+            content.gsub!(pattern) do
+              names << $3
+              %{#{$1}#{$2}}
+            end
+
+            File.open(path, 'wb') { |file| file.write(content) }
+            names.uniq!
+            names
+          end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/commands/build_deployment.rb

@@ -0,0 +1,30 @@
+module Rys
+  module Bundler
+    module Commands
+      class BuildDeployment < Build
+
+        def default_target_dir
+          'gems'
+        end
+
+        def build_gem_from_git(dependency, source, path)
+          if source.send(:local?)
+            FileUtils.cp_r(source.path, path)
+            print_gem_status(dependency.name, 'copied')
+          else
+            command %{git clone --depth=1 --branch="#{source.branch}" "#{source.uri}" "#{path}"}
+            print_gem_status(dependency.name, 'clonned')
+          end
+
+          FileUtils.rm_rf(path.join('.git'))
+        end
+
+        def build_gem_from_path(dependency, source, path)
+          FileUtils.cp_r(source.path, path)
+          print_gem_status(dependency.name, 'copied')
+        end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/commands/build_interactively.rb

@@ -0,0 +1,14 @@
+module Rys
+  module Bundler
+    module Commands
+      class BuildInteractively
+
+        def self.run(args)
+          puts 'Comming soon'
+          exit 1
+        end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/commands/build_local.rb

@@ -0,0 +1,28 @@
+module Rys
+  module Bundler
+    module Commands
+      class BuildLocal < Build
+
+        def default_target_dir
+          'local'
+        end
+
+        def build_gem_from_git(dependency, source, path)
+          if source.send(:local?)
+            path.make_symlink(source.path)
+            print_gem_status(dependency.name, 'symlinked')
+          else
+            command %{git clone --branch="#{source.branch}" "#{source.uri}" "#{path}"}
+            print_gem_status(dependency.name, 'clonned')
+          end
+        end
+
+        def build_gem_from_path(dependency, source, path)
+          path.make_symlink(source.path)
+          print_gem_status(dependency.name, 'symlinked')
+        end
+
+      end
+    end
+  end
+end

data/lib/rys/bundler/hooks.rb

@@ -0,0 +1,292 @@
+##
+# Dependencies tree can look like this
+# (except it is even worse)
+#
+# You have to ensure that local dependencies (gemfile: `path: '...'`) are
+# resolved prior to remote dependencies (gemfile: `git: '...'`) because not
+# all users have rights for the repository (that is why packages are created).
+#
+#   gems.rb
+#   |-- easy_twofa (local)
+#   |   |-- rys (remote)
+#   |   `-- easy_core (remote)
+#   |-- easy_contacts (local)
+#   |   |-- easy_query (remote)
+#   |   |   |-- rys (remote)
+#   |   |   `-- easy_core(remote)
+#   |   |-- rys (remote)
+#   |   `-- easy_core (remote)
+#   |-- rys (local)
+#   |-- easy_core (local)
+#   |   `-- rys (remote)
+#   |-- tty-prompt (remote)
+#   `-- easy_query (local)
+#       |-- easy_core (remote)
+#       `-- rys (remote)
+#
+module Rys
+  module Bundler
+    module Hooks
+
+      # Recursively searches for dependencies
+      # If there will be same dependencies => first won
+      #
+      # == Arguments:
+      # dependencies:: Array of dependencies which should be resolved
+      # new_dependencies:: All dependencies from resolving
+      #                    Array is in-place modified
+      # resolved_dependencies:: Already resolved dependencies
+      #                        For preventing loops
+      #
+      def self.resolve_rys_dependencies(dependencies, new_dependencies, resolved_dependencies)
+        dependencies = prepare_dependencies_for_next_round(dependencies, resolved_dependencies)
+
+        # Resolving is done in next round
+        next_dependencies_to_resolve = []
+
+        dependencies.each do |dependency|
+          # To allow resolving
+          dependency.source.remote!
+
+          # Ensure gem (downloaded if necessary)
+          dependency.source.specs
+
+          # Get dependencies from this file using rys group
+          dependencies_rb = dependency.source.path.join('dependencies.rb')
+
+          if dependencies_rb.exist?
+            definition = ::Bundler::Dsl.evaluate(dependencies_rb, ::Bundler.default_lockfile, true)
+            rys_group_dependencies = definition.dependencies.select{|dep| dep.groups.include?(:rys) }
+
+            new_dependencies.concat(rys_group_dependencies)
+            next_dependencies_to_resolve.concat(rys_group_dependencies)
+          end
+
+          resolved_dependencies << dependency
+          # add_source_definition(dependency, ::Bundler.definition)
+        end
+
+        if next_dependencies_to_resolve.size > 0
+          resolve_rys_dependencies(next_dependencies_to_resolve, new_dependencies, resolved_dependencies)
+        end
+      end
+
+      # Be careful!!!
+      # There is a lot of possibilities for gem definition
+      #
+      #   1. Normal gem
+      #   2. Gem on git (download)
+      #   3. Gem on git (not-downloaded)
+      #   4. Gem on git locally overriden
+      #   5. Gem on local disk
+      #
+      def self.before_install_all(dependencies)
+        new_dependencies = []
+        resolved_dependencies = []
+        resolve_rys_dependencies(dependencies, new_dependencies, resolved_dependencies)
+
+        # Select only missing dependencies so user can
+        # rewrite each dependecny in main gems.rb
+        new_dependencies = new_dependencies.uniq(&:name)
+        new_dependencies.reject! do |dep1|
+          dependencies.any? do |dep2|
+            dep1.name == dep2.name && !dep2.groups.include?(:__dependencies__)
+          end
+        end
+
+        # Adding sources from new dependecies
+        # Needef for Path or Git
+        new_dependencies.each do |dependency|
+          next if !dependency.source
+          sources = ::Bundler.definition.send(:sources).send(:source_list_for, dependency.source)
+          sources << dependency.source
+        end
+
+        ::Bundler.ui.info "Added #{new_dependencies.size} new dependencies"
+
+        # Concat them to main Bundler.definition.dependencies
+        dependencies.concat(new_dependencies)
+
+        # Save them for Bundler.require (rails config/boot.rb)
+        save_new_dependencies(new_dependencies)
+
+        # To ensure main bundler download plugins
+        ::Bundler.definition.instance_eval do
+          @dependency_changes = true
+          # @local_changes = converge_locals
+        end
+      end
+
+      def self.rys_gemfile(dsl)
+        # Loading dependencies brings some troubles. For example if main
+        # app add a gem which already exist as dependencies. There could
+        # be conflicts. To avoid some of problems - dependencies are
+        # loaded only if there is not a lock file (bundler wasn't
+        # launched or user want force install).
+        return if !::Bundler.root.join('gems.locked').exist? && !::Bundler.root.join('Gemfile.lock').exist?
+
+        if gems_dependencies_rb.exist?
+          # Mark gems as dependencies to be rewritten in a hook
+          # Because you dont know if:
+          #   - gems are loaded for rails
+          #   - running bundle install
+          #   - bundle exec
+          #   - or something else
+          dsl.group(:__dependencies__) do
+            dsl.eval_gemfile(gems_dependencies_rb)
+          end
+        end
+      end
+
+      # Load gems from dummy path
+      # Conflicts are ingnored
+      #
+      def self.rys_load_dummy(dsl, dummy_path=nil)
+        possible_app_dirs = [
+          dummy_path,
+          ENV['DUMMY_PATH'],
+          ::Bundler.root.join('test/dummy')
+        ]
+
+        possible_app_dirs.each do |dir|
+          next if !dir
+          next if !File.directory?(dir)
+
+          ['Gemfile', 'gems.rb'].each do |gems_rb|
+            gems_rb = File.expand_path(File.join(dir, gems_rb))
+
+            if File.exist?(gems_rb)
+              dsl.instance_eval do
+
+                # Patch method `gem` to avoid duplicit definition
+                # For example you can test rys 'ondra' but its
+                # already included in main app gemfile.
+                if is_a?(::Bundler::Plugin::DSL)
+                  # gem methods is not defined here
+                else
+                  singleton_class.class_eval do
+                    alias_method :original_gem, :gem
+                  end
+
+                  def gem(name, *args)
+                    if @dependencies.any? {|d| d.name == name }
+                      ::Bundler.ui.info "Skipping gem '#{name}' because already exist"
+                    else
+                      original_gem(name, *args)
+                    end
+                  end
+                end
+
+                eval_gemfile(gems_rb)
+              end
+
+              return
+            end
+          end
+        end
+      end
+
+      def self.gems_dependencies_rb
+        ::Bundler.root.join('gems.dependencies.rb')
+      end
+
+      def self.prepare_dependencies_for_next_round(dependencies, resolved_dependencies)
+        dependencies = dependencies.dup
+
+        # Prepare dependencies
+        dependencies.keep_if do |dependency|
+          dependency.groups.include?(:rys) &&
+          dependency.source &&
+          resolved_dependencies.none?{|rd| rd.name == dependency.name }
+        end
+
+        # Sort them to prior local dependencies
+        dependencies.sort_by! do |dependency|
+          case dependency.source
+          # Git should be first because its inherit from Path
+          when ::Bundler::Source::Git
+            if dependency.source.send(:local?)
+              1
+            else
+              3
+            end
+          # Local path
+          when ::Bundler::Source::Path
+            0
+          # Rubygems, gemspec, metadata
+          else
+            2
+          end
+        end
+
+        # More dependencies can depend on the same dependencies :-)
+        dependencies.uniq!(&:name)
+
+        return dependencies
+      end
+
+      def self.merge_definition_sources(from_definition, to_definition)
+        to_sources = to_definition.send(:sources)
+
+        from_definition.send(:sources).all_sources.map do |source|
+          begin
+            to_sources.send(:source_list_for, source) << source
+          rescue
+          end
+        end
+      end
+
+      def self.add_source_definition(dependency, to_definition)
+        sources = to_definition.send(:sources).send(:source_list_for, dependency.source)
+
+        if sources.include?(dependency.source)
+          # Already there
+        else
+          sources << dependency.source
+        end
+      rescue
+        # Bundler could raise an ArgumentError
+      end
+
+      def self.save_new_dependencies(dependencies)
+        File.open(gems_dependencies_rb, 'w') do |f|
+          f.puts %{# This file was generated by Rys::Bundler at #{Time.now}}
+          f.puts %{# Dependencies are generated after every `bundle` command}
+          f.puts %{# Modify file at your own risk}
+          f.puts
+
+          dependencies.each do |dep|
+            options = {}
+
+            source = dep.source
+            case source
+            when ::Bundler::Source::Git
+              options[:git] = source.uri
+              options[:branch] = source.branch
+              options[:ref] = source.ref
+            when NilClass
+              # Regular gem
+            else
+              raise "Unknow source '#{source.class}'"
+            end
+
+            args = []
+            args << dep.name
+            args.concat(dep.requirement.as_list)
+
+            options[:groups] = dep.groups
+            options[:require] = dep.autorequire if dep.autorequire
+
+            gem_args = args.map{|arg| '"' + arg + '"' }.join(', ')
+
+            f.puts %{if dependencies.none?{|dep| dep.name.to_s == "#{dep.name}" }}
+            f.puts %{  gem #{gem_args}, #{options}}
+            f.puts %{end}
+            f.puts
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rys/bundler/version.rb

@@ -0,0 +1,5 @@
+module Rys
+  module Bundler
+    VERSION = '1.0.1'
+  end
+end

data/lib/rys/bundler.rb

@@ -0,0 +1,17 @@
+require 'rys/bundler/version'
+
+module Rys
+  module Bundler
+    autoload :Hooks,   'rys/bundler/hooks'
+    autoload :Command, 'rys/bundler/command'
+
+    module Commands
+      autoload :Base,               'rys/bundler/commands/base'
+      autoload :Add,                'rys/bundler/commands/add'
+      autoload :Build,              'rys/bundler/commands/build'
+      autoload :BuildLocal,         'rys/bundler/commands/build_local'
+      autoload :BuildDeployment,    'rys/bundler/commands/build_deployment'
+      autoload :BuildInteractively, 'rys/bundler/commands/build_interactively'
+    end
+  end
+end

data/lib/rys-bundler.rb

@@ -0,0 +1 @@
+require_relative 'rys/bundler'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: rys-bundler
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Ondřej Moravčík
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rys-bundler.rb
+- lib/rys/bundler.rb
+- lib/rys/bundler/command.rb
+- lib/rys/bundler/commands/add.rb
+- lib/rys/bundler/commands/base.rb
+- lib/rys/bundler/commands/build.rb
+- lib/rys/bundler/commands/build_deployment.rb
+- lib/rys/bundler/commands/build_interactively.rb
+- lib/rys/bundler/commands/build_local.rb
+- lib/rys/bundler/hooks.rb
+- lib/rys/bundler/version.rb
+homepage: 
+licenses: []
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Recursively resolving rys dependencies
+test_files: []