repositories 0.0.1

data/lib/repository/active_record.rb

@@ -0,0 +1,238 @@
+require 'active_record'
+require 'repository/base'
+
+module Repository
+  class ActiveRecord < Base
+
+    def initialize(model_klass, options={})
+      @model_klass        = model_klass
+      @domain_model_klass = options[:domain_model_klass]
+    end
+
+    def create!(model_or_hash={})
+      attrs = model_or_hash_as_attrs(model_or_hash)
+      build_domain_model(model_klass.create!(attrs))
+    end
+
+    def update!(model_or_id, attrs={})
+      attributes = attrs || {}
+      case
+      when model_or_id.is_a?(model_klass)
+        if model_or_id.persisted?
+          model_or_id.update_attributes(attributes)
+          build_domain_model(model_or_id)
+        else
+          raise ArgumentError.new("Could not update record with id: #{model_or_id.send(primary_key)} because it does not exist")
+        end
+      when model_or_id.is_a?(domain_model_klass)
+        id = model_or_id.send(primary_key)
+        if model = model_klass.where(primary_key => id).first
+          update!(model, model_or_id.attributes.merge(attributes))
+        else
+          raise ArgumentError.new("Could not update record with id: #{id} because it does not exist")
+        end
+      else
+        if model = model_klass.where(primary_key => model_or_id).first
+          update!(model, attributes)
+        else
+          raise ArgumentError.new("Could not update record with id: #{model_or_id} because it does not exist")
+        end
+      end
+    end
+
+    def find_by_id(id)
+      self.find.eq(model_klass.primary_key, id).first
+    end
+
+    def execute_find(query)
+      scope = apply_filters model_klass, query[:filters]
+      scope = apply_sorts   scope,       query[:sorts]
+      scope = apply_limit   scope,       query[:limit]
+      scope = apply_offset  scope,       query[:offset]
+      scope.all.map { |m| build_domain_model(m) }
+    end
+
+    def execute_count(query)
+      apply_filters(model_klass, query[:filters]).count
+    end
+
+    def execute_remove!(query)
+      apply_filters(model_klass, query[:filters]).delete_all
+    end
+
+    private
+
+    attr_reader :domain_model_klass
+
+    def update_data(model_or_id)
+      case
+      when model_or_id.is_a?(model_klass)
+        [model_or_id.send(primary_key), model_or_id.attributes.slice(*model_or_id.changed)]
+      when model_or_id.is_a?(domain_model_klass)
+        [model_or_id.send(primary_key), model_or_id.attributes]
+      else
+        [model_or_id, {}]
+      end
+    end
+
+    def build_domain_model(model)
+      if domain_model_klass
+        domain_model_klass.new(model.attributes)
+      else
+        model
+      end
+    end
+
+    def apply_filters(scope, filters)
+      apply_filter(scope, Filter.new(nil, 'and', filters))
+    end
+
+    class FakeScope
+
+      attr_reader :wheres, :variables
+
+      def initialize
+        @wheres = []
+        @variables = []
+      end
+
+      def where(sql, *varaiables)
+        @wheres << sql
+        @variables += varaiables
+        self
+      end
+
+    end
+
+    def apply_filter(scope, filter)
+      column = quoted_column(filter.field)
+      case filter.operator
+      when '='
+        if filter.value
+          scope.where("#{column} = ?", filter.value)
+        else
+          scope.where("#{column} IS NULL")
+        end
+      when '!='
+        if filter.value
+          scope.where("#{column} <> ? OR #{column} IS NULL", filter.value)
+        else
+          scope.where("#{column} IS NOT NULL")
+        end
+      when '<'
+        scope.where("#{column} < ?", filter.value)
+      when '<='
+        scope.where("#{column} <= ?", filter.value)
+      when '>'
+        scope.where("#{column} > ?", filter.value)
+      when '>='
+        scope.where("#{column} >= ?", filter.value)
+      when 'in'
+        apply_contains_filter(scope, column, filter.value, '', lambda { |str|
+          "(#{str} AND #{column} IS NOT NULL)"
+        }, lambda { |str|
+          "(#{str} OR #{column} IS NULL)"
+        })
+      when '!in'
+        non_nil_values, nil_values = filter.value.uniq.partition { |val| !val.nil? }
+        case
+        when non_nil_values.empty? && nil_values.empty?
+          scope
+        when non_nil_values.empty? && !nil_values.empty?
+          scope.where("#{column} IS NOT NULL")
+        when !non_nil_values.empty? && nil_values.empty?
+          scope.where("(#{column} NOT IN (?) OR #{column} IS NULL)", non_nil_values)
+        when !non_nil_values.empty? && !nil_values.empty?
+          scope.where("(#{column} NOT IN (?) AND #{column} IS NOT NULL)", non_nil_values)
+        end
+      when 'like'
+        scope.where("#{column} LIKE #{glob(filter.value)}")
+      when 'or'
+        apply_and_join_filters(scope, filter.value, ' OR ')
+      when 'and'
+        apply_and_join_filters(scope, filter.value, ' AND ')
+      else
+        scope
+      end
+    end
+
+    def apply_and_join_filters(scope, filters, join)
+      fake_scope = FakeScope.new
+      filters.each do |filter|
+        apply_filter(fake_scope, filter)
+      end
+      sql = fake_scope.wheres.join(join)
+      sql = "(#{sql})" if fake_scope.wheres.size > 1
+      scope.where(sql, *fake_scope.variables)
+    end
+
+    def apply_contains_filter(scope, column, values, _not, if_nil, if_not_nil)
+      non_nil_values, nil_values = values.uniq.partition { |val| !val.nil? }
+      str = "#{column} #{_not} IN (?)"
+      if nil_values.empty?
+        str = if_nil.call(str)
+      else
+        str = if_not_nil.call(str)
+      end
+      scope.where(str, non_nil_values)
+    end
+
+    def apply_sorts(scope, sorts)
+      if sorts.empty?
+        scope
+      else
+        ar_sorts = sorts.reduce([]) do |ar_sorts, sort|
+          ar_sorts << "#{quoted_column(sort.field)} #{sort.order}"
+          ar_sorts
+        end.join(', ')
+        scope.order ar_sorts
+      end
+    end
+
+    def apply_limit(scope, limit)
+      if limit
+        scope.limit(limit)
+      else
+        scope
+      end
+    end
+
+    def apply_offset(scope, offset)
+      if offset
+        scope.offset(offset)
+      else
+        scope
+      end
+    end
+
+    def quoted_column(column)
+      ::ActiveRecord::Base.connection.quote_column_name(column)
+    end
+
+    def quoted_value(value)
+      ::ActiveRecord::Base.connection.quote(value)
+    end
+
+    def glob(k)
+      quoted_value("%#{k}%")
+    end
+
+    def store_record!(attrs)
+      record = attrs.dup
+      if id = record.delete(primary_key)
+        model_klass.update_all(record, {primary_key => id}, {limit: 1})
+      else
+        model_klass.create!(record)
+      end
+    end
+
+    def primary_key
+      model_klass.primary_key
+    end
+
+    def remove_model!(model)
+      model_klass.delete_all(id: model.id)
+    end
+
+  end
+end

data/lib/repository/base.rb

@@ -0,0 +1,55 @@
+require 'time'
+require 'repository/cursor'
+require 'repository/filter_factory'
+
+module Repository
+  class Base
+
+    def find
+      cursor
+    end
+
+    def filter
+      @filter_factory ||= FilterFactory.new
+    end
+
+    def remove_by_id!(id)
+      if model = find_by_id(id)
+        remove_model!(model)
+      else
+        raise ArgumentError.new("Could not remove record with id: #{id} because it does not exist")
+      end
+    end
+
+    def remove!(model=nil)
+      if model
+        remove_by_id!(model.send(primary_key))
+      else
+        cursor.remove!
+      end
+    end
+
+    private
+
+    attr_reader :model_klass
+
+    def cursor
+      Cursor.new(self)
+    end
+
+    def model_or_hash_as_attrs(model_or_hash)
+      if model_or_hash
+        if model_or_hash.is_a?(Hash)
+          model_or_hash
+        elsif model_or_hash.is_a?(model_klass)
+          model_or_hash.attributes
+        else
+          raise ArgumentError.new("A hash or a #{model_klass} must be given to create a record")
+        end
+      else
+        {}
+      end
+    end
+
+  end
+end

data/lib/repository/cursor.rb

@@ -0,0 +1,168 @@
+require 'repository/filter'
+require 'repository/sort'
+require 'repository/filter_factory'
+
+module Repository
+  class Cursor
+
+    def initialize(query_executor)
+      @query_executor = query_executor
+      @filters = []
+      @sorts   = []
+    end
+
+    def eq(field, value)
+      @filters << filter_factory.eq(field, value)
+      self
+    end
+
+    def not_eq(field, value)
+      @filters << filter_factory.not_eq(field, value)
+      self
+    end
+
+    def lt(field, value)
+      @filters << filter_factory.lt(field, value)
+      self
+    end
+
+    def lte(field, value)
+      @filters << filter_factory.lte(field, value)
+      self
+    end
+
+    def gt(field, value)
+      @filters << filter_factory.gt(field, value)
+      self
+    end
+
+    def gte(field, value)
+      @filters << filter_factory.gte(field, value)
+      self
+    end
+
+    def in(field, value)
+      @filters << filter_factory.in(field, value)
+      self
+    end
+
+    def not_in(field, value)
+      @filters << filter_factory.not_in(field, value)
+      self
+    end
+
+    def like(field, value)
+      @filters << filter_factory.like(field, value)
+      self
+    end
+
+    def or(*filters)
+      @filters << filter_factory.or(*filters)
+      self
+    end
+
+    def sort(field, order)
+      assert_field!(field)
+      assert_order!(order)
+      @sorts << Sort.new(field, order.to_sym)
+      self
+    end
+
+    def limit(limit)
+      if limit
+        assert_int!('Limit', limit)
+        @limit = limit.to_i
+      end
+      self
+    end
+
+    def offset(offset)
+      if offset
+        assert_int!('Offset', offset)
+        @offset = offset.to_i
+      end
+      self
+    end
+
+    def count
+      query_executor.execute_count(query)
+    end
+
+    def all
+      query_executor.execute_find(query)
+    end
+
+    def first
+      query_executor.execute_find(
+        query.merge(
+          sorts: sorts_for_first,
+          limit: 1
+        )).first
+    end
+
+    def last
+      query_executor.execute_find(
+        query.merge(
+          sorts: sorts_for_last,
+          limit: 1
+        )).first
+    end
+
+    def remove!
+      query_executor.execute_remove!(query)
+    end
+
+    def first
+      query_executor.execute_find(
+        query.merge(
+          limit: 1
+        )).first
+    end
+
+    def query
+      {
+        :type    => @type,
+        :filters => @filters,
+        :sorts   => @sorts,
+        :offset  => @offset,
+        :limit   => @limit
+      }
+    end
+
+    private
+
+    attr_reader :query_executor
+
+    def filter_factory
+      @filter_factory ||= FilterFactory.new
+    end
+
+    def sorts_for_first
+      @sorts
+    end
+
+    def sorts_for_last
+      sorts_for_first.map do |sort|
+        Sort.new(sort.field, sort.order == :asc ? :desc : :asc)
+      end
+    end
+
+    def assert_field!(field)
+      unless field.is_a?(String) || field.is_a?(Symbol)
+        raise ArgumentError.new "Field name must be a String or Symbol but you gave #{PP.pp(field, '')}"
+      end
+    end
+
+    def assert_order!(order)
+      unless [:asc, :desc, 'asc', 'desc'].include?(order)
+        raise ArgumentError.new "Sort order must be 'asc' or 'desc' but you gave #{PP.pp(order, '')}"
+      end
+    end
+
+    def assert_int!(name, num)
+      unless num.is_a?(Integer) || (num.is_a?(String) && num =~ /\d+/)
+        raise ArgumentError.new "#{name} must be an integer but you gave #{PP.pp(num, '')}"
+      end
+    end
+  end
+end

data/lib/repository/filter.rb

@@ -0,0 +1,13 @@
+module Repository
+  class Filter
+
+    attr_reader :field, :operator, :value
+
+    def initialize(field, operator, value)
+      @field = field
+      @operator = operator
+      @value = value
+    end
+
+  end
+end

data/lib/repository/filter_factory.rb

@@ -0,0 +1,87 @@
+require 'repository/filter'
+
+module Repository
+  class FilterFactory
+
+    def eq(field, value)
+      assert_field!(field)
+      Filter.new(field, '=', value)
+    end
+
+    def not_eq(field, value)
+      assert_field!(field)
+      Filter.new(field, '!=', value)
+    end
+
+    def lt(field, value)
+      assert_field!(field)
+      assert_not_nil!('Less than', value)
+      Filter.new(field, '<', value)
+    end
+
+    def lte(field, value)
+      assert_field!(field)
+      assert_not_nil!('Less than or equal to', value)
+      Filter.new(field, '<=', value)
+    end
+
+    def gt(field, value)
+      assert_field!(field)
+      assert_not_nil!('Greater than', value)
+      Filter.new(field, '>', value)
+    end
+
+    def gte(field, value)
+      assert_field!(field)
+      assert_not_nil!('Greater than or equal to', value)
+      Filter.new(field, '>=', value)
+    end
+
+    def in(field, value)
+      assert_field!(field)
+      assert_to_a!('Inclusion', value)
+      Filter.new(field, 'in', value.to_a)
+    end
+
+    def not_in(field, value)
+      assert_field!(field)
+      assert_to_a!('Exclusion', value)
+      Filter.new(field, '!in', value.to_a)
+    end
+
+    def like(field, value)
+      assert_field!(field)
+      assert_str_or_sym!(value, 'Value')
+      Filter.new(field, 'like', value)
+    end
+
+    def or(*filters)
+      Filter.new(nil, 'or', filters)
+    end
+
+    private
+
+    def assert_to_a!(name, value)
+      unless value.respond_to?(:to_a)
+        raise ArgumentError.new "#{name} filter value must respond to to_a but #{PP.pp(value, '')} does not"
+      end
+    end
+
+    def assert_not_nil!(name, value)
+      if value.nil?
+        raise ArgumentError.new "#{name} filter value cannot be nil"
+      end
+    end
+
+    def assert_field!(field)
+      assert_str_or_sym!(field, 'Field name')
+    end
+
+    def assert_str_or_sym!(value, name)
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise ArgumentError.new "#{name} must be a String or Symbol but you gave #{PP.pp(value, '')}"
+      end
+    end
+
+  end
+end

data/lib/repository/memory.rb

@@ -0,0 +1,206 @@
+require 'multi_json'
+require 'repository/base'
+require 'repository/cursor'
+
+# for sorting on booleans
+class FalseClass
+  def <(other)
+    other
+  end
+
+  def >(other)
+    false
+  end
+end
+
+class TrueClass
+  def <(other)
+    other
+  end
+
+  def >(other)
+    true
+  end
+end
+
+module Repository
+  class Memory < Base
+
+    def initialize(model_klass, options={})
+      @model_klass = model_klass
+      @id = 0
+      @store = {}
+      @primary_key = options[:primary_key]
+    end
+
+    def create!(attrs={})
+      _id = id
+      attrs = model_or_hash_as_attrs(attrs)
+      verify_attributes!(attrs)
+      attributes = attrs.merge(primary_key => _id)
+      store!(_id, attributes)
+      model_klass.new(attributes)
+    end
+
+    def update!(model_or_id, attributes={})
+      attributes ||= {}
+      model = case
+              when model_or_id.is_a?(model_klass)
+                if model = find_by_id(model_or_id.send(primary_key))
+                  model_or_id
+                else
+                  raise ArgumentError.new("Could not update record with id: #{model_or_id.send(primary_key)} because it does not exist") unless model
+                end
+
+              else
+                if model = find_by_id(model_or_id)
+                  model
+                else
+                  raise ArgumentError.new("Could not update record with id: #{model_or_id} because it does not exist") unless model
+                end
+              end
+      updated_attrs = model.attributes.merge(attributes_without_pkey(attributes))
+      store!(model.send(primary_key), updated_attrs)
+      model_klass.new(updated_attrs)
+    end
+
+    def find_by_id(id)
+      find.eq(primary_key, id).first
+    end
+
+    ###########################
+    # These methods are called by the cursor. Do not call them directly. Or call them. Whatever. Either one.
+
+    def raw_find(query)
+      models = all_models
+      models = apply_transforms models, query[:transforms]
+      models = filter_models    models, query[:filters]
+      models = sort_models      models, query[:sorts]
+      models = offset_models    models, query[:offset]
+      models = limit_models     models, query[:limit]
+    end
+
+    def execute_find(query)
+      models = raw_find(query)
+      models.map { |h| model_klass.new(h) }
+    end
+
+    def execute_count(query)
+      execute_find(query).size
+    end
+
+    def execute_remove!(query)
+      execute_find(query).each do |model|
+        remove_model!(model)
+      end
+    end
+
+    ###########################
+
+    private
+
+    attr_reader :primary_key
+
+    def verify_attributes!(attrs)
+      null_model = model_klass.new
+      allowed_attributes = null_model.attributes.keys.map(&:to_sym)
+      attrs.each do |key, value|
+        unless allowed_attributes.include?(key.to_sym)
+          raise ArgumentError.new("Unknown attribute: #{key}")
+        end
+      end
+    end
+
+    def attributes_without_pkey(attributes)
+      attributes.reject { |k, v| k == primary_key }
+    end
+
+    def apply_transforms(models, transforms)
+      models.map do |model|
+        (transforms || []).reduce(model) do |model, transform|
+          transform.call(model)
+        end
+      end
+    end
+
+    def filter_models(models, filters)
+      models.select do |model|
+        (filters || []).all? do |filter|
+          filter_matches?(filter, model)
+        end
+      end
+    end
+
+    def filter_matches?(filter, model)
+      value = model[filter.field]
+      case filter.operator
+      when '='; value == filter.value
+      when '!='; value != filter.value
+      when '<'; value && value < filter.value
+      when '<='; value && value <= filter.value
+      when '>'; value && value > filter.value
+      when '>='; value && value >= filter.value
+      when 'in'; filter.value.include?(value)
+      when '!in'; !filter.value.include?(value)
+      when 'or'; filter.value.any? do |sub_filter|
+        filter_matches?(sub_filter, model)
+      end
+      when 'like'; value =~ /#{filter.value}/i
+      end
+    end
+
+    def sort_models(models, sorts)
+      models.sort { |model1, model2| compare_models(model1, model2, sorts) }
+    end
+
+    def compare_models(model1, model2, sorts)
+      sorts.each do |sort|
+        result = compare_model(model1, model2, sort)
+        return result if result
+      end
+      0
+    end
+
+    def compare_model(model1, model2, sort)
+      field1, field2 = model1[sort.field], model2[sort.field]
+      field1 == field2                         ?  nil :
+        field1 < field2 && sort.order == :asc  ?  -1  :
+        field1 > field2 && sort.order == :desc ?  -1  : 1
+    end
+
+    def limit_models(models, limit)
+      if limit
+        models.take(limit)
+      else
+        models
+      end
+    end
+
+    def offset_models(models, offset)
+      if offset
+        models.drop(offset)
+      else
+        models
+      end
+    end
+
+    def all_models
+      @store.values.map do |raw_record|
+        model_klass.new(MultiJson.load(raw_record)).attributes
+      end
+    end
+
+    def store!(id, attributes)
+      @store[id] = MultiJson.dump(attributes)
+    end
+
+    def remove_model!(model)
+      @store.delete(model.send(primary_key))
+      nil
+    end
+
+    def id
+      @id += 1
+    end
+  end
+end

data/lib/repository/sort.rb

@@ -0,0 +1,12 @@
+module Repository
+  class Sort
+
+    attr_reader :field, :order
+
+    def initialize(field, order)
+      @field = field
+      @order = order
+    end
+
+  end
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: repositories
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Myles Megyesi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.6
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+description: Repository?
+email:
+- myles.megyesi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/repository/memory.rb
+- lib/repository/base.rb
+- lib/repository/filter_factory.rb
+- lib/repository/sort.rb
+- lib/repository/filter.rb
+- lib/repository/active_record.rb
+- lib/repository/cursor.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Store some data?
+test_files: []