mize 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a3d262bfae6dc90882b9a6deeb29a655bebd647
+  data.tar.gz: 9e606ff6fae19a19b6c83f263e3d6ae58f18589a
+SHA512:
+  metadata.gz: a2754ca93ed9e827b50d3f8528a535a9ac69790d8defbc9510d0408d4a0128a7f3b8a3356f5420a856cbb141b8fb42c187732be8ee934d6d03fb1a1db40b91c5
+  data.tar.gz: 715c53aa026e8270bcc9fc9e4fed0a35bafdc6514b57ce11c023d1e2797f113b073a7c2e9c2220bf5a374c1dda809e64443b54b4f5c6e9fe81716eec275144e9

data/.gitignore

@@ -0,0 +1,10 @@
+.*.sw[pon]
+.AppleDouble
+.byebug_history
+.rvmrc
+.yard*
+Gemfile.lock
+coverage
+errors.lst
+pkg
+tags

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-fd

data/.travis.yml

@@ -0,0 +1,10 @@
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - jruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/.utilsrc

@@ -0,0 +1,26 @@
+# vim: set ft=ruby:
+
+search do
+  prune_dirs /\A(\.svn|\.git|CVS|tmp|tags|coverage|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.(log|fnm|jpg|jpeg|png|pdf|svg)\z|tags|~\z)/i
+end
+
+discover do
+  prune_dirs /\A(\.svn|\.git|CVS|tmp|tags|coverage|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.log\z|~\z)/
+  binary false
+end
+
+strip_spaces do
+  prune_dirs /\A(\..*|CVS|pkg)\z/
+  skip_files /(\A\.|\.sw[pon]\z|\.log\z|~\z)/
+end
+
+probe do
+  test_framework :rspec
+  #include_dirs 'features'
+end
+
+ssh_tunnel do
+  terminal_multiplexer :tmux
+end

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,39 @@
+# Mize
+
+## Description
+
+
+## Installation
+
+You can use rubygems to fetch the gem and install it for you:
+
+    # gem install mize
+
+You can also put this line into your Gemfile
+
+    gem 'mize'
+
+and bundle.
+
+## Usage
+
+### Configuration
+
+
+## Changes
+
+* 2015-12-10 Release 0.0.0
+
+## Download
+
+The homepage of this library is located at
+
+* https://github.com/flori/mize
+
+## Author
+
+[Florian Frank](mailto:flori@ping.de)
+
+## License
+
+This software is licensed under MIT license.

data/Rakefile

@@ -0,0 +1,55 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'mize'
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "http://flori.github.com/#{name}"
+  summary     'Library that provides memoziation for methods and functions'
+  description "#{summary} for Ruby."
+  readme      'README.md'
+  licenses << 'MIT'
+
+  test_dir    'spec'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', 'coverage', '.rvmrc',
+    '.AppleDouble', 'tags', '.byebug_history', '.yard*', 'errors.lst'
+
+
+  dependency 'protocol'
+  development_dependency 'rake'
+  development_dependency 'simplecov'
+  development_dependency 'rspec'
+  development_dependency 'yard'
+  development_dependency 'byebug'
+
+  required_ruby_version '>= 2'
+end
+
+namespace :yard do
+  require 'pathname'
+
+  yard_dir = Pathname.new('yard')
+
+  desc 'Create yard documentation'
+  task :create do
+    sh 'yardoc'
+  end
+
+  desc 'View the yard documentation'
+  task :view do
+    index_file = yard_dir + 'index.html'
+    File.exist?(index_file)
+    sh "open #{index_file}"
+  end
+
+  desc 'Clean the yard documentation'
+  task :clean do
+    rm_rf yard_dir
+  end
+end
+
+task :yard => %i[ yard:create yard:view ]
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/config/broken_config.yml

@@ -0,0 +1 @@
+,kaput

data/config/config.yml

@@ -0,0 +1,13 @@
+development:
+  config:
+    foo: true
+    bar: false
+    baz: 'something'
+    pi:  <%= Math::PI %>
+
+test:
+  config:
+    foo: false
+    bar: true
+    baz: 'something else'
+    pi:  3.141

data/lib/mize/cache_methods.rb

@@ -0,0 +1,52 @@
+require 'mize/cache_protocol'
+require 'mize/default_cache'
+
+module Mize::CacheMethods
+  # Clear cached values for all methods/functions of this object.
+  def mize_cache_clear
+    __mize_cache__.clear
+    self
+  end
+
+  private
+
+  # Set the cache object to +cache+.
+  def __mize_cache__=(cache)
+    Mize::CacheProtocol.check cache
+    @__mize_cache__ = cache
+  end
+
+  # Return the cache object.
+  def __mize_cache__
+    if @__mize_cache__
+      @__mize_cache__
+    else
+      self.__mize_cache__ = Mize.default_cache.prototype
+    end
+  end
+
+  # Build a key prefix for +name+.
+  def build_key_prefix(name)
+    "mize/#{name}"
+  end
+
+  # Build a +name+ prefixed key for the arguments +args+.
+  def build_key(name, *args)
+    "#{build_key_prefix(name)}/#{Marshal.dump(args)}"
+  end
+
+  # Apply the visibility of method +id+ to the wrapper method of this method.
+  def memoize_apply_visibility(id)
+    visibility = instance_eval do
+      case
+      when private_method_defined?(id)
+        :private
+      when protected_method_defined?(id)
+        :protected
+      end
+    end
+    yield
+  ensure
+    visibility and __send__(visibility, id)
+  end
+end

data/lib/mize/cache_protocol.rb

@@ -0,0 +1,32 @@
+require 'protocol'
+
+# The protocol the cache object has to conform to. This is a minimal subset of
+# the ActiveSupport::Cache::Store protocol.
+Mize::CacheProtocol = Protocol do
+  # Clear the entire cache.
+  def clear(options = nil)
+  end
+
+  # Returns true if the cache contains an entry for the given key.
+  def exist?(name, options = nil)
+  end
+
+  # Fetches data from the cache, using the given key. If there is data in the
+  # cache with the given key, then that data is returned. Otherwise, nil is
+  # returned.
+  def read(name, options = nil)
+  end
+
+  # Writes the value to the cache, with the key.
+  def write(name, value, options = nil)
+  end
+
+  # Iterate over all cache entries and yield to their names.
+  def each_name(&block)
+  end
+
+  # Return another cache instance that was correctly configured.
+  def prototype
+    dup
+  end
+end

data/lib/mize/configure.rb

@@ -0,0 +1,17 @@
+module Mize::Configure
+  attr_accessor :default_cache
+
+  def cache(cache)
+    self.default_cache = cache
+  end
+
+  def configure(&block)
+    instance_eval(&block)
+  end
+end
+
+module Mize
+  extend Mize::Configure
+end
+
+Mize.default_cache = Mize::DefaultCache.new

data/lib/mize/default_cache.rb

@@ -0,0 +1,33 @@
+require 'monitor'
+
+class Mize::DefaultCache < Hash
+  include MonitorMixin
+
+  private(*(instance_methods - Object.instance_methods - %i[ synchronize ]))
+
+  def clear(options = nil)
+    super()
+  end
+
+  def exist?(name, options = nil)
+    key?(name)
+  end
+
+  def read(name, options = nil)
+    fetch(name, nil)
+  end
+
+  def write(name, value, options = nil)
+    store(name, value)
+  end
+
+  def delete(name, options = nil)
+    super(name)
+  end
+
+  def each_name(&block)
+    each_key(&block)
+  end
+
+  alias prototype dup
+end

data/lib/mize/global_clear.rb

@@ -0,0 +1,41 @@
+require 'monitor'
+
+module Mize
+  class << self
+
+    # Clear all memoization caches at once.
+    def cache_clear
+      each_cache do |id, cache|
+        cache and cache.clear
+        cache_tracker.delete id
+      end
+    end
+
+    private
+
+    def each_cache
+      cache_tracker.synchronize do
+        cache_tracker.each_name do |id|
+          begin
+            cache = ObjectSpace._id2ref id
+          rescue RangeError
+          end
+          yield id, cache
+        end
+      end
+    end
+
+    def cache_tracker
+      @cache_tracker ||= Mize.default_cache.dup
+    end
+
+    def track_cache(cache_id)
+      cache_tracker.exist?(cache_id) and return
+      cache_tracker.synchronize do
+        cache_tracker.write cache_id, true
+      end
+    end
+  end
+
+  cache_tracker
+end

data/lib/mize/memoize.rb

@@ -0,0 +1,61 @@
+require 'mize/cache_methods'
+require 'mize/reload'
+
+module Mize
+  module Memoize
+    include CacheMethods
+
+    # Memoize either a +method+ or a +function+. In the former case the
+    # memoized results do NOT ONLY depend on the arguments, but ALSO on the
+    # object the method is called on. In the latter the memoized results ONLY
+    # depend on the arguments given to the function. If the +freeze+ argument
+    # is true, the result is frozen if possible to make it immutable.
+    def memoize(method: nil, function: nil, freeze: false)
+      if method && function
+        raise ArgumentError, 'memoize a method xor a function'
+      elsif method
+        wrap_method method, freeze: freeze
+      elsif function
+        wrap_method function, function: true, freeze: freeze
+      else
+        raise ArgumentError, 'missing keyword: method/function'
+      end
+    end
+
+    private
+
+    def wrap_method(method_id, freeze: false, function: false)
+      include CacheMethods
+
+      mc = __mize_cache__
+
+      unless function
+        prepend Mize::Reload
+      end
+
+      method_id = method_id.to_s.to_sym
+      memoize_apply_visibility method_id do
+        orig_method = instance_method(method_id)
+        __send__(:define_method, method_id) do |*args|
+          function or mc = __mize_cache__
+          Mize.__send__ :track_cache, mc.__id__
+          key = build_key(method_id, *args)
+          if mc.exist?(key) and result = mc.read(key)
+            result
+          else
+            result = orig_method.bind(self).call(*args)
+            mc.write(key, result)
+            if $DEBUG
+              warn "#{self.class} cached method "\
+                "#{method_id}(#{args.inspect unless args.empty?}) = "\
+                "#{result.inspect} [#{__id__}]"
+            end
+            freeze and result.freeze rescue result
+          end
+          result
+        end
+      end
+      method_id
+    end
+  end
+end

data/lib/mize/railtie.rb

@@ -0,0 +1,8 @@
+module Mize
+  class Railtie < Rails::Railtie
+    config.to_prepare do
+      Mize.cache_clear
+    end
+  end
+end
+

data/lib/mize/reload.rb

@@ -0,0 +1,12 @@
+module Mize::Reload
+  # Reload this object if a #reload method was provided up somewhere in the
+  # inheritance tree, afterwards clear the memoization cache and return self.
+  def reload(*)
+    result = self
+    if defined? super
+      result = super
+    end
+    mize_cache_clear
+    result
+  end
+end

data/lib/mize/version.rb

@@ -0,0 +1,8 @@
+module Mize
+  # Mize version
+  VERSION         = '0.0.0'
+  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/mize.rb

@@ -0,0 +1,12 @@
+module Mize
+end
+
+require 'mize/version'
+require 'mize/memoize'
+require 'mize/configure'
+require 'mize/global_clear'
+require 'mize/railtie' if defined? Rails
+
+class ::Module
+  prepend Mize::Memoize
+end

data/mize.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+# stub: mize 0.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "mize"
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Florian Frank"]
+  s.date = "2016-01-28"
+  s.description = "Library that provides memoziation for methods and functions for Ruby."
+  s.email = "flori@ping.de"
+  s.extra_rdoc_files = ["README.md", "lib/mize.rb", "lib/mize/cache_methods.rb", "lib/mize/cache_protocol.rb", "lib/mize/configure.rb", "lib/mize/default_cache.rb", "lib/mize/global_clear.rb", "lib/mize/memoize.rb", "lib/mize/railtie.rb", "lib/mize/reload.rb", "lib/mize/version.rb"]
+  s.files = [".gitignore", ".rspec", ".travis.yml", ".utilsrc", "Gemfile", "README.md", "Rakefile", "VERSION", "config/broken_config.yml", "config/config.yml", "lib/mize.rb", "lib/mize/cache_methods.rb", "lib/mize/cache_protocol.rb", "lib/mize/configure.rb", "lib/mize/default_cache.rb", "lib/mize/global_clear.rb", "lib/mize/memoize.rb", "lib/mize/railtie.rb", "lib/mize/reload.rb", "lib/mize/version.rb", "mize.gemspec", "spec/mize/global_clear_spec.rb", "spec/mize/memoize_method_spec.rb", "spec/mize/memoize_reload_spec.rb", "spec/mize/version_spec.rb", "spec/spec_helper.rb"]
+  s.homepage = "http://flori.github.com/mize"
+  s.licenses = ["MIT"]
+  s.rdoc_options = ["--title", "Mize - Library that provides memoziation for methods and functions", "--main", "README.md"]
+  s.required_ruby_version = Gem::Requirement.new(">= 2")
+  s.rubygems_version = "2.5.1"
+  s.summary = "Library that provides memoziation for methods and functions"
+  s.test_files = ["spec/mize/global_clear_spec.rb", "spec/mize/memoize_method_spec.rb", "spec/mize/memoize_reload_spec.rb", "spec/mize/version_spec.rb", "spec/spec_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<gem_hadar>, ["~> 1.3.1"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<byebug>, [">= 0"])
+      s.add_runtime_dependency(%q<protocol>, [">= 0"])
+    else
+      s.add_dependency(%q<gem_hadar>, ["~> 1.3.1"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<byebug>, [">= 0"])
+      s.add_dependency(%q<protocol>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<gem_hadar>, ["~> 1.3.1"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<byebug>, [">= 0"])
+    s.add_dependency(%q<protocol>, [">= 0"])
+  end
+end

data/spec/mize/global_clear_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class Foo
+  def self.reset
+    @@foo = nil
+  end
+
+  def reload
+    @reload = true
+    self
+  end
+
+  def foo(*a)
+    @@foo ||= 0
+    @@foo += 1
+  end
+  memoize method: :foo
+end
+
+describe Mize, 'cache_clear' do
+  let(:foo) { Foo.new }
+
+  describe '#cache_clear' do
+    it 'clears cache after Mize.cache_clear' do
+      expect(foo.foo).to eq 1
+      expect(foo.foo).to eq 1
+      Mize.cache_clear
+      expect(foo.foo).to eq 2
+    end
+  end
+end

data/spec/mize/memoize_method_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+class FooBar
+  def self.reset
+    @@foo = nil
+    @@bar = nil
+    @@baz = nil
+    mize_cache_clear
+  end
+
+  def foo(*a)
+    @@foo ||= 0
+    @@foo += 1
+  end
+  memoize method: :foo
+
+  def footsie(*a)
+    @@footsie ||= 0
+    @@footsie += 1
+  end
+  protected :footsie
+  memoize method: :footsie
+
+  def bar(*a)
+    @@bar ||= 0
+    @@bar += 1
+  end
+  memoize function: :bar
+
+  private
+
+  def baz(*a)
+    @@baz ||= 0
+    @@baz += 1
+  end
+  memoize function: :baz
+end
+
+describe Mize do
+  before do
+    FooBar.reset
+    class ::Mize::DefaultCache
+      public :empty?
+    end
+  end
+
+  let(:fb1) { FooBar.new }
+
+  let(:fb2) { FooBar.new }
+
+  context 'memoize method' do
+    it 'can cache methods' do
+      expect(fb1.__send__(:__mize_cache__)).to be_empty
+      expect(fb2.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.foo(1, 2)).to eq 1
+      expect(fb2.foo(1, 2)).to eq 2
+      expect(fb1.foo(1, 2, 3)).to eq 3
+      expect(fb2.foo(1, 2, 3)).to eq 4
+      expect(fb1.foo(1, 2)).to eq 1
+      expect(fb2.foo(1, 2)).to eq 2
+      fb1.mize_cache_clear
+      fb2.mize_cache_clear
+      expect(fb1.__send__(:__mize_cache__)).to be_empty
+      expect(fb2.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.foo(1, 2)).to eq 5
+      expect(fb2.foo(1, 2)).to eq 6
+      expect(fb1.foo(1, 2)).to eq 5
+      expect(fb2.foo(1, 2)).to eq 6
+      expect(fb1.__send__(:__mize_cache__)).not_to be_empty
+      expect(fb2.__send__(:__mize_cache__)).not_to be_empty
+    end
+
+    it 'can cache protected methods' do
+      expect(fb1.__send__(:__mize_cache__)).to be_empty
+      expect(fb2.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.__send__(:footsie, 1, 2)).to eq 1
+      expect(fb2.__send__(:footsie, 1, 2)).to eq 2
+      expect(fb1.__send__(:footsie, 1, 2, 3)).to eq 3
+      expect(fb2.__send__(:footsie, 1, 2, 3)).to eq 4
+      expect(fb1.__send__(:footsie, 1, 2)).to eq 1
+      expect(fb2.__send__(:footsie, 1, 2)).to eq 2
+      fb1.mize_cache_clear
+      fb2.mize_cache_clear
+      expect(fb1.__send__(:__mize_cache__)).to be_empty
+      expect(fb2.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.__send__(:footsie, 1, 2)).to eq 5
+      expect(fb2.__send__(:footsie, 1, 2)).to eq 6
+      expect(fb1.__send__(:footsie, 1, 2)).to eq 5
+      expect(fb2.__send__(:footsie, 1, 2)).to eq 6
+      expect(fb1.__send__(:__mize_cache__)).not_to be_empty
+      expect(fb2.__send__(:__mize_cache__)).not_to be_empty
+    end
+  end
+
+  context 'memoize function' do
+    it 'can cache functions' do
+      expect(FooBar.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.bar(1, 2)).to eq 1
+      expect(fb2.bar(1, 2)).to eq 1
+      expect(fb1.bar(1, 2, 3)).to eq 2
+      expect(fb2.bar(1, 2, 3)).to eq 2
+      expect(fb1.bar(1, 2)).to eq 1
+      expect(fb2.bar(1, 2)).to eq 1
+      FooBar.mize_cache_clear
+      expect(fb1.bar(1, 2)).to eq 3
+      expect(fb2.bar(1, 2)).to eq 3
+      expect(FooBar.__send__(:__mize_cache__)).not_to be_empty
+    end
+
+    it 'can cache private functions' do
+      expect(FooBar.__send__(:__mize_cache__)).to be_empty
+      expect(fb1.__send__(:baz, 1, 2)).to eq 1
+      expect(fb2.__send__(:baz, 1, 2)).to eq 1
+      expect(fb1.__send__(:baz, 1, 2, 3)).to eq 2
+      expect(fb2.__send__(:baz, 1, 2, 3)).to eq 2
+      expect(fb1.__send__(:baz, 1, 2)).to eq 1
+      expect(fb2.__send__(:baz, 1, 2)).to eq 1
+      FooBar.mize_cache_clear
+      expect(fb1.__send__(:baz, 1, 2)).to eq 3
+      expect(fb2.__send__(:baz, 1, 2)).to eq 3
+      expect(FooBar.__send__(:__mize_cache__)).not_to be_empty
+    end
+  end
+end

data/spec/mize/memoize_reload_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class Foo
+  def self.reset
+    @@foo = nil
+  end
+
+  def reload
+    @reload = true
+    self
+  end
+
+  def foo(*a)
+    @@foo ||= 0
+    @@foo += 1
+  end
+  memoize method: :foo
+end
+
+describe Mize::Reload do
+  before do
+    Foo.reset
+  end
+
+  let(:foo) { Foo.new }
+
+  describe '#reload' do
+    it 'clears cache after reload' do
+      expect(foo.foo).to eq 1
+      expect(foo.foo).to eq 1
+      expect(foo.reload.foo).to eq 2
+    end
+  end
+end

data/spec/mize/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Mize::VERSION do
+  it 'has a version' do
+    expect(Mize::VERSION).to be_a String
+    expect(Mize::VERSION).to match /\d+./
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+if ENV['START_SIMPLECOV'].to_i == 1
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "#{File.basename(File.dirname(__FILE__))}/"
+  end
+end
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+require 'rspec'
+begin
+  require 'byebug'
+rescue LoadError
+end
+require 'mize'

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: mize
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Florian Frank
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gem_hadar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: protocol
+  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: Library that provides memoziation for methods and functions for Ruby.
+email: flori@ping.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- lib/mize.rb
+- lib/mize/cache_methods.rb
+- lib/mize/cache_protocol.rb
+- lib/mize/configure.rb
+- lib/mize/default_cache.rb
+- lib/mize/global_clear.rb
+- lib/mize/memoize.rb
+- lib/mize/railtie.rb
+- lib/mize/reload.rb
+- lib/mize/version.rb
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".utilsrc"
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- config/broken_config.yml
+- config/config.yml
+- lib/mize.rb
+- lib/mize/cache_methods.rb
+- lib/mize/cache_protocol.rb
+- lib/mize/configure.rb
+- lib/mize/default_cache.rb
+- lib/mize/global_clear.rb
+- lib/mize/memoize.rb
+- lib/mize/railtie.rb
+- lib/mize/reload.rb
+- lib/mize/version.rb
+- mize.gemspec
+- spec/mize/global_clear_spec.rb
+- spec/mize/memoize_method_spec.rb
+- spec/mize/memoize_reload_spec.rb
+- spec/mize/version_spec.rb
+- spec/spec_helper.rb
+homepage: http://flori.github.com/mize
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title"
+- Mize - Library that provides memoziation for methods and functions
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Library that provides memoziation for methods and functions
+test_files:
+- spec/mize/global_clear_spec.rb
+- spec/mize/memoize_method_spec.rb
+- spec/mize/memoize_reload_spec.rb
+- spec/mize/version_spec.rb
+- spec/spec_helper.rb