acts_as_partitioned 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ff28314db1efa3069fbdb9097112672045cd2b2a
+  data.tar.gz: 3a7dcebc0758cc66aeedd53711e502f934c94d15
+SHA512:
+  metadata.gz: 59b8231df8d42e6e7f86020afc2da307282c3b918fd7126a2b7c5f495a91d66e2e81c5b5ee9a81b5528d84e8f1887433c15cbde4e25b146b289ecf3029bf8dfb
+  data.tar.gz: ed96751cc941bda70c2b766c25f21da0f6cd7fa81dbc1be6263725c9052c3408c0fb0580dd26321856aba92471391ba5da79a0a6d7dc77fa24ccf07c4baced21

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in acts_as_partitioned.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dan Draper
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ActsAsPartitioned
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'acts_as_partitioned'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install acts_as_partitioned
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/acts_as_partitioned/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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/acts_as_partitioned.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_partitioned/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acts_as_partitioned"
+  spec.version       = ActsAsPartitioned::VERSION
+  spec.authors       = ["Dan Draper"]
+  spec.email         = ["daniel@codefire.com"]
+  spec.summary       = %q{A plugin for active record}
+  spec.description   = %q{Handle postgres style partitions in ActiveRecord}
+  spec.homepage      = ""
+  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.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/active_record/acts/partitioned/cache/partition_cache.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Acts
+    module Partitioned
+      module Cache
+        class PartitionCache
+    	  def initialize(keys)
+	    @pce_fact = PartitionCacheEntryFactory.new(keys)
+	    @cache = []
+	  end
+
+          # TODO: Add cache expiry
+	  def add(partition)
+	    @entry = @pce_fact.create
+	    @entry.partition = partition
+	    partition.key.each_pair do |key, value|
+	      @entry.send("#{key}=", value)
+	    end
+	    found = self.find(partition.key)
+	    @cache << @entry unless found
+	  end
+
+	  def find(hash)
+	    res = @cache.find do |entry|
+	      entry == hash
+	    end
+            res ? res.partition : nil
+	  end
+
+          def size
+            @cache.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/cache/partition_cache_entry.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module Acts
+    module Partitioned
+      module Cache
+        class PartitionCacheEntry
+          attr_accessor :partition
+
+          def initialize(keys)
+            @keys = keys
+            @columns = keys.columns
+          end
+
+    	  def match(h)
+            hash = HashWithIndifferentAccess.new(h)
+            @columns.each do |column|
+              value = hash[column.to_sym]
+              raise "No value provided for #{column} (#{column.class})" unless value
+	      unless match_instance(column, value)
+	        return false
+	      end
+	    end
+	    true
+	  end
+	  alias :== :match
+
+  	  private
+	    def match_instance(key, value)
+	      compare_to = instance_variable_get("@#{key}")
+              compare_to === value || compare_to == value
+	    end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/cache/partition_cache_entry_factory.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module Acts
+    module Partitioned
+      module Cache
+        class PartitionCacheEntryFactory
+	  def initialize(keys)
+	    @keys = keys
+	  end
+
+          def create
+	    entry = PartitionCacheEntry.new(@keys)
+	    sing = class << entry; self ; end
+	    @keys.each do |key|
+  	      sing.send(:define_method, "#{key.column}=") { |arg|
+	        instance_variable_set("@#{key.column}".to_sym, arg)
+	      }
+	    end
+	    entry
+          end
+        end    
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/copy_proxy.rb

@@ -0,0 +1,108 @@
+require 'active_record/acts/partitioned/cache/partition_cache'
+
+module ActiveRecord
+  module Acts
+    module Partitioned
+      class CopyProxy
+       	def initialize(keys, factory)
+          @keys = keys
+          @factory = factory
+	        @cache = Cache::PartitionCache.new(@keys)
+	      end
+
+        # determine partition
+        # grab the partition keys from the hash (raise if missing)
+        # try to find an open copy file
+        # A copy file is linked to a partition - if we don't have one then should we fail or build a new part?
+        # if not create one
+        # expire old copy files
+        def <<(hash)
+          values = find_key_values(hash)
+          partition = @cache.find(values)
+          unless partition
+            # TODO: If there is no partition for then we need to create one
+            # We should provide a creation function - specifically how to create a partition with the desired key range
+            partition = @factory.find_for(hash)
+            raise "No partition for hash (#{hash.inspect})" unless partition
+            @cache.add(partition)
+	        end
+          partition.copy_into << hash
+	      end
+
+        private
+          def find_key_values(hash)
+            values = {}
+            hash.each_pair do |key, value|
+              if @keys.columns.include?(key)
+                values[key] = value
+              end
+            end
+            if values.keys.size < @keys.size
+              raise "Not all keys provided to copy data into partition: #{@keys.columns.join(',')} needed"
+            end
+            values
+          end
+        end
+
+
+      class CopyFile
+        # TODO: Make this a configurable option
+        ::COPY_FILE_DIRECTORY = "/tmp/dumps/"
+
+        def initialize(table_name, options = {})
+          @table_name = table_name
+          @options = options
+          @header_written = false
+          @filename = generate_filename
+          @file = File.open(::COPY_FILE_DIRECTORY + @filename, "w")
+          #write_meta
+        end
+
+        def <<(hash)
+          unless @header_written
+            write_header(hash.keys)
+          end
+          # TODO: Write values
+          @file << hash.values.map { |v| quote_and_escape(v) }.join(',') << "\n"
+        end
+
+        def close
+          @file.close
+        end
+
+        private
+          def quote_and_escape(arg)
+            # TODO: Escape - see Adam's cortex code
+            "\"#{arg}\""
+          end
+
+          def write_meta
+            # TODO
+          end
+
+          def write_header(keys)
+            # TODO
+            @file << "COPY #{@table_name} (#{keys.join(',')}) FROM stdin with csv;\n"
+            @header_written = true
+          end
+
+          def generate_filename
+            str = "copy_"
+            str << @table_name
+            if @options.has_key?(:key)
+              str << "_#{@options[:key]}"
+            end
+            str << tmpstr
+          end
+
+          def tmpstr
+            str = ""
+            8.times do
+              str << ((rand * 25).to_i + 97).chr
+            end
+            str
+          end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/factory.rb

@@ -0,0 +1,126 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Partitioned #:nodoc:
+
+      # TODO: Rename to Proxy
+      # TODO: If we were clever we would merge this with the Partiton AR model - can't merge as you need a proxy instance but we can move lots of methods over
+      class Factory
+        attr_reader :model, :partition_class
+        attr_reader :keys
+      	delegate :find, :to => :partition_class
+      	delegate :count, :to => :partition_class
+	      delegate :with_key, :to => :partition_class
+
+        def initialize(model, partition_class, options = {})
+          @model = model
+          @keys = Keys.new
+      	  # TODO: Should we raise if we never add any keys?
+          @partition_class = partition_class
+          partition_class.factory = self
+          # TODO: Raise if model does not have key column(s)
+          @options = options
+        end
+
+        def partition_by(column, options = {})
+          # TODO: Raise if caller tries to partition on primary key
+          @keys << Key.new(column, options)
+        end
+
+        # TODO: Prevent overlapping ranges
+      	# TODO: Private?
+        def set_validations
+          # TODO: Move below this line to the partition class itself
+          @keys.each do |key|
+            case key.type
+              when :continuous
+                partition_class.validates_uniqueness_of("#{key.column}_begin", :scope => @keys.remaining_columns("#{key.column}_begin"))
+                partition_class.validates_uniqueness_of("#{key.column}_end", :scope => @keys.remaining_columns("#{key.column}_end"))
+              when :discrete
+                partition_class.validates_uniqueness_of(key.column, :scope => @keys.remaining_columns(key.column))
+            end
+          end
+        end
+
+        def init(options = {:force => false})
+          Structure.init_partition_catalog(model, @keys, options)
+        end
+
+        def copy(filename, db_name = nil)
+          port, host, user, db = if db_name
+            config = ActiveRecord::Base.configurations[db_name.to_s]
+            raise "No such DB configuration: #{db_name}" unless config
+            [config['port'], config['host'], config['username'], config['database']]
+          else
+            conn = @model.connection.raw_connection
+            [conn.port, conn.host, conn.user, conn.db]
+          end
+          "psql --set ON_ERROR_STOP=1 --single-transaction -p #{port} -h #{host} -U #{user} #{db} < #{filename}"
+        end
+
+        # Arguments are the keys specified in creation as a hash
+        # eg: create(:date => Date.today, :domain => domain)
+        def create(key_hash)
+          # TODO: Raise if a key missing
+          @model.transaction do
+            partition = partition_class.create!(key_hash)
+            @keys.create_partition_tables(@model, :key_hash => key_hash)
+            # TODO: Indexes
+            partition
+          end
+        end
+
+        def clear
+          partition_class.find(:all).each do |partition|
+            partition.drop!
+          end
+        end
+
+        # Finds a partition to which these keys belong
+        # Not by keys used to create the partition
+        # This is the same thing for discrete keys
+        # but for continuous (ie; ranged keys)
+        # the end points of a range may not equal the values
+        # stored in the part
+        # Here we see if a value fits within the range
+        # Use this method if you want to know which partition
+        # to write data to
+        def find_for(_hash)
+          hash = _hash.symbolize_keys
+          conditions = {}
+          @keys.each do |key|
+            puts "key = #{key.inspect}"
+            value = hash[key.column.to_sym]
+            raise "No value provided for #{key.column}" unless value
+            case key.type
+              when :discrete
+                conditions[key.column.to_sym] = value
+              when :continuous
+                conditions[:"#{key.column}_begin"] = value.begin
+                conditions[:"#{key.column}_end"] = value.end
+                conditions[:"#{key.column}_exclusive"] = value.exclude_end?
+            end
+          end
+          puts "conditions = #{conditions.inspect}"
+          partition_class.find_by(conditions)
+        end
+
+        def find_or_create_for(hash)
+          find_for(hash) || create(hash)
+        end
+
+      	def dump_age
+          if @options[:dump_age].kind_of?(Proc)
+            @options[:dump_age].call || 0
+          else
+            @options[:dump_age] || 0
+          end
+	      end
+
+	      def archive?
+          @options[:archive] || false
+	      end
+      end
+    end
+  end
+end
+

data/lib/active_record/acts/partitioned/key.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Partitioned #:nodoc:
+      class Key
+        attr_accessor :column, :type, :using
+
+        def initialize(column, options = {})
+          @column = column.to_s
+          @type = options[:ranged] ? :continuous : :discrete
+        end
+
+        def column_names
+          case @type
+            when :continuous then ["#{@column}_begin", "#{@column}_end"]
+            when :discrete then [@column]
+          end
+        end
+
+        def create_partition_table(model, opts = {})
+          table = model.table_name.dup
+          table << "_part_" + opts[:parent].partition_handle(:key_hash => opts[:key_hash]) if opts.has_key?(:parent)
+          partition_name = "#{model.table_name}_part_#{partition_handle(opts)}"
+          unless model.connection.tables.include?(partition_name)
+            model.connection.execute(<<-SQL)
+              CREATE TABLE #{partition_name} (
+                CHECK (#{apply_check(opts[:key_hash]).join(' AND ')})
+              ) INHERITS (#{table});
+            SQL
+          end
+        end
+
+        def partition_handle(opts)
+          handle = []
+          handle << opts[:parent].partition_handle(:key_hash => opts[:key_hash]) if opts.has_key?(:parent)
+          value = opts[:key_hash][@column.to_sym]
+          handle << case @type
+            when :discrete then value
+            when :continuous then [ value.begin, value.end ]
+          end
+          handle.flatten.map { |value|
+            handle_partition_value(value)
+          }.join("_")
+        end
+
+        private
+	        def apply_check(key_hash)
+            value = key_hash[@column.to_sym]
+            unless value
+              raise "No value provided for key #{@column}, hash is #{key_hash.inspect}"
+            end
+            case @type
+              when :discrete then ["#{@column} = '#{value}'"]
+              when :continuous then ["#{@column} >= '#{value.begin}'", "#{@column} <#{'=' unless value.exclude_end?} '#{value.end}'"]
+            end
+          end
+
+          def handle_partition_value(value)
+            case value
+              when Date,Time,Timestamp
+                value.strftime("%Y%m%d%H%M")
+              when String
+                handle_partition_value(value.to_time) rescue value
+              else value
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/keys.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Partitioned #:nodoc:
+      class Keys < Array
+        def columns
+          self.map(&:column)
+        end
+
+        def column_names
+          self.map { |k| k.column_names }.flatten
+        end
+
+        # Returns the list of column names excluding this one
+        def remaining_columns(column)
+          self.column_names - [column]
+        end
+
+        def create_partition_tables(model, opts = {})
+          each_with_index do |key, index|
+            key_opts = index == 0 ? opts : opts.merge(:parent => self[index - 1])
+            key.create_partition_table(model, key_opts)
+          end
+        end
+
+        def partition_handle(opts)
+          map { |k| k.partition_handle(opts) }.join("_")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned/partition.rb

@@ -0,0 +1,121 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Partitioned #:nodoc:
+      class Partition < ActiveRecord::Base
+        class_attribute :factory
+
+        # TODO: WHAT THE HELL??
+      	def self.with_key(hash)
+          self.scoped(:conditions => modified_attrs(hash)).first
+        end
+
+        def self.column_names
+          []
+        end
+
+        # Returns true if the hash values should be stored in this partition
+        def include?(hash)
+          self.key.each_pair do |key, value|
+            unless value === hash[key]
+              return false
+            end
+          end
+          true
+        end
+
+        def initialize(attrs = {}, options = {})
+          super(self.class.modified_attrs(attrs), options)
+        end
+
+        def drop!
+          self.transaction do
+            if partition_exists?
+              self.connection.execute "DROP TABLE #{name}"
+            end
+            self.destroy
+            if num_siblings == 0
+              # Delete the parent
+              self.connection.execute "DROP TABLE #{parent_name}"
+            end
+          end
+        end
+
+        def num_siblings
+          parent = self.class.factory.keys[-2] # second to last
+          if parent
+            # TODO: This won't handle a ranged parent yet
+            self.class.count(:conditions => { parent.column => attributes[parent.column] })
+          end
+        end
+
+        # Will unlink the partition from the parent table but not delete
+        def unlink
+          self.transaction do
+            self.class.factory.model.connection.execute <<-SQL
+              ALTER TABLE #{name} NO INHERIT #{self.class.factory.model.table_name};
+              ALTER TABLE #{name} RENAME TO #{name}_unlinked;
+            SQL
+            self.destroy
+          end
+        end
+
+        def dump
+          conn = self.class.factory.model.connection.raw_connection
+          raise "Partition does not exist" unless partition_exists?
+          `pg_dump -h #{conn.host} -U #{conn.user} -t #{self.tablename} #{conn.db} | gzip`
+        end
+
+        def size
+          rec = self.class.find(:first, :select => "relpages", :from => "pg_class", :conditions => "relname = '#{self.tablename}'")
+          rec[:relpages].to_i * 8192
+        end
+
+        def name
+          "#{self.class.factory.model.table_name}_part_#{self.class.factory.keys.partition_handle(:key_hash => key)}"
+        end
+
+        def parent_name
+          return nil unless self.class.factory.keys[-2]
+          "#{self.class.factory.model.table_name}_part_#{self.class.factory.keys[-2].partition_handle(:key_hash => key)}"
+        end
+
+        def partition_exists?
+          self.connection.table_exists?(name)
+        end
+
+        # Modify parameters to suit ranges if required
+        private
+          def self.modified_attrs(attrs)
+            hash = {}
+            attrs.each_pair do |key, value|
+              if value.instance_of?(Range)
+                hash["#{key}_begin"] = value.begin
+                hash["#{key}_end"] = value.end
+                hash["#{key}_exclusive"] = value.exclude_end?
+              else
+                hash[key] = value
+              end
+            end
+            hash
+          end
+
+          def key
+            hash = HashWithIndifferentAccess.new
+            self.class.factory.keys.each do |k|
+              case k.type
+                when :continuous
+                  r_start = self.send("#{k.column}_begin")
+                  r_end = self.send("#{k.column}_end")
+                  r_exclusive = self.send("#{k.column}_exclusive")
+                  hash[k.column] = Range.new(r_start, r_end, r_exclusive)
+                when :discrete
+                  hash[k.column] = self.send(k.column)
+              end
+            end
+            hash
+          end
+      end
+    end
+  end
+end
+ 

data/lib/active_record/acts/partitioned/structure.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module Acts
+    module Partitioned
+      class Structure < ActiveRecord::Migration
+        def self.init_partition_catalog(model, keys, options = {})
+          create_table("#{model.table_name}_partitions", :force => options[:force]) do |t|
+            puts "keys are '#{keys.inspect}'"
+            keys.each do |key|
+              case key.type
+                when :discrete
+                  t.column key.column, determine_column_type(model, key.column)
+		            when :continuous
+                  t.column "#{key.column}_begin", determine_column_type(model, key.column)
+                  t.column "#{key.column}_end", determine_column_type(model, key.column)
+                  t.column "#{key.column}_exclusive", :boolean
+              end
+	          end
+            # TODO: Add key columns and indexes
+          end
+        end
+
+        def self.determine_column_type(model, column)
+          found = model.columns.detect { |c| c.name == column.to_s }
+          raise "No such column '#{column}' on model '#{model}'" unless found
+          found.type
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts/partitioned.rb

@@ -0,0 +1,57 @@
+require 'active_record/acts/partitioned/key'
+require 'active_record/acts/partitioned/keys'
+require 'active_record/acts/partitioned/partition'
+require 'active_record/acts/partitioned/factory'
+require 'active_record/acts/partitioned/structure'
+require 'active_record/acts/partitioned/copy_proxy'
+
+# ActsAsPartitioned
+module ActiveRecord
+  class Base
+    class << self
+      def partitioned_classes
+        @@subclasses[ActiveRecord::Base].select(&:partitioned?)
+      end
+    end
+  end
+
+  module Acts #:nodoc:
+    module Partitioned #:nodoc:
+      class PartitionError < StandardError ; end
+ 
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_attribute :partitions
+      end
+
+      module ClassMethods
+      	def partition(*args)
+          options = args.extract_options!
+          # TODO: Use an anonymous class
+          eval <<-EVAL
+            class ActiveRecord::Acts::Partitioned::#{self.name}Partition < ActiveRecord::Acts::Partitioned::Partition
+              self.table_name = '#{self.table_name}_partitions'
+            end
+          EVAL
+          klass = "ActiveRecord::Acts::Partitioned::#{self.name}Partition".constantize
+	        factory = Factory.new(self, klass, options)
+	        args.each { |arg| factory.partition_by(key) }
+	        yield factory if block_given?
+          factory.set_validations
+          self.partitions = factory
+
+          # TODO: Put this in sep rake task and call on factory - should this be called Proxy
+	        #factory.migrate(:force => true)
+	      end
+
+        def partitions
+          nil
+        end
+
+        def partitioned?
+          self.partitions.present?
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_partitioned/version.rb

@@ -0,0 +1,3 @@
+module ActsAsPartitioned
+  VERSION = "0.0.2"
+end

data/lib/acts_as_partitioned.rb

@@ -0,0 +1,8 @@
+require "acts_as_partitioned/version"
+require 'active_record/acts/partitioned'
+
+module ActsAsPartitioned
+  # Your code goes here...
+end
+
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::Partitioned)

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_partitioned
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Dan Draper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+description: Handle postgres style partitions in ActiveRecord
+email:
+- daniel@codefire.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_partitioned.gemspec
+- lib/active_record/acts/partitioned.rb
+- lib/active_record/acts/partitioned/.key.rb.swp
+- lib/active_record/acts/partitioned/cache/partition_cache.rb
+- lib/active_record/acts/partitioned/cache/partition_cache_entry.rb
+- lib/active_record/acts/partitioned/cache/partition_cache_entry_factory.rb
+- lib/active_record/acts/partitioned/copy_proxy.rb
+- lib/active_record/acts/partitioned/factory.rb
+- lib/active_record/acts/partitioned/key.rb
+- lib/active_record/acts/partitioned/keys.rb
+- lib/active_record/acts/partitioned/partition.rb
+- lib/active_record/acts/partitioned/structure.rb
+- lib/acts_as_partitioned.rb
+- lib/acts_as_partitioned/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A plugin for active record
+test_files: []