prosto_cache 0.1.3 → 0.2.0

data/Gemfile

@@ -1,9 +1,7 @@
 source "http://rubygems.org"
 
 group :development do
-  gem "rspec", "~> 2.3.0"
-  gem "bundler", "~> 1.1.0"
-  gem "rake", "0.8.7"
+  gem "rspec" #, "~> 2.3.0"
+  gem "bundler" #, "~> 1.1.0"
+  gem "rake" #, "0.8.7"
 end
-
-gem "hashie", ">= 1.0.0"

data/Gemfile.lock

@@ -1,23 +1,21 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
-    hashie (1.0.0)
-    rake (0.8.7)
-    rspec (2.3.0)
-      rspec-core (~> 2.3.0)
-      rspec-expectations (~> 2.3.0)
-      rspec-mocks (~> 2.3.0)
-    rspec-core (2.3.1)
-    rspec-expectations (2.3.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.3.0)
+    diff-lcs (1.2.4)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.1.0)
-  hashie (>= 1.0.0)
-  rake (= 0.8.7)
-  rspec (~> 2.3.0)
+  bundler
+  rake
+  rspec

data/Rakefile

@@ -6,4 +6,7 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.fail_on_error = false
 end
+
+task :default => :spec

data/lib/prosto_cache.rb

@@ -1,63 +1,117 @@
 =begin
 This library provides a simple way to cache model and to access this cache in some canonical way.
 Any changes to the model's objects will automatically result in cache reload.
-Cache reload in other ruby processes of same app will be triggered as well, but with some delay (currently up to 60 seconds).
-If delay in cache reloading is not an option, well, this simply library will not work for you, and you have to use something fancier, like Memcached.
+Cache reload in other ruby processes of same app will be triggered as well, but
+with some delay (currently up to 60 seconds).
+If delay in cache reloading is not an option, well, this simply library will
+not work for you, and you have to use something fancier, like Memcached.
 
 Usage:
-1. add ProstoCache mixin to your model
+
+* Add ProstoCache mixin to your model
   class YourModel < ActiveRecord::Base
     include ProstoCache
-2. Configure cache access keys (optional step, by default cache is accessed by key 'name')
+
+* Configure cache access keys (optional step, by default cache is accessed by key 'name')
   cache_accessor_keys %w(scope name)
-3. Your model must have non-nullable column updated_at, add it in migration if it is missing (this field is used for invalidating cache in other ruby processes).
-4. Access cached model object in your code like this
+
+* Your model must have non-nullable column updated_at, add it in migration if
+  it is missing (this field is used for invalidating cache in other ruby processes).
+
+* Access cached model object in your code like this
   Simple case of one key
     YourModel.cache[:key1]
-  Case of 2 or more keys where it is known ahead of time that all parent keys exist. Looks conventional, but is unreliable because brackets operation on nill will raise an error.
-    YourModel.cache[:key1][:key2][:key3]
-  Case of 2 or more keys where any key may not be present in cache, and expected answer is nil. Looks so-so, but is much more reliable then previos use case.
-    YourModel.cache[[:key1, :key2, :key3]]
-5. If you want to, you can add extra lookup helpers to the objects that relate to the cached object, that will allow those objects to update 'string' attribute, and that will result in database reference change.
+  Case of 2 or more keys
+    YourModel.cache[:key1, :key2, :key3]
+
+* Handling of non-existing cache values.
+  If cache is accessed using symbol key and value not found, it will raise BadCacheKeyError.
+  If cache is accessed using string key and value not found, it will return nil.
+  For complex keys type of last key component is the one taken into account.
+
+* If you want to, you can add extra lookup helpers to the objects that relate
+  to the cached object, that will allow those objects to update 'string'
+  attribute, and that will result in database reference change.
     class OtherModel < ActiveRecord::Base
       belongs_to :your_model
       lookup_enum_for :your_model
     end
-    
-    This lookup was intertionally not integrated with ActiveRecord since not everybody would want that, and monkey-patching other library (AR) is not really a good thing, even if it results in more magically 'smooth' experience.
-    Principle of least surprise, right?
-=end
 
-require 'hashie'
+  This lookup was intertionally not integrated 'seamlessly' with ActiveRecord since not
+  everybody would want that, and monkey-patching other library (AR) is not really
+  a good thing, even if it results in more 'smooth' experience where everything works as if by magic.
+=end
 
 module ProstoCache
+  class BadCacheKeyError < StandardError; end
+  class BadCacheValuesError < StandardError; end
+
   # cache itself, contains pretty much all the logic
   class ProstoModelCache
-    attr_accessor :model_class, :cache, :signature, :validated_at, :accessor_keys
+
+    class ProstoHash
+      extend Forwardable
+      def initialize(hash = {})
+        @hash = hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
+      end
+
+      def [](key)
+        raise ArgumentError unless key
+        hash[key.to_sym]
+      end
+
+      def []=(key, value)
+        raise ArgumentError unless key
+        hash[key.to_sym] = value
+      end
+
+      def_delegators :hash, :to_s, :inspect
+
+      private
+
+      attr_reader :hash
+    end
+
+    def self.fail_on_missing_value?(litmus)
+      case litmus
+      when Symbol
+        true
+      when String
+        false
+      else
+        raise ArgumentError, "Unknown type of cache key #{litmus.inspect}"
+      end
+    end
+
+    MAX_CACHE_LIFE = 60 # seconds
 
     def initialize(model_class, accessor_keys)
-      self.model_class = model_class
-      self.accessor_keys = accessor_keys || 'name'
+      raise ArgumentError, "No model class provided" unless model_class
+
+      @model_class = model_class
+      @accessor_keys = [*(accessor_keys || :name)]
     end
 
     def invalidate
       self.cache = self.signature = self.validated_at = nil
     end
 
-    def [](keys)
-      if keys.respond_to?(:to_ary)
-        keys_ary = keys.to_ary
-        if keys_ary.empty?
-          nil
-        else
-          # looks like an array of key was passed in, lets try them one after another, without failing
-          keys_ary.inject(safe_cache) do |memo,key|
-            break unless memo
-            memo[key]
+    def [](*keys)
+      unless keys.length == accessor_keys.length
+        raise BadCacheKeyError, "Cached accessed by #{keys.length} keys, expected #{accessor_keys.length}"
+      end
+
+      keys.zip((1..keys.length)).inject(safe_cache) do |memo, (key, index)|
+        value = memo[key]
+        unless value
+          if ProstoModelCache.fail_on_missing_value?(keys.last)
+            raise BadCacheKeyError, key
+          else
+            value = ProstoHash.new unless index == keys.length
           end
         end
-      else
-        safe_cache[keys]
+
+        value
       end
     end
 
@@ -71,56 +125,71 @@ module ProstoCache
 
     private
 
+    attr_reader :model_class, :cache, :signature, :validated_at, :accessor_keys
+    attr_writer :cache, :signature, :validated_at
+
     def safe_cache
-      max_cache_life = 60 # seconds
-      current_time = Time.now.to_i
+      time = Time.now.to_i
+
+      if cache && validated_at < time - MAX_CACHE_LIFE
+        current_cache_signature = validate_cache_signature(time)
+      end
+
+      unless cache
+        load_cache(time, current_cache_signature)
+      end
 
-      if cache && validated_at < current_time - max_cache_life
-        current_cache_signature = query_cache_signature
+      cache
+    end
+
+    def validate_cache_signature(time)
+      query_cache_signature.tap { |current_cache_signature|
         if current_cache_signature == signature
-          self.validated_at = current_time
+          self.validated_at = time
         else
           invalidate
         end
-      end
+      }
+    end
 
-      unless cache
-        current_cache_signature ||= query_cache_signature
+    def load_cache(time, current_cache_signature = nil)
+      fail "Can not load already loaded cache" if cache
 
-        self.cache = build_cache(model_class.all, accessor_keys)
-        self.validated_at = current_time
-        self.signature = current_cache_signature
-      end
+      current_cache_signature ||= query_cache_signature
 
-      return cache
+      self.cache = build_cache(model_class.all, accessor_keys)
+      self.validated_at = time
+      self.signature = current_cache_signature
     end
 
-    def build_cache(objects, attributes=nil)
-      attributes = [*attributes] if attributes
-      if !attributes || attributes.empty?
+
+    def build_cache(objects, attributes=[])
+      attributes = [*attributes]
+      if attributes.empty?
         # terminal case
-        raise "No cache entry found" if objects.nil? || objects.empty?
-        raise "Non deterministic search result, more then one cache entry found" if objects.size > 1
+        raise BadCacheValuesError, "No cache entry found" if objects.nil? || objects.empty?
+        raise BadCacheValuesError, "Non deterministic search result, more then one cache entry found" if objects.size > 1
         return objects.first
       else
         reduced_attributes = attributes.dup
         attribute = reduced_attributes.delete_at(0).to_sym
-        array_map = objects.inject({}) do |memo, o|
+        # first, bucketize to reduce problem's complexity
+        array_map = objects.each_with_object({}) do |o, memo|
           key = o.send(attribute).to_s
           memo[key] ||= []
           memo[key] << o
-          memo
         end
-        array_map.inject(Hashie::Mash.new) do |memo, (k, v)|
-          # recursion !
-          memo[k] = build_cache(v, reduced_attributes)
-          memo
+        # second, recurse and build cache from those reduced buckets!
+        array_map.each_with_object(ProstoHash.new) do |(attr_value, attr_bucket), memo|
+          memo[attr_value] = build_cache(attr_bucket, reduced_attributes)
         end
       end
     end
 
     def query_cache_signature
-      raw_result = ActiveRecord::Base.connection.execute "select max(updated_at) as max_updated_at, max(id) as max_id, count(id) as count from #{model_class.table_name}"
+      raw_result = ActiveRecord::Base.connection.execute(
+        "select max(updated_at) as max_updated_at, max(id) as max_id, count(id) as count from #{model_class.table_name}"
+      )
       array_result = case raw_result.class.name
       when 'Mysql::Result'
         [].tap { |rows| raw_result.each_hash { |h| rows << h } }
@@ -129,7 +198,7 @@ module ProstoCache
       when 'PGresult'
         raw_result.map(&:to_hash)
       else
-        raise "Result class #{raw_result.class.name} in unsupported"
+        fail "Result class #{raw_result.class.name} in unsupported"
       end
       array_result.map(&:symbolize_keys).first
     end
@@ -150,9 +219,10 @@ module ProstoCache
       end
     end
   end
-    module Extensions
+
+  module Extensions
     def lookup_enum_for(name, enum_class=nil)
-      raise unless name
+      raise ArgumentError, "No name provided" unless name
       enum_class = name.to_s.classify.constantize unless enum_class
       define_method("#{name}_with_lookup=") do |o|
         new_value = o
@@ -166,7 +236,3 @@ module ProstoCache
     end
   end
 end
-
-
-
-

data/prosto_cache.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "prosto_cache"
-  s.version = "0.1.3"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Olek Poplavsky"]
@@ -35,20 +35,17 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<hashie>, [">= 1.0.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1.0"])
-      s.add_development_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.1"])
+      s.add_development_dependency(%q<rake>)
     else
-      s.add_dependency(%q<hashie>, [">= 1.0.0"])
-      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
-      s.add_dependency(%q<bundler>, ["~> 1.1.0"])
-      s.add_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_dependency(%q<rspec>, ["~> 2.3"])
+      s.add_dependency(%q<bundler>, ["~> 1.1"])
+      s.add_dependency(%q<rake>)
     end
   else
-    s.add_dependency(%q<hashie>, [">= 1.0.0"])
-    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
-    s.add_dependency(%q<bundler>, ["~> 1.1.0"])
-    s.add_dependency(%q<rake>, ["= 0.8.7"])
+    s.add_dependency(%q<rspec>, ["~> 2.3"])
+    s.add_dependency(%q<bundler>, ["~> 1.1"])
+    s.add_dependency(%q<rake>)
   end
 end

data/spec/prosto_cache_spec.rb

@@ -5,69 +5,80 @@ describe "ProstoCache" do
     Object.send(:remove_const, 'Foo') if Object.const_defined? 'Foo'
 
     class Foo; end
-    Foo.should_receive(:after_save)
-    class Foo
-      include ProstoCache
-    end
+    Foo.stub(:after_save)
   end
 
-  it "should be a mix-in" do
-  end
+  describe '#cache' do
+    before do
+      class Foo
+        include ProstoCache
+      end
+    end
 
-  it "should add a cache method" do
-    Foo.cache.should_not be_nil
-    Foo.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
-  end
+    it "should add a cache method" do
+      Foo.cache.should_not be_nil
+      Foo.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
+    end
 
-  it "should not load cache if it was never accessed" do
-    Foo.cache.should_not be_nil
-    Foo.cache.should_not_receive(:query_cache_signature)
-    Foo.should_not_receive(:all)
+    it "should not load cache if it was never accessed" do
+      Foo.cache.should_not_receive(:query_cache_signature)
+      Foo.should_not_receive(:all)
+
+      Foo.cache.should_not be_nil
+    end
   end
 
   context "[] method with single key access" do
     before do
-      Object.send(:remove_const, 'Foo') if Object.const_defined? 'Foo'
-
       class Foo
+        include ProstoCache
+
         attr_accessor :name
         def initialize(name)
           self.name = name
         end
       end
 
-      Foo.should_receive(:after_save)
-
-      class Foo
-        include ProstoCache
-      end
-
-      Foo.cache.should_not be_nil
-      Foo.cache.should_receive(:query_cache_signature).once.and_return(:foo)
-      Foo.should_receive(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n) })
+      Foo.cache.stub(:query_cache_signature).once.and_return(:foo)
+      Foo.stub(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n) })
     end
 
     it "should load cache when it is accessed" do
-      Foo.cache[:nondef]
+      Foo.should_receive(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n) })
+
+      Foo.cache[:foo]
     end
 
-    it "should return nil for key that was not found" do
-      Foo.cache[:nondef].should be_nil
+    context 'when key is symbol' do
+      it "should raise an error for key that was not found" do
+        expect { Foo.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
+      end
+
+      it "should return proper object for key that was found" do
+        Foo.cache[:foo].should_not be_nil
+        Foo.cache[:foo].name.should == 'foo'
+      end
     end
 
-    it "should return proper object for key that was found" do
-      Foo.cache[:foo].should_not be_nil
-      Foo.cache[:foo].name.should == 'foo'
-      Foo.cache[:bar].name.should == 'bar'
+    context 'when key is string' do
+      it "should return nil for key that was not found" do
+        Foo.cache['nondef'].should be_nil
+      end
+
+      it "should return proper object for key that was found" do
+        Foo.cache['foo'].should_not be_nil
+        Foo.cache['foo'].name.should == 'foo'
+      end
     end
   end
 
   context "[] method with composite key access" do
     before do
-      Object.send(:remove_const, 'Foo') if Object.const_defined? 'Foo'
-
       class Foo
-        attr_accessor :key1, :key2, :name
+        include ProstoCache
+        cache_accessor_keys %w(key1 key2)
+
+        attr_accessor :name, :key1, :key2
         def initialize(name, key1, key2)
           self.name = name
           self.key1 = key1
@@ -75,46 +86,56 @@ describe "ProstoCache" do
         end
       end
 
-      Foo.should_receive(:after_save)
-
-      class Foo
-        include ProstoCache
-        cache_accessor_keys %w(key1 key2)
-      end
-
-      Foo.cache.should_not be_nil
-      Foo.cache.should_receive(:query_cache_signature).once.and_return(:foo)
-      Foo.should_receive(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n, n + '1', n + '2') })
+      Foo.cache.stub(:query_cache_signature).once.and_return(:foo)
+      Foo.stub(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n, n + '1', n + '2') })
     end
 
-    it "should return nil for first level key that was not found" do
-      Foo.cache[:nondef].should be_nil
+    it "should raise an error when not enough keys provided" do
+      expect { Foo.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache[:foo1] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache['nondef'] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache['foo1'] }.to raise_error ProstoCache::BadCacheKeyError
     end
 
-    it "should return nil for second level key that was not found" do
-      Foo.cache[:foo1][:nondef].should be_nil
+    it "should raise an error when too many keys provided" do
+      expect { Foo.cache[:nondef1, :nondef2, :nondef3] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache[:foo1, :foo2, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache['nondef1', 'nondef2', 'nondef3'] }.to raise_error ProstoCache::BadCacheKeyError
+      expect { Foo.cache['foo1', 'foo2', 'nondef'] }.to raise_error ProstoCache::BadCacheKeyError
     end
 
-    it "should return nil for safe access method when first level key was not found" do
-      Foo.cache[[:nodef, :foo2]].should be_nil
-    end
+    context 'when last key is symbol' do
+      it "should raise an error for first key that was not found" do
+        expect { Foo.cache[:undef, :foo2] }.to raise_error ProstoCache::BadCacheKeyError
+        expect { Foo.cache['undef', :foo2] }.to raise_error ProstoCache::BadCacheKeyError
+      end
 
-    it "should return proper object for key that was found, using unsafe access method" do
-      Foo.cache[:foo1][:foo2].should_not be_nil
-      Foo.cache[:foo1][:foo2].name.should == 'foo'
-      Foo.cache[:bar1][:bar2].name.should == 'bar'
-    end
+      it "should raise an error for last key that was not found" do
+        expect { Foo.cache[:foo1, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+        expect { Foo.cache['foo1', :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+      end
 
-    it "should return proper object for key that was found, using safe access method" do
-      Foo.cache[[:foo1, :foo2]].should_not be_nil
-      Foo.cache[[:foo1, :foo2]].name.should == 'foo'
-      Foo.cache[[:bar1, :bar2]].name.should == 'bar'
+      it "should return proper object for key that was found" do
+        Foo.cache[:foo1, :foo2].should_not be_nil
+        Foo.cache[:foo1, :foo2].name.should == 'foo'
+      end
     end
 
-    it "should fail with exception for the unsafe access method when first level key that was not found" do
-      lambda {
-        Foo.cache[:nondef][:foo2]
-      }.should raise_error
+    context 'when last key is string' do
+      it "should return nil for first level key that was not found" do
+        Foo.cache['nondef', 'foo2'].should be_nil
+        Foo.cache[:nondef, 'foo2'].should be_nil
+      end
+
+      it "should return nil for second level key that was not found" do
+        Foo.cache['foo1', 'nondef'].should be_nil
+        Foo.cache[:foo1, 'nondef'].should be_nil
+      end
+
+      it "should return proper object for key that was found" do
+        Foo.cache['foo1', 'foo2'].should_not be_nil
+        Foo.cache['foo1', 'foo2'].name.should == 'foo'
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'rspec'
 require 'prosto_cache'
 
@@ -8,5 +9,4 @@ require 'prosto_cache'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosto_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,22 +11,6 @@ bindir: bin
 cert_chain: []
 date: 2011-05-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: hashie
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,23 +42,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0'
 description: Use this gem if you want a simple 'enum-like' cache for your models that
   does not restrict updates, but will stay current with them.
 email: olek@woodenbits.com
@@ -107,9 +91,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 849790085734229441
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: