cloudsmith-api 2.0.21 → 2.0.22

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/README.md

@@ -0,0 +1,157 @@
+Memoist
+=============
+
+[![Build Status](https://travis-ci.org/matthewrudy/memoist.svg?branch=master)](https://travis-ci.org/matthewrudy/memoist)
+
+Memoist is an extraction of ActiveSupport::Memoizable.
+
+Since June 2011 ActiveSupport::Memoizable has been deprecated.
+But I love it,
+and so I plan to keep it alive.
+
+Usage
+-----
+
+Just extend with the Memoist module
+
+```ruby
+require 'memoist'
+class Person
+  extend Memoist
+
+  def social_security
+    puts "execute!"
+    decrypt_social_security
+  end
+  memoize :social_security
+end
+
+person = Person.new
+
+person.social_security
+# execute!
+# => (returns decrypt_social_security)
+
+person.social_security
+# => (returns the memoized value)
+```
+
+And person.social_security will only be calculated once.
+
+Every memoized function (which initially was not accepting any arguments) has a ```(reload)```
+argument you can pass in to bypass and reset the memoization:
+
+```ruby
+def some_method
+  Time.now
+end
+memoize :some_method
+```
+
+Calling ```some_method``` will be memoized, but calling ```some_method(true)``` will rememoize each time.
+
+You can even memoize method that takes arguments.
+
+```ruby
+class Person
+  def taxes_due(income)
+    income * 0.40
+  end
+  memoize :taxes_due
+end
+```
+
+This will only be calculated once per value of income.
+
+You can also memoize class methods.
+
+```ruby
+class Person
+
+  class << self
+    extend Memoist
+    def with_overdue_taxes
+      # ...
+    end
+    memoize :with_overdue_taxes
+  end
+
+end
+```
+
+When a sub-class overrides one of its parent's methods and you need to memoize both. 
+Then you can use the `:identifier` parameter in order to help _Memoist_ distinguish between the two.
+
+```ruby
+class Clock
+  extend Memoist
+  def now
+     "The time now is #{Time.now.hour} o'clock and #{Time.now.min} minutes"
+  end
+  memoize :now
+end
+
+class AccurateClock < Clock
+  extend Memoist
+  def now
+    "#{super} and #{Time.now.sec} seconds"
+  end
+  memoize :now, :identifier => :accurate_clock
+end
+```
+
+
+Reload
+------
+
+Each memoized function comes with a way to flush the existing value.
+
+```ruby
+person.social_security       # returns the memoized value
+person.social_security(true) # bypasses the memoized value and rememoizes it
+```
+
+This also works with a memoized method with arguments
+
+```ruby
+person.taxes_due(100_000)       # returns the memoized value
+person.taxes_due(100_000, true) # bypasses the memoized value and rememoizes it
+```
+
+If you want to flush the entire memoization cache for an object
+
+```ruby
+person.flush_cache   # returns an array of flushed memoized methods, e.g. ["social_security", "some_method"]
+```
+
+Authors
+===========
+
+Everyone who contributed to it in the rails repository.
+
+* Joshua Peek
+* Tarmo Tänav
+* Jeremy Kemper
+* Eugene Pimenov
+* Xavier Noria
+* Niels Ganser
+* Carl Lerche & Yehuda Katz
+* jeem
+* Jay Pignata
+* Damien Mathieu
+* José Valim
+* Matthew Rudy Jacobs
+
+Contributing
+============
+
+1. Fork it ( https://github.com/matthewrudy/memoist/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+License
+=======
+
+Released under the [MIT License](http://www.opensource.org/licenses/MIT), just as Ruby on Rails is.

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/Rakefile

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task default: ['test']

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/lib/memoist/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Memoist
+  VERSION = '0.16.2'.freeze
+end

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/lib/memoist.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'memoist/version'
+
+module Memoist
+  def self.extended(extender)
+    Memoist.memoist_eval(extender) do
+      unless singleton_class.method_defined?(:memoized_methods)
+        def self.memoized_methods
+          @_memoized_methods ||= []
+        end
+      end
+    end
+  end
+
+  def self.memoized_ivar_for(method_name, identifier = nil)
+    "@#{memoized_prefix(identifier)}_#{escape_punctuation(method_name)}"
+  end
+
+  def self.unmemoized_method_for(method_name, identifier = nil)
+    "#{unmemoized_prefix(identifier)}_#{method_name}".to_sym
+  end
+
+  def self.memoized_prefix(identifier = nil)
+    if identifier
+      "_memoized_#{identifier}"
+    else
+      '_memoized'.freeze
+    end
+  end
+
+  def self.unmemoized_prefix(identifier = nil)
+    if identifier
+      "_unmemoized_#{identifier}"
+    else
+      '_unmemoized'.freeze
+    end
+  end
+
+  def self.escape_punctuation(string)
+    string = string.is_a?(String) ? string.dup : string.to_s.dup
+
+    return string unless string.end_with?('?'.freeze, '!'.freeze)
+
+    # A String can't end in both ? and !
+    if string.sub!(/\?\Z/, '_query'.freeze)
+    else
+      string.sub!(/!\Z/, '_bang'.freeze)
+    end
+    string
+  end
+
+  def self.memoist_eval(klass, *args, &block)
+    if klass.respond_to?(:class_eval)
+      klass.class_eval(*args, &block)
+    else
+      klass.singleton_class.class_eval(*args, &block)
+    end
+  end
+
+  def self.extract_reload!(method, args)
+    if args.length == method.arity.abs + 1 && (args.last == true || args.last == :reload)
+      reload = args.pop
+    end
+    reload
+  end
+
+  module InstanceMethods
+    def memoize_all
+      prime_cache
+    end
+
+    def unmemoize_all
+      flush_cache
+    end
+
+    def memoized_structs(names)
+      ref_obj = self.class.respond_to?(:class_eval) ? singleton_class : self
+      structs = ref_obj.all_memoized_structs
+      return structs if names.empty?
+
+      structs.select { |s| names.include?(s.memoized_method) }
+    end
+
+    def prime_cache(*method_names)
+      memoized_structs(method_names).each do |struct|
+        if struct.arity == 0
+          __send__(struct.memoized_method)
+        else
+          instance_variable_set(struct.ivar, {})
+        end
+      end
+    end
+
+    def flush_cache(*method_names)
+      memoized_structs(method_names).each do |struct|
+        remove_instance_variable(struct.ivar) if instance_variable_defined?(struct.ivar)
+      end
+    end
+  end
+
+  MemoizedMethod = Struct.new(:memoized_method, :ivar, :arity)
+
+  def all_memoized_structs
+    @all_memoized_structs ||= begin
+      structs = memoized_methods.dup
+
+      # Collect the memoized_methods of ancestors in ancestor order
+      # unless we already have it since self or parents could be overriding
+      # an ancestor method.
+      ancestors.grep(Memoist).each do |ancestor|
+        ancestor.memoized_methods.each do |m|
+          structs << m unless structs.any? { |am| am.memoized_method == m.memoized_method }
+        end
+      end
+      structs
+    end
+  end
+
+  def clear_structs
+    @all_memoized_structs = nil
+  end
+
+  def memoize(*method_names)
+    identifier = method_names.pop[:identifier] if method_names.last.is_a?(Hash)
+
+    method_names.each do |method_name|
+      unmemoized_method = Memoist.unmemoized_method_for(method_name, identifier)
+      memoized_ivar = Memoist.memoized_ivar_for(method_name, identifier)
+
+      Memoist.memoist_eval(self) do
+        include InstanceMethods
+
+        if method_defined?(unmemoized_method)
+          warn "Already memoized #{method_name}"
+          return
+        end
+        alias_method unmemoized_method, method_name
+
+        mm = MemoizedMethod.new(method_name, memoized_ivar, instance_method(method_name).arity)
+        memoized_methods << mm
+        if mm.arity == 0
+
+          # define a method like this;
+
+          # def mime_type(reload=true)
+          #   skip_cache = reload || !instance_variable_defined?("@_memoized_mime_type")
+          #   set_cache = skip_cache && !frozen?
+          #
+          #   if skip_cache
+          #     value = _unmemoized_mime_type
+          #   else
+          #     value = @_memoized_mime_type
+          #   end
+          #
+          #   if set_cache
+          #     @_memoized_mime_type = value
+          #   end
+          #
+          #   value
+          # end
+
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(reload = false)
+              skip_cache = reload || !instance_variable_defined?("#{memoized_ivar}")
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}
+              else
+                value = #{memoized_ivar}
+              end
+
+              if set_cache
+                #{memoized_ivar} = value
+              end
+
+              value
+            end
+          EOS
+        else
+
+          # define a method like this;
+
+          # def mime_type(*args)
+          #   reload = Memoist.extract_reload!(method(:_unmemoized_mime_type), args)
+          #
+          #   skip_cache = reload || !memoized_with_args?(:mime_type, args)
+          #   set_cache = skip_cache && !frozen
+          #
+          #   if skip_cache
+          #     value = _unmemoized_mime_type(*args)
+          #   else
+          #     value = @_memoized_mime_type[args]
+          #   end
+          #
+          #   if set_cache
+          #     @_memoized_mime_type ||= {}
+          #     @_memoized_mime_type[args] = value
+          #   end
+          #
+          #   value
+          # end
+
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(*args)
+              reload = Memoist.extract_reload!(method(#{unmemoized_method.inspect}), args)
+
+              skip_cache = reload || !(instance_variable_defined?(#{memoized_ivar.inspect}) && #{memoized_ivar} && #{memoized_ivar}.has_key?(args))
+              set_cache = skip_cache && !frozen?
+
+              if skip_cache
+                value = #{unmemoized_method}(*args)
+              else
+                value = #{memoized_ivar}[args]
+              end
+
+              if set_cache
+                #{memoized_ivar} ||= {}
+                #{memoized_ivar}[args] = value
+              end
+
+              value
+            end
+          EOS
+        end
+
+        if private_method_defined?(unmemoized_method)
+          private method_name
+        elsif protected_method_defined?(unmemoized_method)
+          protected method_name
+        end
+      end
+    end
+    # return a chainable method_name symbol if we can
+    method_names.length == 1 ? method_names.first : method_names
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/memoist.gemspec

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memoist/version'
+
+AUTHORS = [
+  ['Joshua Peek',               'josh@joshpeek.com'],
+  ['Tarmo Tänav',               'tarmo@itech.ee'],
+  ['Jeremy Kemper',             'jeremy@bitsweat.net'],
+  ['Eugene Pimenov',            'libc@mac.com'],
+  ['Xavier Noria',              'fxn@hashref.com'],
+  ['Niels Ganser',              'niels@herimedia.co'],
+  ['Carl Lerche & Yehuda Katz', 'wycats@gmail.com'],
+  ['jeem',                      'jeem@hughesorama.com'],
+  ['Jay Pignata',               'john.pignata@gmail.com'],
+  ['Damien Mathieu',            '42@dmathieu.com'],
+  ['José Valim',                'jose.valim@gmail.com'],
+  ['Matthew Rudy Jacobs',       'matthewrudyjacobs@gmail.com']
+].freeze
+
+Gem::Specification.new do |spec|
+  spec.name          = 'memoist'
+  spec.version       = Memoist::VERSION
+  spec.authors       = AUTHORS.map { |name, _email| name }
+  spec.email         = AUTHORS.map { |_name, email| email }
+  spec.summary       = 'memoize methods invocation'
+  spec.homepage      = 'https://github.com/matthewrudy/memoist'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.2'
+
+  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'bundler'
+  if RUBY_VERSION < '1.9.3'
+    spec.add_development_dependency 'rake', '~> 10.4'
+  else
+    spec.add_development_dependency 'rake'
+  end
+  spec.add_development_dependency 'minitest', '~> 5.10'
+end

data/vendor/bundle/ruby/2.6.0/gems/memoist-0.16.2/script/benchmark.rb

@@ -0,0 +1,48 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'benchmark/ips'
+
+require 'memoist'
+
+class Benchy
+  extend Memoist
+
+  def arity_0
+    'Hello World'
+  end
+  memoize :arity_0
+
+  def arity_1(name)
+    "Hello #{name}"
+  end
+  memoize :arity_1
+end
+
+OBJECT = Benchy.new
+
+puts "Benchmarking: #{Memoist::VERSION}"
+
+Benchmark.ips do |x|
+  x.report('arity 0 - memoized') do |times|
+    times.times do
+      OBJECT.arity_0
+    end
+  end
+
+  # x.report("arity 0 - unmemoized") do |times|
+  #   times.times do
+  #     OBJECT._unmemoized_arity_0
+  #   end
+  # end
+
+  x.report('arity 1 - memoized') do |times|
+    times.times do
+      OBJECT.arity_1(:World)
+    end
+  end
+
+  # x.report("arity 1 - unmemoized") do |times|
+  #   times.times do
+  #     OBJECT._unmemoized_arity_1(:World)
+  #   end
+  # end
+end