buzztools 0.0.3 → 0.0.5

data/lib/buzztools/config.rb

@@ -0,0 +1,114 @@
+module Buzztools
+	class Config < Hash
+
+		attr_reader :default_values
+
+		def initialize(aDefaultValues,aNewValues=nil,&aBlock)
+			@default_values = aDefaultValues.clone
+			reset()
+			if aNewValues
+				block_given? ? read(aNewValues,&aBlock) : read(aNewValues)
+			end
+		end
+
+		# aBlock allows values to be filtered based on key,default and new values
+		def read(aSource,&aBlock)
+			default_values.each do |k,v|
+				done = false
+				if block_given? && ((newv = yield(k,v,aSource && aSource[k])) != nil)
+					self[k] = newv
+					done = true
+				end
+				copy_item(aSource,k) if !done && aSource && !aSource[k].nil?
+			end
+			self
+		end
+
+		# reset values back to defaults
+		def reset
+			self.clear
+			me = self
+			@default_values.each {|n,v| me[n] = v.is_a?(Class) ? nil : v}
+		end
+
+		def set_int(aKey,aValue)
+			case aValue
+				when String then    self[aKey] = aValue.to_integer(self[aKey]);
+				when Fixnum then    self[aKey] = aValue;
+				when Float then     self[aKey] = aValue.to_i;
+			end
+		end
+
+		def set_float(aKey,aValue)
+			case aValue
+				when String then    self[aKey] = aValue.to_float(self[aKey]);
+				when Fixnum then    self[aKey] = aValue.to_f;
+				when Float then     self[aKey] = aValue;
+			end
+		end
+
+		def set_boolean(aKey,aValue)
+			case aValue
+				when TrueClass,FalseClass then   self[aKey] = aValue;
+				when String then    self[aKey] = (['1','yes','y','true','on'].include?(aValue.downcase))
+			else
+				set_boolean(aKey,aValue.to_s)
+			end
+		end
+
+		def set_symbol(aKey,aValue)
+			case aValue
+				when String then    self[aKey] = (aValue.to_sym rescue nil);
+				when Symbol then    self[aKey] = aValue;
+			end
+		end
+
+		def copy_item(aHash,aKey)
+			d = default_values[aKey]
+			d_class = (d.is_a?(Class) ? d : d.class)
+			cname = d_class.name.to_sym
+			case cname
+				when :NilClass then self[aKey] = aHash[aKey];
+				when :String then self[aKey] = aHash[aKey].to_s unless aHash[aKey].nil?
+				when :Float then set_float(aKey,aHash[aKey]);
+				when :Fixnum then set_int(aKey,aHash[aKey]);
+				when :TrueClass, :FalseClass then set_boolean(aKey,aHash[aKey]);
+				when :Symbol then self[aKey] = (aHash[aKey].to_sym rescue nil)
+				when :Proc then self[aKey] = aHash[aKey] if aHash[aKey].is_a?(Proc)
+				else
+					raise StandardError.new('unsupported type')
+			end
+		end
+
+		def copy_strings(aHash,*aKeys)
+			aKeys.each do |k|
+				self[k] = aHash[k].to_s unless aHash[k].nil?
+			end
+		end
+
+		def copy_ints(*aDb)
+			aHash = aDb.shift
+			aKeys = aDb
+			aKeys.each do |k|
+				set_int(k,aHash[k])
+			end
+		end
+
+		def copy_floats(aHash,*aKeys)
+			aKeys.each do |k|
+				set_float(k,aHash[k])
+			end
+		end
+
+		def copy_booleans(aHash,*aKeys)
+			aKeys.each do |k|
+				set_boolean(k,aHash[k])
+			end
+		end
+
+		def to_hash
+			{}.merge(self)
+		end
+
+	end
+end

data/lib/buzztools/extend_array.rb

@@ -1,3 +1,5 @@
+require 'csv'
+
 module ExtendArray
 
 	module_function # this makes the methods accessible on the module as well as instances when the module is included into a class
@@ -41,6 +43,27 @@ module ExtendArray
 	def to_nil
 		self.empty? ? nil : self
 	end
+
+	def to_csv
+		def as_hash(aItem)
+			aItem = aItem.attributes if aItem.respond_to?(:attributes)
+			return aItem if aItem.is_a?(Hash)
+			nil
+		end
+		item1 = as_hash(first)
+		raise "Must be an array of hashes" unless item1 && item1.is_a?(Hash)
+		fields = item1.keys.map(&:to_s).sort
+		if fields.delete('id')
+			fields.unshift('id')
+		end
+    CSV.generate do |csv|
+      csv << fields
+      self.each do |i|
+	      next unless i = as_hash(i)
+        csv << i.values_at(*column_names)
+      end
+    end
+	end
 end
 
 Array.class_eval do

data/lib/buzztools/extend_bignum.rb

@@ -13,7 +13,7 @@ end
 Float.class_eval do
 
 	def to_nil
-		(self==0 || self.nan?) ? nil : self
+		(self==0 || !self.finite?) ? nil : self
 	end
 
 end

data/lib/buzztools/extend_object.rb

@@ -24,21 +24,24 @@ module ExtendObject
 			path = args
 		end
 		if path.is_a?(String)
-			segments = path.split('.').map!(&:to_sym)
+			segments = path.split('.')
 			segment = segments.shift
 		elsif path.is_a?(Symbol)
-			segments = []
-			segment = path
+			path = path.to_s
+			segments = [path]
+			segment = segments.shift
 		elsif path.is_a?(Array)
 			segments = path
 			segment = segments.shift
-			segment = segment.to_sym if segment
+			#segment = segment.to_sym if segment
 		end
 		return self unless segment.to_nil
-		value = if self.respond_to?(segment)
+		value = if self.is_a?(Array)
+			self[segment.to_i] rescue nil
+		elsif (self.respond_to?(segment.to_sym) rescue nil)
 			self.send(segment)
 		elsif self.respond_to?(:[])
-			(self[segment] || self[segment.to_s]) rescue nil
+			(begin self[segment] rescue nil end) || (begin self[segment.to_sym] rescue nil end)
 		end
 		if segments.empty?
 			value

data/lib/buzztools/extend_string.rb

@@ -215,6 +215,21 @@ String.class_eval do
 	def self.from_file(aFilename)
 		File.open(aFilename, "rb") { |f| f.read }
 	end
+
+	# given ('abcdefg','c.*?e') returns ['ab','cde','fg'] so you can manipulate the head, match and tail seperately, and potentially rejoin
+	def split3(aPattern,aOccurence=0)
+		aString = self
+		matches = aString.scan_md(aPattern)
+		match = matches[aOccurence]
+		parts = (match ? [match.pre_match,match.to_s,match.post_match] : [aString,nil,''])
+
+		if !block_given?	# return head,match,tail
+			parts
+		else						# return string
+			parts[1] = yield *parts if match
+			parts.join
+		end
+	end
 end
 
 

data/lib/buzztools/extend_time.rb

@@ -81,4 +81,14 @@ Time.class_eval do
 	def to_w3c
 		utc.strftime("%Y-%m-%dT%H:%M:%S+00:00")
 	end
+
+	# returns an integer date stamp (milliseconds since 1970) compatible with Javascript
+	def to_ms
+		(to_f*1000).round
+	end
+
+	# creates a Time object from an integer date stamp (milliseconds since 1970) compatible with Javascript
+	def self.from_ms(aMilliseconds)
+		at(aMilliseconds/1000.0)
+	end
 end

data/lib/buzztools/extras/shell_extras.rb

@@ -0,0 +1,79 @@
+gem 'POpen4'; require 'popen4'
+
+module POpen4
+
+	class ExecuteError < StandardError
+
+		attr_reader :result #,:stderr,:stdout,:exitcode,:pid
+
+    def initialize(aArg)
+      if aArg.is_a? Hash
+				msg = ([aArg[:stderr],aArg[:stdout],"Error #{aArg[:exitcode].to_s}"].find {|i| i && !i.empty?})
+        super(msg)
+        @result = aArg
+      else
+        super(aArg)
+      end
+    end
+		
+		def inspect
+			"#{self.class.to_s}: #{@result.inspect}"
+		end
+
+	end
+	
+	def self.pump_thread(aIn,aOut)
+		Thread.new do
+			loop { aOut.puts aIn.gets }
+		end
+	end
+
+	# Usage :
+	# result = POpen4::shell('somebinary') do |r|   # block gives opportunity to adjust result, and avoid exception raised from non-zero exit codes
+	# 	if r[:exitcode]==254		# eg. say this binary returns 254 to mean something special but not an error
+	#     r[:stdout] = 'some correct output'
+	#     r[:stderr] = ''
+	#     r[:exitcode] = 0
+	#   end
+	# end
+  #
+  # OR
+  #
+  # result = POpen4::shell('somebinary');
+  # puts result[:stdout]
+	#
+	# Giving aStdOut,aStdErr causes the command output to be connected to the given stream, and that stream to not be given in the result hash
+	def self.shell(aCommand,aWorkingDir=nil,aTimeout=nil,aStdOut=nil,aStdErr=nil)
+		raise ExecuteError.new('aWorkingDir doesnt exist') unless !aWorkingDir || File.exists?(aWorkingDir)
+		orig_wd = Dir.getwd
+		result = {:command => aCommand, :dir => (aWorkingDir || orig_wd)}
+    status = nil
+		begin
+			Dir.chdir(aWorkingDir) if aWorkingDir
+			Timeout.timeout(aTimeout,ExecuteError) do	# nil aTimeout will not time out
+				status = POpen4::popen4(aCommand) do |stdout, stderr, stdin, pid|
+					thrOut = aStdOut ? Thread.new { aStdOut.puts stdout.read } : nil
+					thrErr = aStdErr ? Thread.new { aStdErr.puts stderr.read } : nil
+					thrOut.join if thrOut
+					thrErr.join if thrErr
+
+					result[:stdout] = stdout.read unless aStdOut
+					result[:stderr] = stderr.read unless aStdErr
+					result[:pid] = pid
+				end
+			end
+		ensure
+			Dir.chdir(orig_wd)
+		end
+		result[:exitcode] = (status && status.exitstatus) || 1
+		yield(result) if block_given?
+		raise ExecuteError.new(result) if result[:exitcode] != 0
+		return result
+	end
+	
+	def self.shell_out(aCommand,aWorkingDir=nil,aTimeout=nil,&block)
+		block_given? ? POpen4::shell(aCommand,aWorkingDir,aTimeout,STDOUT,STDERR,&block) : POpen4::shell(aCommand,aWorkingDir,aTimeout,STDOUT,STDERR)
+	end
+
+end
+

data/lib/buzztools/file.rb

@@ -0,0 +1,123 @@
+module Buzztools
+	module File
+
+		module_function
+
+		def sniff_seperator(aPath)
+			result = 0.upto(aPath.length-1) do |i|
+				char = aPath[i,1]
+				break char if char=='\\' || char=='/'
+			end
+			result = ::File::SEPARATOR if result==0
+			return result
+		end
+
+		def append_slash(aPath,aSep=nil)
+			aSep = sniff_seperator(aPath) unless aSep
+			aPath.ensure_suffix(aSep)
+		end
+
+		def remove_slash(aPath)
+			last_char = aPath[-1,1]
+			aPath = aPath[0..-2] if last_char=='\\' || last_char=='/'
+			return aPath
+		end
+
+		#def ensure_prefix(aString,aPrefix)
+		#	aString.begins_with?(aPrefix) ? aString : aPrefix+aString
+		#end
+		#
+		#def ensure_suffix(aString,aSuffix)
+		#	aString.ends_with?(aSuffix) ? aString : aString+aSuffix
+		#end
+
+		# Remove base dir from given path. Result will be relative to base dir and not have a leading or trailing slash
+		#'/a/b/c','/a' = 'b/c'
+		#'/a/b/c','/' = 'a/b/c'
+		#'/','/' = ''
+		def path_debase(aPath,aBase)
+			aBase = append_slash(aBase)
+			aPath = remove_slash(aPath) unless aPath=='/'
+			aPath[0,aBase.length]==aBase ? aPath[aBase.length,aPath.length-aBase.length] : aPath
+		end
+
+		def path_rebase(aPath,aOldBase,aNewBase)
+			rel_path = path_debase(aPath,aOldBase)
+			append_slash(aNewBase)+rel_path
+		end
+
+		def path_combine(aBasePath,aPath)
+			return aBasePath if !aPath
+			return aPath if !aBasePath
+			return path_relative?(aPath) ? ::File.join(aBasePath,aPath) : aPath
+		end
+
+		# make path real according to file system
+		def real_path(aPath)
+			(path = Pathname.new(::File.expand_path(aPath))) && path.realpath.to_s
+		end
+
+		# takes a path and combines it with a root path (which defaults to Dir.pwd) unless it is absolute
+		# the final result is then expanded
+		def canonize_path(aPath,aRootPath=nil)
+			path = path_combine(aRootPath,aPath)
+			path = real_path(path) if path
+			path
+		end
+
+		def find_upwards(aStartPath,aPath)
+			curr_path = ::File.expand_path(aStartPath)
+			while curr_path && !(test_path_exists = ::File.exists?(test_path = ::File.join(curr_path,aPath))) do
+				curr_path = path_parent(curr_path)
+			end
+			curr_path && test_path_exists ? test_path : nil
+		end
+
+		# allows special symbols in path
+		# currently only ... supported, which looks upward in the filesystem for the following relative path from the basepath
+		def expand_magic_path(aPath,aBasePath=nil)
+			aBasePath ||= Dir.pwd
+			path = aPath
+			if path.begins_with?('...')
+				rel_part = path.split3(/\.\.\.[\/\\]/)[2]
+				path = find_upwards(aBasePath,rel_part)
+			end
+		end
+
+		def path_parent(aPath)
+			return nil if is_root_path?(aPath)
+			append_slash(::File.dirname(remove_slash(expand_path(aPath))))
+		end
+
+		def simple_dir_name(aPath)
+			::File.basename(remove_slash(aPath))
+		end
+
+		def simple_file_name(aPath)
+			f = ::File.basename(aPath)
+			dot = f.index('.')
+			return dot ? f[0,dot] : f
+		end
+
+		def path_parts(aPath)
+			sep = sniff_seperator(aPath)
+			aPath.split(sep)
+		end
+
+		def extension(aFile,aExtended=true)
+			f = ::File.basename(aFile)
+			dot = aExtended ? f.index('.') : f.rindex('.')
+			return dot ? f[dot+1..-1] : f
+		end
+
+		def no_extension(aFile,aExtended=true)
+			ext = extension(aFile,aExtended)
+			return aFile.chomp('.'+ext)
+		end
+
+		def change_ext(aFile,aExt,aExtend=false)
+			no_extension(aFile,false)+(aExtend ? '.'+aExt+'.'+extension(aFile,false) : '.'+aExt)
+		end
+
+	end
+end

data/lib/buzztools/version.rb

@@ -1,3 +1,3 @@
 module Buzztools
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/lib/buzztools/versionary.rb

@@ -0,0 +1,163 @@
+# Versionary is a mixin for implementing versioning of models with ActiveRecord in Rails 3.2+
+# It attempts to be better than other solutions eg.
+#
+# * no shadow tables
+# * does not abuse ActiveRecord, no magic
+# * no serialization at all, so queries work with all versions
+# * associations work like normal ActiveRecord. The id column identifies a single version of an instance. You can associate to an old version
+# * its easy to read and write old versions
+# * if you use and keep updated the ver_current column, it is extremely fast
+# * this file is really all there is to it
+# * supports future versions that become current when the time comes eg. future price changes
+#
+# This is achieved by using the id column to identify each version of each instance, unlike some solutions that use the id per instance, then have to do trickery to provide versions.
+# This means associations can simply attach to any version of any instance using the id column as normal
+# Instances are identified by the iid column
+#
+# id    iid  version   name  price
+# 1     3         1         eggs  2.99
+# 2     3         2         eggs  3.10
+# 3     4         1         bread 3.50
+#
+# In the above table, eggs (iid = 3) has 2 versions and bread (iid = 4) has 1 version.
+# An order can simply attach to any product/version using the id column
+#
+# The eggs product would be created as follows :
+#
+# eggs = Product.create!(name: 'eggs', price: 2.99)
+# eggs2 = eggs.create_version!(price: 3.10)
+#
+# current_10_dollar_products = Product.live_current_versions.where(price: 10)
+#
+# Migration
+#
+#class CreateThings < ActiveRecord::Migration
+#  def change
+#    create_table :things do |t|
+#      t.integer :iid         # instance id - versions of an instance will have different ids but the same iid
+#      t.integer :version
+#      t.integer :current_from, limit: 8    # timestamp in milliseconds since 1970
+#			 t.boolean :ver_current, null: false, default: false    # optional, for performance. true indicates this is the current version
+#
+#      t.integer :size
+#      t.string :colour
+#      t.string :shape
+#    end
+#		add_index(:things, [:iid, :version], :unique => true)
+#  end
+#end
+#
+# Model
+#
+#class Thing < ActiveRecord::Base
+#
+#	include Versionary
+#
+#end
+#
+#
+module Versionary
+
+	def self.included(aClass)
+    aClass.class_eval do
+
+	    def self.next_version_id(aIid)
+	   		where(iid: aIid).maximum(:version).to_i + 1
+	   	end
+
+	    after_create do
+	   		updates = {}
+	   		updates[:iid] = id if !iid
+		    if !version
+	   		  updates[:version] = self.class.next_version_id(self.iid)
+		    end
+	   		update_attributes!(updates) unless updates.empty?
+	   		true
+	   	end
+
+			# should be able to do eg. : TaxRate.where(owner_id: 1,dealership_id: 2).latest_versions.where(state: 'WA')
+			scope :live_latest_versions, -> {
+				inner = clone.select("iid, max(version) as version").group(:iid).to_sql
+				ids = ActiveRecord::Base.connection.execute("select id from (#{inner}) as v inner join #{table_name} as t on t.iid = v.iid and t.version = v.version").to_a
+				if (adapter = ActiveRecord::Base.configurations[Rails.env]['adapter'])=='postgresql'
+					ids = ids.map{|i| i['id']}.join(',')
+				elsif adapter.begins_with? 'mysql'
+					ids = ids.flatten.join(',')
+				else
+					raise "Adapter #{adapter} not supported"
+				end
+
+				#ids = ActiveRecord::Base.connection.execute("select id from (SELECT iid, max(version) as version FROM `things` GROUP BY iid) as v inner join things as t on t.iid = v.iid and t.version = v.version").to_a.flatten.join(',')
+				where "id IN (#{ids})"
+			}
+
+	    # Scopes to the current version for all iids at the given timestamp
+	    # This and other methods beginning with "live" do not use the ver_current column
+			scope :live_current_versions, ->(aTimestamp) {
+				inner = clone.select("iid, max(version) as version").where(["current_from <= ?",aTimestamp]).group(:iid).to_sql
+				ids = ActiveRecord::Base.connection.execute("select id from (#{inner}) as v inner join #{table_name} as t on t.iid = v.iid and t.version = v.version").to_a
+				if (adapter = ActiveRecord::Base.configurations[Rails.env]['adapter'])=='postgresql'
+					ids = ids.map{|i| i['id']}.join(',')
+				elsif adapter.begins_with? 'mysql'
+					ids = ids.flatten.join(',')
+				else
+					raise "Adapter #{adapter} not supported"
+				end
+				if ids.to_nil
+					where "id IN (#{ids})"
+				else
+					where("1=0")              # relation that matches nothing
+				end
+			}
+
+	    # Scopes to the current version of a given iid. Can only return 0 or 1 records
+	    # This and other methods beginning with "live" do not use the ver_current column
+	    scope :live_current_version, ->(aIid,aTimestamp=nil) {
+		    aTimestamp ||= KojacUtils.timestamp
+		    where(iid: aIid).where(["current_from <= ?",aTimestamp]).order('version DESC').limit(1)
+	    }
+
+	    # Scopes to current version for all iids using the ver_current column. The ver_current must be updated regularly using update_all_ver_current.
+	    # This method is much faster than live_current_versions
+	    scope :current_versions, -> {
+		    where(ver_current: true)
+	    }
+
+	    # Updates the ver_current column, which enables simpler and much faster queries on current versions eg. using current_versions instead of live_current_versions.
+	    # Must be run periodically eg. 4am daily
+	    def self.update_all_ver_current
+		    self.update_all(ver_current: false)
+		    self.live_current_versions(Time.now.to_ms).update_all(ver_current: true)
+	    end
+    end
+  end
+
+	def copyable_attributes
+		result = {}
+		self.class.columns.each do |c|
+			next if ['id', 'version'].include? c.name
+			result[c.name.to_sym] = self.send(c.name)
+		end
+		result
+	end
+
+	def new_version(aValues)
+		raise "iid must be set before calling new_version" unless self.iid
+		attrs = copyable_attributes
+		attrs[:version] = self.class.next_version_id(self.iid)
+		ver = self.class.new(attrs)
+		ver
+	end
+
+	def create_version!(aValues)
+		raise "iid must be set before calling new_version" unless self.iid
+		attrs = copyable_attributes
+		attrs[:version] = self.class.next_version_id(self.iid)
+		attrs.merge!(aValues.symbolize_keys)
+		self.class.create!(attrs)
+	end
+
+	def current_version
+		self.class.live_current_version(self.iid,KojacUtils.timestamp).first
+	end
+end

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: buzztools
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
+  prerelease: 
 platform: ruby
 authors:
 - Gary McGhee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-12 00:00:00.000000000 Z
+date: 2014-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -27,6 +30,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -34,6 +38,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -52,6 +57,7 @@ files:
 - Rakefile
 - buzztools.gemspec
 - lib/buzztools.rb
+- lib/buzztools/config.rb
 - lib/buzztools/extend_array.rb
 - lib/buzztools/extend_bignum.rb
 - lib/buzztools/extend_fixnum.rb
@@ -60,29 +66,39 @@ files:
 - lib/buzztools/extend_object.rb
 - lib/buzztools/extend_string.rb
 - lib/buzztools/extend_time.rb
+- lib/buzztools/extras/shell_extras.rb
+- lib/buzztools/file.rb
 - lib/buzztools/version.rb
+- lib/buzztools/versionary.rb
 homepage: https://github.com/buzzware/buzztools
 licenses:
 - MIT
-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'
+      segments:
+      - 0
+      hash: -3067569873639998217
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3067569873639998217
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: reusable function library
 test_files: []

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTI2MDkwZmY0Mjc1NTllMzk0NzgyMGY3YzBlNTAwNDlkNWRlOTJkNA==
-  data.tar.gz: !binary |-
-    OTg3MWE5YTQ3ODU3NGU1YmU4YjdkNGVjYzA1NGU0M2VjZDRhMDgxNA==
-SHA512:
-  metadata.gz: !binary |-
-    MDhiZTMwNmQyYWVjNmIwZDE2NjY5OTMwZmQ5NjNmNTcxZmEyOTg0YTYxZDE3
-    NzA4MDY3MDJiMDM0ZjkzMDYzNGVhYzhhYmM1MzlhOTlhNzQ1N2FjN2RlZjI2
-    ODQxYTVkMzQwMDI2YTg3ZTAxZTBkYTU1YTFkNmQ4Y2MzMDY4YzM=
-  data.tar.gz: !binary |-
-    OGZmYjZiMDllNmVkMDlmMTY0YzQ3YTFlNmJhYTQyOGU1NDYxZTZiOGZhYTJk
-    MDlmNDNmNjVmOTdiMzY0NjI0ZDA2ZmVmYTM1NTg2ZDM1ZDM0MTJjZTEwOTZh
-    YTM0MjFmMjY3ODkwYjU0NjY1OTUzMTgzNDFkMjVkZGY5ZTk2MTY=