mem_model 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGM2ZmU3YzU3NDA4MjRlNjcyMTBmYzcxN2UyNmM1OGJhNDA0NGJkMA==
+  data.tar.gz: !binary |-
+    ZDg1OWNiMDVlNjQ4YWNhOTI3Mzc1Y2FhMzdiZDI4ZDhkOGYzNWEwNg==
+SHA512:
+  metadata.gz: !binary |-
+    YjA1N2JlZTlhMDg2MzJhZjQ2N2I5ZDdhZmE1YWQxNDE3ZjMxZmU4OTkzYjky
+    ZmNkYTg3NDA1Zjk3OWJmOGUyYmEzNzhmZTg3NGVjNWI2NTRlNTk2Nzk1NmUz
+    Njk2ZDdmMzYzMDg3ZDM0YTVlOTZkMGQzZGY3MGJhMDEwODllMzM=
+  data.tar.gz: !binary |-
+    M2UwODI1OGY5ZjNkZmUwNWNiNjY2N2U2NGRmODc2OWY5ZGI3YzA3YmRlNzli
+    NDE4OTIxMjc5NTlmZWZlZjU0NzVjOGYxNWVmZjJkNGQ5ZTQ0MTA1YTE4MDlj
+    MmFjNTA2YTFmY2MwMjM5ZTE5ZTcwNDkyMTM3YzQ4MGUwYTY3ZTU=

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+### 0.1.0 / 2013-12-19
+
+* 1 major enhancement
+
+  * Birthday!

data/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help
+improve this project.
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code ( **no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/johnnyt/mem_model/issues
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add, commit, and push your changes.
+9. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2013 JohnnyT
+
+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/Manifest.txt

@@ -0,0 +1,15 @@
+CHANGELOG.md
+CONTRIBUTING.md
+LICENSE.md
+Manifest.txt
+README.md
+Rakefile
+lib/mem_model.rb
+lib/mem_model/base.rb
+lib/mem_model/version.rb
+mem_model.gemspec
+test/helper.rb
+test/mem_model/test_active_model_lint.rb
+test/mem_model/test_base.rb
+test/mem_model/test_persistence.rb
+test/test_version.rb

data/README.md

@@ -0,0 +1,106 @@
+# MemModel
+
+MemModel persists Ruby objects using MagLev as a data storage engine. It is an
+ActiveModel compliant implementation so it works stand-alone or in Rails 3 as a
+drop-in replacement for ActiveRecord or DataMapper.
+
+If MemModel is used in non-MagLev platforms, objects will be persisted to
+in-memory sets.
+
+
+### Installation
+
+Run `gem install mem_model` to install the gem on its own.
+
+Or you can add the following to your Gemfile and run the `bundle` command to
+install it.
+
+    gem 'mem_model'
+
+
+##### Development
+
+If you'd like to work on this project first make sure you have the `hoe` gem
+installed (`gem install hoe` if not), then run `rake newb` from the
+`mem_model` project directory.
+
+
+### Example
+
+```ruby
+require 'mem_model'
+
+class Account
+  include MemModel::Base
+  attribute :balance
+  validates_presence_of :balance
+end
+
+checking = Account.new  #=> #<Account balance: nil, id: "ACC-123...">
+checking.valid?         #=> false
+checking.balance = 100  #=> 100
+checking.valid?         #=> true
+
+checking.save           #=> "ACC-123..."
+checking.new?           #=> false
+Account.size            #=> 1
+Account.first           #=> #<Account balance: 100, id: "ACC-123...">
+```
+
+
+### Similar stuff
+
+This stuff has been very helpful in working on MemModel.
+
+##### Projects
+
+* [Tesla][tesla]: MagLev niceties like models... and signs
+* [Supermodel][supermodel]. Simple in-memory database using ActiveModel. Primarily
+  developed for Bowline applications.
+* [ActiveAttr][active_attr]: What ActiveModel left out
+* [MagLevRecord][maglevrecord]: MagLev persistence with an
+  ActiveRecord-like interface!
+
+##### Docs
+
+* [MagLev Persistence API][persistence_api]: Overview of the persistence API inMagLev
+* [Persistence README][persistence_readme]: MagLev Persistence Examples overview
+* [Migrations][migrations]: The Problem: Evolution of Persistent Data Formats (Schema Changes)
+* [Migrations DSL][migrations_dsl]: Requirements for a Migration DSL which would allow
+  "rails-like" migrations for MagLev.
+
+##### Examples
+
+* [Blog Data Migration Example][blog]: create a blog, add attributes, migrate existing
+  instances
+* [K-d Tree][kd_tree]: includes a Google Maps example using zipcodes
+* [Indexing][indexing]: use unordered collections with MagLev's built-in indexing support
+* [Points][points]: shows two approaches of handling data migration using a Point class.
+
+
+### Contributing
+
+If you'd like to contribute to MemModel, that's awesome. There's a guide to contributing
+(both code and general help) over in [CONTRIBUTING.md](CONTRIBUTING.md)
+
+### Development
+
+To see what has changed in recent versions, see the [CHANGELOG.md](CHANGELOG.md).
+
+[hoe]: http://www.zenspider.com/projects/hoe.html
+
+[tesla]: https://github.com/jc00ke/tesla
+[supermodel]: https://github.com/maccman/supermodel
+[active_attr]: https://github.com/cgriego/active_attr
+[maglevrecord]: https://github.com/knub/maglevrecord
+
+[persistence_api]: https://github.com/MagLev/maglev/blob/master-1.9/docs/persistence-api.rdoc
+[persistence_readme]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/Persistence-README.rdoc
+[migrations]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/migrations/migrations.org
+[migrations_dsl]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/migrations/migration-dsl.org
+
+[migration_examples]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/migrations/example/example.rdoc
+[kd_tree]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/kdtree/KDTree-README.rdoc
+[indexing]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/indexing/Indexing-README.rdoc
+[blog]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/migrations/example/example.rdoc
+[points]: https://github.com/MagLev/maglev/blob/master-1.9/examples/persistence/migrations/example2/README.rdoc

data/Rakefile

@@ -0,0 +1,32 @@
+# -*- ruby -*-
+
+#require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :git
+Hoe.plugin :gemspec
+
+Hoe.spec 'mem_model' do
+  developer 'JohnnyT', 'ubergeek3141@gmail.com'
+
+  self.summary     = 'ActiveModel-compliant MagLev persistence'
+  self.description = <<-DESC.strip.gsub(/\n\s+/, " ")
+    MemModel persists Ruby objects using MagLev as a data storage engine. It's an
+    ActiveModel implementation so it works stand-alone or in Rails 3 as a drop-in
+    replacement for ActiveRecord or DataMapper.  If MemModel is used in non-MagLev
+    platforms, objects will be persisted to in-memory sets.
+  DESC
+  self.urls        = ['https://github.com/johnnyt/mem_model']
+
+  self.history_file = 'CHANGELOG.md'
+  self.readme_file  = 'README.md'
+  self.testlib      = :none # actually minitest. this helps the gem to be loaded
+
+  license 'MIT'
+
+  dependency 'active_attr',   '>= 0.8.2'
+  dependency 'activesupport', '= 3.2.15' # MagLev optimized version
+  dependency 'minitest',      '= 5.0.2', :dev
+end
+
+# vim: syntax=ruby

data/lib/mem_model/base.rb

@@ -0,0 +1,439 @@
+module MemModel
+  class UnknownRecord < ArgumentError; end
+  class InvalidRecord < StandardError; end
+
+  module Base
+    def self.included(base)
+      base.send :include, ActiveAttr::Model
+      base.send :extend, Enumerable
+      base.send :extend, ClassMethods
+      base.class_eval do
+        attribute :id
+      end
+    end
+
+    module ClassMethods
+      extend Forwardable
+      def_delegators :store, :each, :size, :entries
+      alias_method :all, :entries
+
+      def store
+        @store ||= Set.new
+      end
+
+      def generate_id
+        [guid_prefix, '-', SecureRandom.uuid].join.upcase
+      end
+
+      def guid_prefix
+        self.name[0...3]
+      end
+
+      def store
+        @store ||= Set.new
+      end
+
+      def find_by_id(id)
+        store.detect{ |r| id == r.id } || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+
+      def find_all_by_id(substring)
+        records = store.select{ |r| r.id.include?(substring.to_s.upcase) }
+        records && records.size == 1 ?
+          records.first :
+          records || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+
+      def [](substring)
+        store.detect{ |r| r.id.include?(substring.to_s.upcase) } || raise(UnknownRecord, "Couldn't find #{self.name} with ID=~#{substring}")
+      end
+
+      def find(id)
+        store.detect{ |r| r.id == id } || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+
+      def exists?(id)
+        store.any?{ |record| record.id == id }
+      end
+
+      def update(id, atts)
+        find(id).update_attributes(atts)
+      end
+
+      def destroy(id)
+        find(id).destroy
+      end
+
+      # Removes all records and executes
+      # destroy callbacks.
+      def destroy_all
+        all.each {|r| r.destroy }
+      end
+
+      # Removes all records without executing
+      # destroy callbacks.
+      def delete_all
+        store.clear
+      end
+
+      # Create a new record.
+      # Example:
+      #   create(:name => "foo", :id => 1)
+      def create(atts = {})
+        rec = self.new(atts)
+        rec.save && rec
+      end
+
+      def create!(*args)
+        create(*args) || raise(InvalidRecord)
+      end
+    end
+
+    def initialize(attributes = {})
+      @persisted = false
+      self.id = self.class.generate_id
+      load(attributes)
+    end
+
+    def load(attributes) #:nodoc:
+      return unless attributes
+      attributes.each do |(name, value)|
+        self.send("#{name}=".to_sym, value)
+      end
+    end
+
+    def to_model
+      return self
+    end
+
+    def new?
+      !exists?
+    end
+    alias_method :new_record?, :new?
+
+    def exists?
+      @persisted == true
+    end
+
+    def save
+      new? ? create : update
+    end
+
+    def save!
+      save || raise(InvalidRecord)
+    end
+
+    def destroy
+      self.class.records.delete(self.id)
+      self
+    end
+
+    def create
+      self.id ||= generate_id
+      @persisted = true
+      self.class.store << self
+      self.id
+    end
+
+    def update
+      item = self.class.raw_find(id)
+      item.load(attributes)
+      true
+    end
+  end
+
+  class SuperModel
+
+    class << self
+      attr_accessor(:primary_key) #:nodoc:
+
+      def primary_key
+        @primary_key ||= 'id'
+      end
+
+      def collection(&block)
+        @collection ||= Class.new(Array)
+        @collection.class_eval(&block) if block_given?
+        @collection
+      end
+
+      def attributes(*attributes)
+        self.known_attributes |= attributes.map(&:to_s)
+      end
+
+      def records
+        @records ||= {}
+      end
+
+      def find_by_attribute(name, value) #:nodoc:
+        item = records.values.find {|r| r.send(name) == value }
+        item && item.dup
+      end
+
+      def find_all_by_attribute(name, value) #:nodoc:
+        items = records.values.select {|r| r.send(name) == value }
+        collection.new(items.deep_dup)
+      end
+
+      def raw_find(id) #:nodoc:
+        records[id] || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+
+      # Find record by ID, or raise.
+      def find(id)
+        item = raw_find(id)
+        item && item.dup
+      end
+      alias :[] :find
+
+      def first
+        item = records.values[0]
+        item && item.dup
+      end
+
+      def last
+        item = records.values[-1]
+        item && item.dup
+      end
+
+      def where(options)
+        items = records.values.select do |r|
+          options.all? do |k, v|
+            if v.is_a?(Enumerable)
+              v.include?(r.send(k))
+            else
+              r.send(k) == v
+            end
+          end
+        end
+        collection.new(items.deep_dup)
+      end
+
+      def exists?(id)
+        records.has_key?(id)
+      end
+
+      def count
+        records.length
+      end
+
+      def all
+        collection.new(records.values.deep_dup)
+      end
+
+      def select(&block)
+        collection.new(records.values.select(&block).deep_dup)
+      end
+
+      def update(id, atts)
+        find(id).update_attributes(atts)
+      end
+
+      def destroy(id)
+        find(id).destroy
+      end
+
+      # Removes all records and executes
+      # destroy callbacks.
+      def destroy_all
+        all.each {|r| r.destroy }
+      end
+
+      # Removes all records without executing
+      # destroy callbacks.
+      def delete_all
+        records.clear
+      end
+
+      # Create a new record.
+      # Example:
+      #   create(:name => "foo", :id => 1)
+      def create(atts = {})
+        rec = self.new(atts)
+        rec.save && rec
+      end
+
+      def create!(*args)
+        create(*args) || raise(InvalidRecord)
+      end
+
+      def method_missing(method_symbol, *args) #:nodoc:
+        method_name = method_symbol.to_s
+
+        if method_name =~ /^find_by_(\w+)!/
+          send("find_by_#{$1}", *args) || raise(UnknownRecord)
+        elsif method_name =~ /^find_by_(\w+)/
+          find_by_attribute($1, args.first)
+        elsif method_name =~ /^find_or_create_by_(\w+)/
+          send("find_by_#{$1}", *args) || create($1 => args.first)
+        elsif method_name =~ /^find_all_by_(\w+)/
+          find_all_by_attribute($1, args.first)
+        else
+          super
+        end
+      end
+    end
+
+    attr_accessor :attributes
+    attr_writer   :new_record
+
+    def known_attributes
+      self.class.known_attributes | self.attributes.keys.map(&:to_s)
+    end
+
+    def initialize(attributes = {})
+      @new_record = true
+      @attributes = {}.with_indifferent_access
+      @attributes.merge!(known_attributes.inject({}) {|h, n| h[n] = nil; h })
+      @changed_attributes = {}
+      load(attributes)
+    end
+
+    def clone
+      cloned = attributes.reject {|k,v| k == self.class.primary_key }
+      cloned = cloned.inject({}) do |attrs, (k, v)|
+        attrs[k] = v.clone
+        attrs
+      end
+      self.class.new(cloned)
+    end
+
+    def new?
+      @new_record || false
+    end
+    alias :new_record? :new?
+
+    # Gets the <tt>\id</tt> attribute of the item.
+    def id
+      attributes[self.class.primary_key]
+    end
+
+    # Sets the <tt>\id</tt> attribute of the item.
+    def id=(id)
+      attributes[self.class.primary_key] = id
+    end
+
+    def ==(other)
+      other.equal?(self) || (other.instance_of?(self.class) && other.id == id)
+    end
+
+    # Tests for equality (delegates to ==).
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      id.hash
+    end
+
+    def dup
+      self.class.new.tap do |base|
+        base.attributes = attributes
+        base.new_record = new_record?
+      end
+    end
+
+    def save
+      new? ? create : update
+    end
+
+    def save!
+      save || raise(InvalidRecord)
+    end
+
+    def exists?
+      !new?
+    end
+    alias_method :persisted?, :exists?
+
+    def load(attributes) #:nodoc:
+      return unless attributes
+      attributes.each do |(name, value)|
+        self.send("#{name}=".to_sym, value)
+      end
+    end
+
+    def reload
+      return self if new?
+      item = self.class.find(id)
+      load(item.attributes)
+      return self
+    end
+
+    def update_attribute(name, value)
+      self.send("#{name}=".to_sym, value)
+      self.save
+    end
+
+    def update_attributes(attributes)
+      load(attributes) && save
+    end
+
+    def update_attributes!(attributes)
+      update_attributes(attributes) || raise(InvalidRecord)
+    end
+
+    def has_attribute?(name)
+      @attributes.has_key?(name)
+    end
+
+    alias_method :respond_to_without_attributes?, :respond_to?
+
+    def respond_to?(method, include_priv = false)
+      method_name = method.to_s
+      if attributes.nil?
+        super
+      elsif known_attributes.include?(method_name)
+        true
+      elsif method_name =~ /(?:=|\?)$/ && attributes.include?($`)
+        true
+      else
+        super
+      end
+    end
+
+    def destroy
+      raw_destroy
+      self
+    end
+
+    protected
+      def read_attribute(name)
+        @attributes[name]
+      end
+
+      def write_attribute(name, value)
+        @attributes[name] = value
+      end
+
+      def generate_id
+        object_id
+      end
+
+      def raw_destroy
+        self.class.records.delete(self.id)
+      end
+
+      def raw_create
+        self.class.records[self.id] = self.dup
+      end
+
+      def create
+        self.id ||= generate_id
+        self.new_record = false
+        raw_create
+        self.id
+      end
+
+      def raw_update
+        item = self.class.raw_find(id)
+        item.load(attributes)
+      end
+
+      def update
+        raw_update
+        true
+      end
+
+  end
+end

data/lib/mem_model/version.rb

@@ -0,0 +1,3 @@
+module MemModel
+  VERSION = '0.1.0'
+end

data/lib/mem_model.rb

@@ -0,0 +1,10 @@
+require 'active_attr'
+require 'securerandom'
+require 'forwardable'
+require 'set'
+
+module MemModel
+end
+
+require 'mem_model/base'
+require 'mem_model/version'

data/mem_model.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+# stub: mem_model 0.1.0.20131220134709 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "mem_model"
+  s.version = "0.1.0.20131220134709"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["JohnnyT"]
+  s.date = "2013-12-20"
+  s.description = "MemModel persists Ruby objects using MagLev as a data storage engine. It's an ActiveModel implementation so it works stand-alone or in Rails 3 as a drop-in replacement for ActiveRecord or DataMapper.  If MemModel is used in non-MagLev platforms, objects will be persisted to in-memory sets."
+  s.email = ["ubergeek3141@gmail.com"]
+  s.extra_rdoc_files = ["CHANGELOG.md", "CONTRIBUTING.md", "LICENSE.md", "Manifest.txt", "README.md"]
+  s.files = ["CHANGELOG.md", "CONTRIBUTING.md", "LICENSE.md", "Manifest.txt", "README.md", "Rakefile", "lib/mem_model.rb", "lib/mem_model/base.rb", "lib/mem_model/version.rb", "mem_model.gemspec", "test/helper.rb", "test/mem_model/test_active_model_lint.rb", "test/mem_model/test_base.rb", "test/mem_model/test_persistence.rb", "test/test_version.rb", ".gemtest"]
+  s.homepage = "https://github.com/johnnyt/mem_model"
+  s.licenses = ["MIT"]
+  s.rdoc_options = ["--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "mem_model"
+  s.rubygems_version = "2.1.11"
+  s.summary = "ActiveModel-compliant MagLev persistence"
+  s.test_files = ["test/mem_model/test_active_model_lint.rb", "test/mem_model/test_base.rb", "test/mem_model/test_persistence.rb", "test/test_version.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<active_attr>, [">= 0.8.2"])
+      s.add_runtime_dependency(%q<activesupport>, ["= 3.2.15"])
+      s.add_development_dependency(%q<rdoc>, ["~> 4.0"])
+      s.add_development_dependency(%q<minitest>, ["= 5.0.2"])
+      s.add_development_dependency(%q<hoe>, ["~> 3.7"])
+    else
+      s.add_dependency(%q<active_attr>, [">= 0.8.2"])
+      s.add_dependency(%q<activesupport>, ["= 3.2.15"])
+      s.add_dependency(%q<rdoc>, ["~> 4.0"])
+      s.add_dependency(%q<minitest>, ["= 5.0.2"])
+      s.add_dependency(%q<hoe>, ["~> 3.7"])
+    end
+  else
+    s.add_dependency(%q<active_attr>, [">= 0.8.2"])
+    s.add_dependency(%q<activesupport>, ["= 3.2.15"])
+    s.add_dependency(%q<rdoc>, ["~> 4.0"])
+    s.add_dependency(%q<minitest>, ["= 5.0.2"])
+    s.add_dependency(%q<hoe>, ["~> 3.7"])
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require File.expand_path('lib/mem_model')
+require 'active_model/lint'
+gem 'minitest', '5.2.0'
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use!

data/test/mem_model/test_active_model_lint.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../helper', __FILE__)
+
+class TestActiveModelLint < Minitest::Test
+  include ActiveModel::Lint::Tests
+
+  class CompliantModel
+    include MemModel::Base
+  end
+
+  def setup
+    @model = CompliantModel.new
+  end
+end

data/test/mem_model/test_base.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../helper', __FILE__)
+
+class TestBase < Minitest::Test
+  class Account
+    include MemModel::Base
+  end
+
+  def test_new_guid_uniqueness
+    refute_equal Account.generate_id, Account.generate_id
+  end
+end

data/test/mem_model/test_persistence.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../helper', __FILE__)
+
+class TestPersistence < Minitest::Test
+  class Account
+    include MemModel::Base
+    attribute :balance
+  end
+
+  def setup
+    @account = Account.new
+  end
+
+  def teardown
+    @account = nil
+    Account.delete_all
+  end
+
+  def test_new_model_is_new_record
+    assert @account.new_record?
+  end
+
+  def test_saved_model_is_persisted
+    @account.save
+    refute @account.new_record?
+  end
+
+  def test_find_nonexistent_record
+    assert_raises(MemModel::UnknownRecord) do
+      Account.find 'wat'
+    end
+  end
+
+  def test_find
+    @account.save
+    assert_equal @account, Account.find(@account.id)
+  end
+end

data/test/test_version.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestVersion < Minitest::Test
+  def test_version
+    assert MemModel::VERSION
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: mem_model
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- JohnnyT
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: MemModel persists Ruby objects using MagLev as a data storage engine.
+  It's an ActiveModel implementation so it works stand-alone or in Rails 3 as a drop-in
+  replacement for ActiveRecord or DataMapper.  If MemModel is used in non-MagLev platforms,
+  objects will be persisted to in-memory sets.
+email:
+- ubergeek3141@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/mem_model.rb
+- lib/mem_model/base.rb
+- lib/mem_model/version.rb
+- mem_model.gemspec
+- test/helper.rb
+- test/mem_model/test_active_model_lint.rb
+- test/mem_model/test_base.rb
+- test/mem_model/test_persistence.rb
+- test/test_version.rb
+- .gemtest
+homepage: https://github.com/johnnyt/mem_model
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+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: mem_model
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: ActiveModel-compliant MagLev persistence
+test_files:
+- test/mem_model/test_active_model_lint.rb
+- test/mem_model/test_base.rb
+- test/mem_model/test_persistence.rb
+- test/test_version.rb