alki 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30b3e6d184beebdc00446b13b4930d47d32151df
-  data.tar.gz: 98249b15e58962ab44737b9e54199f8690938407
+  metadata.gz: bc1b79ca08e965916ecbd78625d9635f9b11868c
+  data.tar.gz: 7d847de049a43edefa043d07ef4d64160c625407
 SHA512:
-  metadata.gz: df40acd78708b8a0371f5191f1b5160c4d09e9348e92c237791761528a22552f3212c7dd14759c555b20d5364def4cd1976eaa12ad90690d3d9b81a7c5e27670
-  data.tar.gz: 24bc23ef4c32c0b16a6e63a0386c3a767bcc9fc0a2393b8197c9d942e4f9ebad6bc97b394d1d142c060cc39371e42d6fc2edeb6d72a51035fd12dad836babc8c
+  metadata.gz: 05ffaa08ff5d51121f127ee2db0cc01238031b1b0ff6f7e0c1a95eedab5cd551e6733c991ea54a7058cc308468843b97591e40fdbac5c19b005317fbaddd5614
+  data.tar.gz: a1db4bc72926268f1d1ccb789215c903bfd83a0e165816a98777fa15bf5ab70f230a2a35854f94ebf62df8cb0810f9f7b3a2c1fc09bc1cd3cac0d468964b148b

data/exe/alki

@@ -2,8 +2,9 @@
 require 'fileutils'
 require 'optparse'
 require 'alki/support'
+require 'alki/generator'
 
-valid_addons = ["console"]
+valid_addons = ["console","reload"]
 
 options = {
   config_dir: nil,
@@ -14,12 +15,14 @@ options = {
 parser = OptionParser.new do |opts|
   opts.banner = "Usage: alki init PROJECT_NAME [options]"
 
-  opts.on("-a", "--add[=ADDON]", "Add addon to project. Valid addons: #{valid_addons.join(', ')}") do |v|
-    unless valid_addons.include? v
-      puts "Invalid addon: #{v}"
-      exit 1
+  opts.on("-a", "--addons=ADDONS", Array, "Add addon to project. Valid addons: #{valid_addons.join(', ')}") do |vs|
+    vs.each do |v|
+      unless valid_addons.include? v
+        puts "Invalid addon: #{v}"
+        exit 1
+      end
+      options[:addons] |= [v]
     end
-    options[:addon] |= [v]
   end
 
   opts.on('-d','--directory=DIRECTORY', 'Project root, defaults to the current working directory') do |v|
@@ -47,187 +50,9 @@ unless ARGV[1] =~  %r{^[a-z0-9_]+(/[a-z0-9_]+)*$}
   exit 1
 end
 
-
-
-class AlkiFileWriter
-  def initialize(root_dir)
-    @root_dir = root_dir
-    @changes = []
-    @triggers = []
-  end
-
-  def create(file,contents)
-    @changes << [:create,file: file,contents: contents,opts: {}]
-  end
-
-  def create_exec(file,contents)
-    @changes << [:create,file: file,contents: contents,opts: {exec: true}]
-  end
-
-  def check_create(file:, contents:, opts:)
-    path = abs_path( file)
-    if File.exists? path
-      if File.read(path) == contents
-        :skip
-      end
-    end
-  end
-
-  def desc_create(file:, contents:, opts: {})
-    path = abs_path( file)
-    if opts[:exec]
-      adj = "executable "
-    end
-    if File.exists? path
-      "Overwriting #{adj}#{file}!"
-    else
-      "Create #{adj}#{file}"
-    end
-  end
-
-  def do_create(file:, contents:, opts: {})
-    path = abs_path( file)
-    FileUtils.mkdir_p File.dirname(path)
-    File.write path, contents
-    FileUtils.chmod '+x', path if opts[:exec]
-  end
-
-  def opt_create(file,contents)
-    @changes << [:opt_create,file: file,contents: contents]
-  end
-
-  def check_opt_create(file:, contents:)
-    if File.exists? abs_path( file)
-      :skip
-    end
-  end
-
-  def desc_opt_create(opts)
-    desc_create opts
-  end
-
-  def do_opt_create(opts)
-    do_create opts
-  end
-
-  def add_line(file,line,opts={})
-    @changes << [:add_line,file: file,line: line,opts: opts]
-  end
-
-  def check_add_line(file:,line:,opts:)
-    if File.exists? abs_path(file)
-      File.open(file) do |f|
-        if opts[:after]
-          found = until f.eof?
-            break true if f.readline.chomp == opts[:after]
-          end
-          unless found
-            puts "File \"#{file}\" doesn't contain required line #{opts[:after]}"
-            return :abort
-          end
-        end
-        until f.eof?
-          l = f.readline
-          if opts[:match] ? l.chomp.match(opts[:match]) : (l.chomp == line)
-            return :skip
-          end
-        end
-      end
-    else
-      unless @changes.find {|c| [:create,:opt_create].include?(c[0]) && c[1][:file] == file}
-        puts "File \"#{file}\" doesn't exist!"
-        return :abort
-      end
-    end
-  end
-
-  def desc_add_line(file:,line:,opts:)
-    "Add line \"#{line}\" to #{file}"
-  end
-
-  def do_add_line(file:,line:,opts:)
-    if opts[:after]
-      File.write file, File.read(file).sub(/^#{Regexp.quote(opts[:after])}\n/){|m| m + line + "\n"}
-    else
-      File.open(file,'a') do |f|
-        f.puts line
-      end
-    end
-  end
-
-  def trigger(file,cmd)
-    @triggers << [file, cmd]
-  end
-
-  def check_trigger(changes,file)
-    changes.find {|c| c[1][:file] == file}
-  end
-
-  def desc_trigger(cmd:)
-    "Run \"#{cmd}\""
-  end
-
-  def do_trigger(cmd:)
-    system cmd
-  end
-
-  def check_changes
-    puts "Checking preconditions..."
-    abort = false
-    unless Dir.exists?(@root_dir)
-      puts "Root dir doesn't exist"
-      exit 1
-    end
-    do_changes = []
-    @changes.each do |(type,args)|
-      res = send "check_#{type}", args
-      abort = true if res == :abort
-      do_changes << [type,args] unless res == :skip
-    end
-    @triggers.each do |(file,cmd)|
-      if check_trigger do_changes, file
-        do_changes << [:trigger,cmd: cmd]
-      end
-    end
-    exit 1 if abort
-    do_changes
-  end
-
-  def print_overview(changes)
-    puts "Overview of changes to be made:"
-
-    changes.each do |(type,args)|
-      desc = send "desc_#{type}", args
-      puts "  #{desc}" if desc
-    end
-    print "Proceed? "
-    resp = STDIN.gets.chomp
-    unless resp =~ /^y(es?)?/i
-      puts "Aborting"
-      exit
-    end
-  end
-
-  def write
-    puts "Using project root: #{@root_dir}\n"
-    do_changes = check_changes
-    print_overview do_changes
-
-    puts "Writing changes..."
-    do_changes.each do |(type,args)|
-      send "do_#{type}", args
-    end
-    puts "Done"
-  end
-
-  def abs_path(p)
-    File.expand_path(p,@root_dir)
-  end
-end
-
 project_name = ARGV[1]
 
-fw = AlkiFileWriter.new config[:project_dir]
+fw = Alki::Generator.new options[:project_dir]
 
 config_dir = options[:config_dir] || 'config'
 primary_config = options[:primary_config] || 'assembly'
@@ -261,7 +86,7 @@ if options[:addons].include? "console"
   fw.add_line "Gemfile", "gem 'alki-console'", match: /^gem ['"]alki-console['"]/
 
   name = project_name.tr('/','-')
-  fw.add_line primary_config_path, "  mount :console, 'alki/console', name: '#{name}'", match: /^\s*assembly :console/, after: 'Alki do'
+  fw.add_line primary_config_path, "  mount :console, 'alki/console', name: '#{name}'", match: /^\s*mount\( *:console/, after: 'Alki do'
 
   fw.create_exec 'bin/console', <<END
 #!/usr/bin/env ruby
@@ -272,4 +97,12 @@ require '#{project_name}'
 END
 end
 
+if options[:addons].include? "reload"
+  fw.add_line "Gemfile", "gem 'alki-reload'", match: /^gem ['"]alki-reload['"]/
+
+  env_name = project_name.tr('a-z/','A-Z_')+"_ENV"
+  fw.add_line primary_config_path, "  mount(:reloader, 'alki/reload'){ set(:watch) { development? } }", match: /^\s*mount\(? *:reloader/, after: 'Alki do'
+  fw.add_line primary_config_path, "  set(:development?){ ENV['#{env_name}'] == 'development' }", match: /^\s*set :development?/, after: 'Alki do'
+end
+
 fw.write

data/lib/alki/assembly/builder.rb

@@ -10,6 +10,7 @@ module Alki
         @config_dir = nil
         @assembly_name = nil
         @definition = nil
+        @load_mode = :direct
       end
 
       attr_reader :config_dir, :assembly_name, :definition
@@ -19,6 +20,7 @@ module Alki
       end
 
       def build(opts={},&blk)
+        @load_mode = opts[:load_mode] if opts[:load_mode]
         build_assembly blk if blk
         if opts[:config_dir]
           context = if opts[:project_assembly]
@@ -68,9 +70,7 @@ module Alki
       end
 
       def register_config_directory
-        opts = {config_dir: @config_dir}
-        opts[:prefix] = File.join(@assembly_name,'alki_config') if @assembly_name
-        Alki::Dsl.register_dir @config_dir, 'alki/dsls/assembly', opts
+        Alki::Dsl.register_dir @config_dir, 'alki/dsls/assembly', dsl_opts
       end
 
       def load_assembly_file(name = nil)
@@ -78,7 +78,7 @@ module Alki
         if @config_dir
           assembly_config_path = File.join(@config_dir,"#{name}.rb")
           if File.exists? assembly_config_path
-            @definition = Alki::Dsl.load(assembly_config_path)[:class]
+            @definition = assembly_config_path
             true
           end
         end
@@ -89,22 +89,47 @@ module Alki
       end
 
       def build_assembly(blk)
-        @definition = Alki::Dsl.build('alki/dsls/assembly', config_dir: @config_dir, &blk)[:class]
+        @definition = Alki::Dsl.build('alki/dsls/assembly', dsl_opts, &blk)[:class]
+      end
+
+      def dsl_opts
+        opts = {config_dir: @config_dir}
+        if @assembly_name
+          opts[:prefix] = File.join(@assembly_name,'alki_config')
+          opts[:assembly_name] = @assembly_name
+        end
+        opts
       end
 
       def build_class
         definition = @definition
+        name = @assembly_name
+        load_class = if @load_mode == :require
+          ->{ name }
+        else
+          ->{ self }
+        end
         Alki::ClassBuilder.build(
           prefix: '',
           name: @assembly_name,
           class_modules: [Alki::Assembly],
           type: :module,
           class_methods: {
+            assembly_name: {
+              body: ->{
+                name
+              }
+            },
             definition: {
               body: ->{
-                definition
+                definition.is_a?(String) ?
+                  Alki::Dsl.load(definition)[:class] :
+                  definition
               }
             },
+            load_class: {
+              body: load_class
+            }
           }
         )
       end

data/lib/alki/assembly/executor.rb

@@ -11,16 +11,18 @@ module Alki
         @overlays = overlays
         @data = {}
         @semaphore = Monitor.new
-        clear
-      end
-
-      def clear
         @lookup_cache = {}
         @call_cache = {}
         @context_cache = {}
         @processed_overlays = false
       end
 
+      def synchronize
+        @semaphore.synchronize do
+          yield
+        end
+      end
+
       def call(path,*args,&blk)
         execute({},path,args,blk)
       end
@@ -29,7 +31,7 @@ module Alki
           cache_entry = @call_cache[path]
           if cache_entry
             if cache_entry.status == :building
-              raise "Circular element reference found"
+              raise "Circular element reference found: #{path.join(".")}"
             end
           else
             @semaphore.synchronize do
@@ -49,6 +51,15 @@ module Alki
         call_value(cache_entry.type,cache_entry.value,meta,args,blk)
       end
 
+      def canonical_path(from,path)
+        from_elem = lookup(from)
+        scope = from_elem[:full_scope] || from_elem[:scope]
+        path.inject(nil) do |p,elem|
+          scope = lookup(p)[:scope] if p
+          scope[elem]
+        end
+      end
+
       private
 
       def process_overlays
@@ -58,8 +69,11 @@ module Alki
           @overlays.each do |(from,info)|
             target = canonical_path(from,info.target) or
               raise InvalidPathError.new("Invalid overlay target #{info.target.join('.')}")
-            overlay = canonical_path(from,info.overlay) or
-              raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
+            overlay = info.overlay
+            if overlay.is_a?(Array)
+              overlay = canonical_path(from,info.overlay) or
+                raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
+            end
             (@data[:overlays][target]||=[]) << [overlay,info.args]
           end
         end
@@ -84,15 +98,6 @@ module Alki
         elem.output data
       end
 
-
-      def canonical_path(from,path)
-        scope = lookup(from)[:full_scope]
-        path.inject(nil) do |p,elem|
-          scope = lookup(p)[:scope] if p
-          scope[elem]
-        end
-      end
-
       def process_action(action)
         if action.key?(:value)
           [:value,action[:value]]

data/lib/alki/assembly/instance.rb

@@ -1,20 +1,37 @@
+require 'delegate'
+require 'alki/support'
+
 module Alki
   module Assembly
-    class Instance
-      def initialize(executor)
-        @executor = executor
+    class Instance < Delegator
+      def initialize(assembly_module,args)
+        @assembly_module = assembly_module
+        @args = args
       end
 
-      def root
-        @root ||= @executor.call []
+      def __reload__
+        if @obj.respond_to? :__reload__
+          did_something = @obj.__reload__
+        end
+        if did_something != false && @obj
+          @obj = nil
+          did_something = true
+        end
+        if did_something
+          GC.start
+        end
+        !!did_something
       end
 
-      def respond_to_missing?(name,include_all)
-        root.respond_to? name
+      def __setobj__(obj)
+        @obj = obj
       end
 
-      def method_missing(name,*args,&blk)
-        root.send name, *args, &blk
+      def __getobj__
+        unless @obj
+          Alki::Support.load_class(@assembly_module).raw_instance self, *@args
+        end
+        @obj
       end
     end
   end

data/lib/alki/assembly/types/service.rb

@@ -12,7 +12,7 @@ Alki do
         },
         proc: -> (elem) {
           elem[:value] = overlays.inject(__build__) do |val,(overlay,args)|
-            overlay = root.lookup(overlay)
+            overlay = root.lookup(overlay) if overlay.is_a?(Array)
             if !overlay.respond_to?(:call) && overlay.respond_to?(:new)
               overlay = overlay.method(:new)
             end

data/lib/alki/assembly.rb

@@ -3,26 +3,34 @@ require 'alki/assembly/types/assembly'
 require 'alki/assembly/types/group'
 require 'alki/assembly/instance'
 require 'alki/assembly/executor'
+require 'alki/overlay_info'
 
 module Alki
   module Assembly
     def new(overrides={},&blk)
+      Instance.new load_class, [overrides, blk]
+    end
+
+    def raw_instance(instance,overrides,blk)
       overrides_info = OverrideBuilder.build(overrides,&blk)
       override_root = overrides_info[:root] || build(:group)
 
       assembly = build :assembly, root, override_root
-      executor = Executor.new(assembly, overlays+overrides_info[:overlays])
+      update_instance_overlay = [[],OverlayInfo.new(
+        [:assembly_instance],
+        ->obj{instance.__setobj__ obj; instance},
+        []
+      )]
+      all_overlays = overlays+overrides_info[:overlays]+[update_instance_overlay]
+      executor = Executor.new(assembly, all_overlays)
 
       override_root.children[:assembly_instance] = build(:service,->{
-        Instance.new(executor)
+        root
       })
+      override_root.children[:assembly_executor] = build(:value,executor)
       executor.call [:assembly_instance]
     end
 
-    def build(type,*args)
-      Alki::Support.load_class("alki/assembly/types/#{type}").new *args
-    end
-
     def root
       self.definition.root
     end
@@ -30,5 +38,11 @@ module Alki
     def overlays
       self.definition.overlays
     end
+
+    private
+
+    def build(type,*args)
+      Alki::Support.load_class("alki/assembly/types/#{type}").new *args
+    end
   end
 end

data/lib/alki/dsls/assembly.rb

@@ -4,6 +4,7 @@ Alki do
 
   finish do
     add :config_dir, build(:value, ctx[:config_dir])
+    add :assembly_name, build(:value, ctx[:assembly_name])
     prefix_overlays :original, ctx[:overlays]
 
     root = ctx[:root]

data/lib/alki/execution/value_context.rb

@@ -1,5 +1,6 @@
 require 'alki/execution/context'
 require 'alki/overlay_delegator'
+require 'alki/reloadable_delegator'
 
 module Alki
   module Execution
@@ -9,6 +10,14 @@ module Alki
       def delegate_overlay(obj,overlay,**args)
         Alki::OverlayDelegator.new(obj,overlay,args)
       end
+
+      def entrypoint(klass,*args, reloadable: false)
+        klass.new *args.map {|a| reloadable ? self.reloadable(a) : lookup(a) }
+      end
+
+      def reloadable(path)
+        Alki::ReloadableDelegator.new(root.assembly_instance,meta[:building],path)
+      end
     end
   end
 end

data/lib/alki/generator.rb

@@ -0,0 +1,177 @@
+module Alki
+  class Generator
+    def initialize(root_dir)
+      @root_dir = root_dir
+      @changes = []
+      @triggers = []
+    end
+
+    def create(file,contents)
+      @changes << [:create,file: file,contents: contents,opts: {}]
+    end
+
+    def create_exec(file,contents)
+      @changes << [:create,file: file,contents: contents,opts: {exec: true}]
+    end
+
+    def check_create(file:, contents:, opts:)
+      path = abs_path( file)
+      if File.exists? path
+        if File.read(path) == contents
+          :skip
+        end
+      end
+    end
+
+    def desc_create(file:, contents:, opts: {})
+      path = abs_path( file)
+      if opts[:exec]
+        adj = "executable "
+      end
+      if File.exists? path
+        "Overwriting #{adj}#{file}!"
+      else
+        "Create #{adj}#{file}"
+      end
+    end
+
+    def do_create(file:, contents:, opts: {})
+      path = abs_path( file)
+      FileUtils.mkdir_p File.dirname(path)
+      File.write path, contents
+      FileUtils.chmod '+x', path if opts[:exec]
+    end
+
+    def opt_create(file,contents)
+      @changes << [:opt_create,file: file,contents: contents]
+    end
+
+    def check_opt_create(file:, contents:)
+      if File.exists? abs_path( file)
+        :skip
+      end
+    end
+
+    def desc_opt_create(opts)
+      desc_create opts
+    end
+
+    def do_opt_create(opts)
+      do_create opts
+    end
+
+    def add_line(file,line,opts={})
+      @changes << [:add_line,file: file,line: line,opts: opts]
+    end
+
+    def check_add_line(file:,line:,opts:)
+      if File.exists? abs_path(file)
+        File.open(file) do |f|
+          if opts[:after]
+            found = until f.eof?
+              break true if f.readline.chomp == opts[:after]
+            end
+            unless found
+              puts "File \"#{file}\" doesn't contain required line #{opts[:after]}"
+              return :abort
+            end
+          end
+          until f.eof?
+            l = f.readline
+            if opts[:match] ? l.chomp.match(opts[:match]) : (l.chomp == line)
+              return :skip
+            end
+          end
+        end
+      else
+        unless @changes.find {|c| [:create,:opt_create].include?(c[0]) && c[1][:file] == file}
+          puts "File \"#{file}\" doesn't exist!"
+          return :abort
+        end
+      end
+    end
+
+    def desc_add_line(file:,line:,opts:)
+      "Add line \"#{line}\" to #{file}"
+    end
+
+    def do_add_line(file:,line:,opts:)
+      if opts[:after]
+        File.write file, File.read(file).sub(/^#{Regexp.quote(opts[:after])}\n/){|m| m + line + "\n"}
+      else
+        File.open(file,'a') do |f|
+          f.puts line
+        end
+      end
+    end
+
+    def trigger(file,cmd)
+      @triggers << [file, cmd]
+    end
+
+    def check_trigger(changes,file)
+      changes.find {|c| c[1][:file] == file}
+    end
+
+    def desc_trigger(cmd:)
+      "Run \"#{cmd}\""
+    end
+
+    def do_trigger(cmd:)
+      system cmd
+    end
+
+    def check_changes
+      puts "Checking preconditions..."
+      abort = false
+      unless Dir.exists?(@root_dir)
+        puts "Root dir doesn't exist"
+        exit 1
+      end
+      do_changes = []
+      @changes.each do |(type,args)|
+        res = send "check_#{type}", args
+        abort = true if res == :abort
+        do_changes << [type,args] unless res == :skip
+      end
+      @triggers.each do |(file,cmd)|
+        if check_trigger do_changes, file
+          do_changes << [:trigger,cmd: cmd]
+        end
+      end
+      exit 1 if abort
+      do_changes
+    end
+
+    def print_overview(changes)
+      puts "Overview of changes to be made:"
+
+      changes.each do |(type,args)|
+        desc = send "desc_#{type}", args
+        puts "  #{desc}" if desc
+      end
+      print "Proceed? "
+      resp = STDIN.gets.chomp
+      unless resp =~ /^y(es?)?/i
+        puts "Aborting"
+        exit
+      end
+    end
+
+    def write
+      puts "Using project root: #{@root_dir}\n"
+      do_changes = check_changes
+      print_overview do_changes
+
+      puts "Writing changes..."
+      do_changes.each do |(type,args)|
+        send "do_#{type}", args
+      end
+      puts "Done"
+    end
+
+    def abs_path(p)
+      File.expand_path(p,@root_dir)
+    end
+  end
+end

data/lib/alki/reloadable_delegator.rb

@@ -0,0 +1,17 @@
+require 'delegate'
+
+module Alki
+  class ReloadableDelegator < Delegator
+    def initialize(instance,from,path)
+      @instance = instance
+      @from = from.to_s.split('.').map(&:to_sym)
+      @path = path.to_s.split('.').map(&:to_sym)
+    end
+
+    def __getobj__
+      @instance.assembly_executor.call(
+        @instance.assembly_executor.canonical_path(@from,@path)
+      )
+    end
+  end
+end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/lib/alki.rb

@@ -5,6 +5,7 @@ module Alki
   class << self
     def project_assembly!(opts={},&blk)
       opts[:project_assembly] ||= caller_locations(1,1)[0].absolute_path
+      opts[:load_mode] = :require
       Assembly::Builder.build(opts,&blk)
     end
 

data/test/feature/overlays_test.rb

@@ -210,16 +210,18 @@ describe 'Overlays' do
 
   it 'should allow setting overlays on assembly_instance' do
     values = []
+    mock = Minitest::Mock.new
     assembly = Alki.create_assembly do
       overlay :assembly_instance, :test_overlay
-
+      set :val, 1
       set :test_overlay, ->(value) {
         values << value
-        :transformed
+        mock
       }
     end
-    assembly.new.must_equal :transformed
+    mock.expect :val, 2
+    assembly.new.val.must_equal 2
     values.size.must_equal 1
-    values[0].must_be_instance_of Alki::Assembly::Instance
+    values[0].val.must_equal 1
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-17 00:00:00.000000000 Z
+date: 2016-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -138,9 +138,11 @@ files:
 - lib/alki/execution/context_class_builder.rb
 - lib/alki/execution/value_context.rb
 - lib/alki/feature_test.rb
+- lib/alki/generator.rb
 - lib/alki/overlay_delegator.rb
 - lib/alki/overlay_info.rb
 - lib/alki/override_builder.rb
+- lib/alki/reloadable_delegator.rb
 - lib/alki/service_delegator.rb
 - lib/alki/test.rb
 - lib/alki/version.rb
@@ -186,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Base library for building applications.