langalex-couch_potato 0.2.6 → 0.2.7

data/README.md

@@ -20,21 +20,26 @@ Lastly Couch Potato aims to provide a seamless integration with Ruby on Rails, e
 
 ### Installation
 
-Couch Potato requires Ruby 1.9.
-
 Couch Potato is hosted as a gem on github which you can install like this:
 
     sudo gem source --add http://gems.github.com # if you haven't already
     sudo gem install langalex-couch_potato
-  
+
 #### Using with your ruby application:
 
     require 'rubygems'
     gem 'langalex-couch_potato'
     require 'couch_potato'
+
+Alternatively you can download or clone the source repository and then require lib/couch_potato.rb.
+
+You MUST specificy the name of the database:
+
     CouchPotato::Config.database_name = 'name of the db'
-  
-Alternatively you can download or clone the source repository and then require lib/couch_potato.rb. 
+
+The server URL will default to http://localhost:5984/ unless specified with:
+
+    CouchPotato::Config.database_server = "http://example.com:5984/"
 
 #### Using with Rails
 
@@ -48,7 +53,7 @@ Then create a config/couchdb.yml:
     test: test_db_name
     production: http://db.server/production_db_name
 
-Alternatively you can also install Couch Potato directly as a plugin. 
+Alternatively you can also install Couch Potato directly as a plugin.
 
 ### Introduction
 
@@ -71,15 +76,15 @@ If you want to store any properties you have to declare them:
 
     class User
       include CouchPotato::Persistence
-    
+
       property :name
     end
-  
+
 Properties can be of any type:
 
     class User
       include CouchPotato::Persistence
-    
+
       property :address, :type => Address
     end
 
@@ -87,7 +92,7 @@ Now you can save your objects. All database operations are encapsulated in the C
 
     user = User.new :name => 'joe'
     CouchPotato.database.save_document user # or save_document!
-  
+
 You can of course also retrieve your instance:
 
     CouchPotato.database.load_document "id_of_the_user_document" # => <#User 0x3075>
@@ -104,13 +109,13 @@ You can access the properties you declared above through normal attribute access
     user.created_at # => Fri Oct 24 19:05:54 +0200 2008
     user.updated_at # => Fri Oct 24 19:05:54 +0200 2008
     user.new? # => false
-  
+
 If you want to have properties that don't map to any JSON type, i.e. other than String, Number, Boolean, Hash or Array you have to define the type like this:
 
     class User
       property :date_of_birth, :type => Date
     end
-  
+
 The date_of_birth property is now automatically serialized to JSON and back when storing/retrieving objects.
 
 #### Dirty tracking
@@ -121,15 +126,15 @@ CouchPotato tracks the dirty state of attributes in the same way ActiveRecord do
     user.name # => 'joe'
     user.name_changed? # => false
     user.name_was # => nil
-  
+
 You can also force a dirty state:
-  
+
     user.name = 'jane'
     user.name_changed? # => true
     user.name_not_changed
     user.name_changed? # => false
     CouchPotato.database.save_document user # does nothing as no attributes are dirty
-  
+
 
 #### Object validations
 
@@ -151,12 +156,12 @@ In order to find data in your CouchDB you have to create a view first. Couch Pot
     class User
       include CouchPotato::Persistence
       property :name
-    
+
       view :all, :key => :created_at
     end
-  
+
 This will create a view called "all" in the "user" design document with a map function that emits "created_at" for every user document.
-  
+
     CouchPotato.database.view User.all
 
 This will load all user documents in your database sorted by created_at.
@@ -169,10 +174,10 @@ Composite keys are also possible:
 
     class User
       property :name
-    
+
       view :all, :key => [:created_at, :name]
     end
-  
+
 The creation of views is based on view specification classes (see the CouchPotato::View module). The above code uses the ModelViewSpec class which is used to find models by their properties. For more sophisticated searches you can use other view specifications (either use the built-in or provide your own) by passing a type parameter:
 
 If you have larger structures and you only want to load some attributes you can use the PropertiesViewSpec (the full class name is automatically derived):
@@ -180,25 +185,25 @@ If you have larger structures and you only want to load some attributes you can
     class User
       property :name
       property :bio
-    
+
       view :all, :key => :created_at, :properties => [:name], :type => :properties
     end
-  
+
   CouchPotato.database.view(User.everyone).first.name # => "joe"
   CouchPotato.database.view(User.everyone).first.bio # => nil
-  
+
 You can also pass in custom map/reduce functions with the custom view spec:
 
     class User
       view :all, :map => "function(doc) { emit(doc.created_at, null)}", :include_docs => true, :type => :custom
     end
-  
+
 If you don't want the results to be converted into models the raw view is your friend:
 
     class User
       view :all, :map => "function(doc) { emit(doc.created_at, doc.name)}", :type => :raw
     end
-  
+
 When querying this view you will get the raw data returned by CouchDB which looks something like this: {'total_entries': 2, 'rows': [{'value': 'alex', 'key': '2009-01-03 00:02:34 +000', 'id': '75976rgi7546gi02a'}]}
 
 To process this raw data you can also pass in a results filter:
@@ -221,7 +226,7 @@ Couch Potato supports the usual lifecycle callbacks known from ActiveRecord:
 
     class User
       include CouchPotato::Persistence
-    
+
       before_create :do_something_before_create
       before_update {|user, db| user.do_something_on_update}
     end
@@ -230,25 +235,25 @@ This will call the method do_something_before_create before creating an object a
 
 Supported callbacks are: :before_validation_on_create, :before_validation_on_update, :before_validation_on_save, :before_create, :after_create, :before_update, :after_update, :before_save, :after_save, :before_destroy, :after_destroy.
 
-#### Testing  
+#### Testing
 
 To make testing easier and faster database logic has been put into its own class, which you can replace and stub out in whatever way you want:
 
     class User
       include CouchPotato::Persistence
     end
-  
+
     # RSpec
     describe 'save a user' do
       it 'should save' do
-        couchrest_db = stub 'couchrest_db', 
+        couchrest_db = stub 'couchrest_db',
         database = CouchPotato::Database.new couchrest_db
         user = User.new
         couchrest_db.should_receive(:save_doc).with(...)
         database.save_document user
       end
     end
-    
+
 By creating you own instances of CouchPotato::Database and passing them a fake CouchRest database instance you can completely disconnect your unit tests/spec from the database.
 
 ### Helping out

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 6
+:patch: 7

data/lib/couch_potato.rb

@@ -10,26 +10,26 @@ require 'validatable'
 
 module CouchPotato
   Config = OpenStruct.new
-  
+
   # Returns a database instance which you can then use to create objects and query views. You have to set the CouchPotato::Config.database_name before this works.
   def self.database
     @@__database ||= Database.new(self.couchrest_database)
   end
-  
+
   # Returns the underlying CouchRest database object if you want low level access to your CouchDB. You have to set the CouchPotato::Config.database_name before this works.
   def self.couchrest_database
     @@__couchrest_database ||= CouchRest.database(full_url_to_database)
   end
-  
+
   private
-  
+
   def self.full_url_to_database
-    database_name = CouchPotato::Config.database_name || raise('No Database configured. Set CouchPotato::Config.database_name')
-    url = database_name
-    if url !~ /^http:\/\//
-      url = "http://localhost:5984/#{database_name}"
+    raise('No Database configured. Set CouchPotato::Config.database_name') unless CouchPotato::Config.database_name
+    if CouchPotato::Config.database_server
+      return "#{CouchPotato::Config.database_server}#{CouchPotato::Config.database_name}"
+    else
+      return "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
     end
-    url
   end
 end
 
@@ -37,5 +37,6 @@ require File.dirname(__FILE__) + '/core_ext/object'
 require File.dirname(__FILE__) + '/core_ext/time'
 require File.dirname(__FILE__) + '/core_ext/date'
 require File.dirname(__FILE__) + '/core_ext/string'
+require File.dirname(__FILE__) + '/core_ext/symbol'
 require File.dirname(__FILE__) + '/couch_potato/persistence'
 

data/lib/couch_potato/database.rb

@@ -35,10 +35,10 @@ module CouchPotato
     alias_method :save!, :save_document!
   
     def destroy_document(document)
-      document.run_callbacks :before_destroy, self
+      document.run_callbacks :before_destroy
       document._deleted = true
       database.delete_doc document.to_hash
-      document.run_callbacks :after_destroy, self
+      document.run_callbacks :after_destroy
       document._id = nil
       document._rev = nil
     end
@@ -48,7 +48,9 @@ module CouchPotato
       raise "Can't load a document without an id (got nil)" if id.nil?
       begin
         json = database.get(id)
-        Class.const_get(json['ruby_class']).json_create json
+        instance = Class.const_get(json['ruby_class']).json_create json
+        instance.database = self
+        instance
       rescue(RestClient::ResourceNotFound)
         nil
       end
@@ -62,29 +64,30 @@ module CouchPotato
     private
   
     def create_document(document)
-      document.run_callbacks :before_validation_on_save, self
-      document.run_callbacks :before_validation_on_create, self
+      document.database = self
+      document.run_callbacks :before_validation_on_save
+      document.run_callbacks :before_validation_on_create
       return unless document.valid?
-      document.run_callbacks :before_save, self
-      document.run_callbacks :before_create, self
+      document.run_callbacks :before_save
+      document.run_callbacks :before_create
       res = database.save_doc document.to_hash
       document._rev = res['rev']
       document._id = res['id']
-      document.run_callbacks :after_save, self
-      document.run_callbacks :after_create, self
+      document.run_callbacks :after_save
+      document.run_callbacks :after_create
       true
     end
   
     def update_document(document)
-      document.run_callbacks :before_validation_on_save, self
-      document.run_callbacks :before_validation_on_update, self
+      document.run_callbacks :before_validation_on_save
+      document.run_callbacks :before_validation_on_update
       return unless document.valid?
-      document.run_callbacks :before_save, self
-      document.run_callbacks :before_update, self
+      document.run_callbacks :before_save
+      document.run_callbacks :before_update
       res = database.save_doc document.to_hash
       document._rev = res['rev']
-      document.run_callbacks :after_save, self
-      document.run_callbacks :after_update, self
+      document.run_callbacks :after_save
+      document.run_callbacks :after_update
       true
     end
   

data/lib/couch_potato/persistence.rb

@@ -17,7 +17,7 @@ module CouchPotato
       base.send :include, DirtyAttributes
       base.send :include, MagicTimestamps
       base.class_eval do
-        attr_accessor :_id, :_rev, :_attachments, :_deleted
+        attr_accessor :_id, :_rev, :_attachments, :_deleted, :database
         alias_method :id, :_id
       end
     end

data/lib/couch_potato/persistence/callbacks.rb

@@ -1,75 +1,38 @@
 module CouchPotato
   module Persistence
     module Callbacks
-      
-      class Callback #:nodoc:
-        def initialize(model, name, database)
-          @model, @name, @database = model, name, database
-        end
-        
-        def run
-          if @name.is_a?(Symbol)
-            run_method_callback @name
-          elsif @name.is_a?(Proc)
-            run_lambda_callback @name
-          else
-            raise "Don't know how to handle callback of type #{name.class.name}"
-          end
-        end
-        
-        private
-        
-        def run_method_callback(name)
-          if callback_method(name).arity == 0
-            @model.send name
-          elsif callback_method(name).arity == 1
-            @model.send name, @database
-          else
-            raise "Don't know how to handle method callback with #{callback_method(name).arity} arguments"
-          end
-        end
-        
-        def callback_method(name)
-          @model.method(name)
-        end
-
-        def run_lambda_callback(lambda)
-          if lambda.arity == 1
-            lambda.call @model
-          elsif lambda.arity == 2
-            lambda.call @model, @database
-          else raise "Don't know how to handle lambda callback with #{lambda.arity} arguments"
-          end
-        end
-        
-      end
-      
       def self.included(base)
         base.extend ClassMethods
-        
+
         base.class_eval do
           attr_accessor :skip_callbacks
           def self.callbacks
             @callbacks ||= {}
-            @callbacks[self.name] ||= {:before_validation_on_create => [], 
-              :before_validation_on_update => [], :before_validation_on_save => [], :before_create => [], 
+            @callbacks[self.name] ||= {:before_validation_on_create => [],
+              :before_validation_on_update => [], :before_validation_on_save => [], :before_create => [],
               :after_create => [], :before_update => [], :after_update => [],
               :before_save => [], :after_save => [],
               :before_destroy => [], :after_destroy => []}
           end
         end
       end
-      
+
       # Runs all callbacks on a model with the given name, i.g. :after_create.
       # 
       # This method is called by the CouchPotato::Database object when saving/destroying an object 
-      def run_callbacks(name, database)
+      def run_callbacks(name)
         return if skip_callbacks
         self.class.callbacks[name].uniq.each do |callback|
-          Callback.new(self, callback, database).run
+          if callback.is_a?(Symbol)
+            send callback
+          elsif callback.is_a?(Proc)
+            callback.call self
+          else
+            raise "Don't know how to handle callback of type #{name.class.name}"
+          end
         end
       end
-      
+
       module ClassMethods
         [
           :before_validation_on_create,

data/lib/couch_potato/persistence/properties.rb

@@ -13,7 +13,7 @@ module CouchPotato
           end
         end
       end
-      
+
       module ClassMethods
         # returns all the property names of a model class that have been defined using the #property method
         #
@@ -26,13 +26,13 @@ module CouchPotato
         def property_names
           properties.map(&:name)
         end
-        
+
         def json_create(json) #:nodoc:
           instance = super
           instance.send(:assign_attribute_copies_for_dirty_tracking)
           instance
         end
-        
+
         # Declare a proprty on a model class. properties are not typed by default. You can use any of the basic types by JSON (String, Integer, Fixnum, Array, Hash). If you want a property to be of a custom class you have to define it using the :class option.
         #
         # example:

data/lib/couch_potato/view/base_view_spec.rb

@@ -3,15 +3,19 @@ module CouchPotato
     class BaseViewSpec
       attr_reader :reduce_function, :design_document, :view_name, :view_parameters, :klass, :options
       private :klass, :options
-      
+
       def initialize(klass, view_name, options, view_parameters)
         @klass = klass
         @design_document = klass.to_s.underscore
         @view_name = view_name
         @options = options
-        @view_parameters = options.select{|key, value| [:group, :include_docs, :descending, :group_level, :limit].include?(key.to_sym)}.merge(view_parameters)
+        @view_parameters = {}
+        [:group, :include_docs, :descending, :group_level, :limit].each do |key|
+          @view_parameters[key] = options[key] if options.include?(key)
+        end
+        @view_parameters.merge!(view_parameters)
       end
-      
+
       def process_results(results)
         results
       end

data/lib/couch_potato/view/custom_views.rb

@@ -8,21 +8,28 @@ require File.dirname(__FILE__) + '/raw_view_spec'
 module CouchPotato
   module View
     module CustomViews
-      
+
       def self.included(base)
         base.extend ClassMethods
       end
-      
+
       module ClassMethods
         # Declare a CouchDB view, for examples on how to use see the *ViewSpec classes in CouchPotato::View
+        def views
+          @views ||= {}
+        end
+
+        def execute_view(view_name, view_parameters)
+          view_spec_class(views[view_name][:type]).new(self, view_name, views[view_name], view_parameters)
+        end
+
         def view(view_name, options)
-          self.class.instance_eval do
-            define_method view_name do |view_parameters = {}|
-              view_spec_class(options[:type]).new self, view_name, options, view_parameters
-            end
-          end
+          view_name = view_name.to_s
+          views[view_name] = options
+          method_str = "def #{view_name}(view_parameters = {}); execute_view(\"#{view_name}\", view_parameters); end"
+          self.instance_eval(method_str)
         end
-        
+
         def view_spec_class(type)
           if type && type.is_a?(Class)
             type

data/lib/couch_potato/view/view_query.rb

@@ -9,18 +9,18 @@ module CouchPotato
         @map_function = map_function
         @reduce_function = reduce_function
       end
-      
+
       def query_view!(parameters = {})
         begin
           query_view parameters
-        rescue RestClient::ResourceNotFound => e
+        rescue RestClient::ResourceNotFound# => e
           create_view
           retry
         end
       end
-      
+
       private
-      
+
       def create_view
         design_doc = @database.get "_design/#{@design_document_name}" rescue nil
         design_doc ||= {'views' => {}, "_id" => "_design/#{@design_document_name}"}
@@ -30,11 +30,11 @@ module CouchPotato
         }
         @database.save_doc(design_doc)
       end
-      
+
       def query_view(parameters)
         @database.view view_url, parameters
       end
-      
+
       def view_url
         "#{@design_document_name}/#{@view_name}"
       end

data/spec/callbacks_spec.rb

@@ -24,8 +24,6 @@ class CallbackRecorder
   
   attr_accessor :lambda_works
   before_create lambda {|model| model.lambda_works = true }
-  after_create lambda {|model, db| db.view CallbackRecorder.all}
-  before_update :method_callback_with_argument
   
   def callbacks
     @callbacks ||= []
@@ -246,26 +244,10 @@ describe "destroy callbacks" do
   end
 end
 
-describe "method callbacks" do
-  it "should pass the database to a method with arity 1" do
-    recorder = CallbackRecorder.new
-    db = stub 'db'
-    db.should_receive(:view)
-    recorder.run_callbacks :before_update, db
-  end
-end
-
 describe "lambda callbacks" do
   it "should run the lambda" do
     recorder = CallbackRecorder.new
-    recorder.run_callbacks :before_create, stub('db')
+    recorder.run_callbacks :before_create
     recorder.lambda_works.should be_true
   end
-  
-  it "should pass the database to a lambda with arity 2" do
-    recorder = CallbackRecorder.new
-    db = stub 'db'
-    db.should_receive(:view)
-    recorder.run_callbacks :after_create, db
-  end
 end

data/spec/custom_view_spec.rb

@@ -2,10 +2,10 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 class Build
   include CouchPotato::Persistence
-  
+
   property :state
   property :time
-  
+
   view :timeline, :key => :time
   view :count, :key => :time, :reduce => true
   view :minimal_timeline, :key => :time, :properties => [:state], :type => :properties
@@ -21,50 +21,51 @@ describe 'view' do
   before(:each) do
     recreate_db
   end
-  
+
   it "should return instances of the class" do
     CouchPotato.database.save_document Build.new(:state => 'success', :time => '2008-01-01')
-    CouchPotato.database.view(Build.timeline).map(&:class).should == [Build]
+    results = CouchPotato.database.view(Build.timeline)
+    results.map(&:class).should == [Build]
   end
-  
-  it "should pass the view options to the viw query" do
+
+  it "should pass the view options to the view query" do
     query = mock 'query'
     CouchPotato::View::ViewQuery.stub!(:new).and_return(query)
     query.should_receive(:query_view!).with(hash_including(:key => 1)).and_return('rows' => [])
     CouchPotato.database.view Build.timeline(:key => 1)
   end
-  
+
   it "should not return documents that don't have a matching ruby_class" do
     CouchPotato.couchrest_database.save_doc({:time => 'x'})
     CouchPotato.database.view(Build.timeline).should == []
   end
-  
+
   it "should count documents" do
     CouchPotato.database.save_document Build.new(:state => 'success', :time => '2008-01-01')
     CouchPotato.database.view(Build.count(:reduce => true)).should == 1
   end
-  
+
   it "should count zero documents" do
     CouchPotato.database.view(Build.count(:reduce => true)).should == 0
   end
-  
+
   describe "properties defined" do
     it "should assign the configured properties" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', :ruby_class => 'Build')
       CouchPotato.database.view(Build.minimal_timeline).first.state.should == 'success'
     end
-    
+
     it "should not assign the properties not configured" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', :ruby_class => 'Build')
       CouchPotato.database.view(Build.minimal_timeline).first.time.should be_nil
     end
-    
+
     it "should assign the id even if it is not configured" do
       id = CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', :ruby_class => 'Build')['id']
       CouchPotato.database.view(Build.minimal_timeline).first._id.should == id
     end
   end
-  
+
   describe "no properties defined" do
     it "should assign all properties to the objects by default" do
       id = CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01', :ruby_class => 'Build'})['id']
@@ -74,60 +75,60 @@ describe 'view' do
       result._id.should == id
     end
   end
-  
+
   describe "map function given" do
     it "should still return instances of the class" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
       CouchPotato.database.view(Build.custom_timeline).map(&:class).should == [Build]
     end
-    
+
     it "should assign the properties from the value" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
       CouchPotato.database.view(Build.custom_timeline).map(&:state).should == ['custom_success']
     end
-    
+
     it "should leave the other properties blank" do
       CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
       CouchPotato.database.view(Build.custom_timeline).map(&:time).should == [nil]
     end
-    
+
     describe "that returns null documents" do
       it "should return instances of the class" do
         CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
         CouchPotato.database.view(Build.custom_timeline_returns_docs).map(&:class).should == [Build]
       end
-      
+
       it "should assign the properties from the value" do
         CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
         CouchPotato.database.view(Build.custom_timeline_returns_docs).map(&:state).should == ['success']
       end
     end
   end
-  
+
   describe "with array as key" do
     it "should create a map function with the composite key" do
       CouchPotato::View::ViewQuery.should_receive(:new).with(anything, anything, anything, string_matching(/emit\(\[doc\['time'\], doc\['state'\]\]/), anything).and_return(stub('view query').as_null_object)
       CouchPotato.database.view Build.key_array_timeline
     end
   end
-  
+
   describe "raw view" do
     it "should return the raw data" do
       CouchPotato.database.save_document Build.new(:state => 'success', :time => '2008-01-01')
       CouchPotato.database.view(Build.raw)['rows'][0]['value'].should == 'success'
     end
-    
+
     it "should return filtred raw data" do
       CouchPotato.database.save_document Build.new(:state => 'success', :time => '2008-01-01')
       CouchPotato.database.view(Build.filtered_raw).should == ['success']
     end
-    
+
     it "should pass view options declared in the view declaration to the query" do
-     view_query = mock 'view_query'   
+     view_query = mock 'view_query'
      CouchPotato::View::ViewQuery.stub!(:new).and_return(view_query)
      view_query.should_receive(:query_view!).with(hash_including(:group => true)).and_return({'rows' => []})
      CouchPotato.database.view(Build.with_view_options)
     end
   end
-  
+
 end

data/spec/spec_helper.rb

@@ -6,13 +6,14 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'couch_potato'
 
 CouchPotato::Config.database_name = 'couch_potato_test'
+CouchPotato::Config.database_server = 'http://127.0.0.1:5984/'
 
 
 class Comment
   include CouchPotato::Persistence
-  
+
   validates_presence_of :title
-  
+
   property :title
   belongs_to :commenter
 end

data/spec/unit/database_spec.rb

@@ -1,5 +1,8 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
+class DbTestUser
+end
+
 describe CouchPotato::Database, 'new' do
   it "should raise an exception if the database doesn't exist" do
     lambda {
@@ -15,4 +18,21 @@ describe CouchPotato::Database, 'load' do
       db.load nil
     }.should raise_error("Can't load a document without an id (got nil)")
   end
+  
+  it "should set itself on the model" do
+    user = mock 'user'
+    DbTestUser.stub!(:new).and_return(user)
+    db = CouchPotato::Database.new(stub('couchrest db', :info => nil, :get => {'ruby_class' => 'DbTestUser'}))
+    user.should_receive(:database=).with(db)
+    db.load '1'
+  end
+end
+
+describe CouchPotato::Database, 'save_document' do
+  it "should set itself on the model for a new object before doing anything else" do
+    db = CouchPotato::Database.new(stub('couchrest db', :info => nil))
+    user = stub('user', :new? => true, :valid? => false).as_null_object
+    user.should_receive(:database=).with(db)
+    db.save_document user
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: langalex-couch_potato
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - Alexander Lang