nano-store 0.2.3

data/.gitignore

@@ -0,0 +1,3 @@
+vendor/*/build-*
+.repl_history
+build

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/BubbleWrap"]
+	path = vendor/BubbleWrap
+	url = https://github.com/mattetti/BubbleWrap.git

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.3-p194@motion

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2012, Francis Chong, All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+ * Neither the name of Tito Ciuro, Webbo, L.L.C. nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.

data/README.md

@@ -0,0 +1,193 @@
+# NanoStore for RubyMotion
+
+Wrapper for NanoStore, a lightweight schema-less key-value document database based on sqlite, in RubyMotion.
+
+Status: Work in progress. API subject to change.
+
+## Installation
+
+Install the CocoaPods dependency manager if you haven't it already:
+
+    gem install motion-cocoapods
+    pod setup
+    
+Install nano-store gem
+
+    gem install nano-store
+
+Require nano-store to your project 'Rakefile'
+
+```ruby
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'motion-cocoapods'
+require 'nano-store'
+
+Motion::Project::App.setup do |app|
+  app.name = 'myapp'
+end
+```
+
+Now, you can use NanoStore in your app.
+
+## Basic Usage
+
+### Set default storage type
+
+````ruby
+NanoStore.shared_store = NanoStore.store(:memory) # memory only db
+NanoStore.shared_store = NanoStore.store(:file, documents_path + "/nano.db") # persist the data
+````
+
+### Define Model
+
+````ruby
+class User < NanoStore::Model
+  attribute :name
+  attribute :age
+  attribute :created_at
+end
+````
+
+A key (UUID) that identifies the object will be added automatically.
+
+Attributes must be serializable, which means that only the following data types are allowed: 
+
+- NSArray
+- NSDictionary
+- NSString
+- NSData (*)
+- NSDate
+- NSNumber
+
+#### Note
+
+(*) The data type NSData is allowed, but it will be excluded from the indexing process.
+
+### Create
+
+````ruby
+# Initialize a new object and save it
+user = User.new(:name => "Bob", :age => 16, :created_at => Time.now)
+user.save
+user.key # => "550e8400-e29b-41d4-a716-446655440000" (automatically generated UUID)
+
+# Create a new object directly
+user = User.create(:name => "Bob", :age => 16, :created_at => Time.now)
+````
+
+### Retrieve
+
+````ruby
+# find all models
+User.all # => [<User#1>, <User#2>]
+
+# find model by criteria
+users = User.find(:name, NSFEqualTo, "Bob")
+````
+
+### Update
+
+````ruby
+user = User.find(:name, NSFEqualTo, "Bob").first
+user.name = "Dom"
+user.save
+````
+
+### Delete
+
+````ruby
+user = User.find(:name, NSFEqualTo, "Bob").first
+user.delete
+````
+
+## Using Transaction
+
+Use transaction is easy, just wrap your database code in a transaction block.
+
+```ruby
+store = NanoStore.shared_store = NanoStore.store
+
+begin
+  store.transaction do |the_store|
+    Animal.count # => 0
+    obj1 = Animal.new
+    obj1.name = "Cat"
+    obj1.save
+      
+    obj2 = Animal.new
+    obj2.name = "Dog"
+    obj2.save
+    Animal.count # => 2
+    raise "error"  # => an error happened!
+  end
+rescue
+  # error handling
+end
+
+Animal.count # => 0
+```
+
+## Using Bags
+
+A bag is a loose collection of objects stored in a document store.
+
+```ruby
+store = NanoStore.store
+bag = Bag.bag
+store << bag
+
+# add subclass of NanoStore::Model object to bag
+page = Page.new
+page.text = "Hello"
+page.index = 1
+bag << page 
+    
+# save the bag
+bag.save
+  
+# obtain the bags from document store
+bags = store.bags
+```
+
+## Performance Tips
+
+NanoStore by defaults saves every object to disk one by one. To speed up inserts and edited objects, increase NSFNanoStore's ```saveInterval``` property.
+
+### Example
+
+```ruby
+# Create a store
+store = NanoStore.shared_store = NanoStore.store
+    
+# Increase the save interval
+store.save_interval = 1000
+
+# Do a bunch of inserts and/or edits
+obj1 = Animal.new
+obj1.name = "Cat"
+store << obj1
+
+obj2 = Animal.new
+obj2.name = "Dog"
+store << obj2
+
+# Don't forget that some objects could be lingering in memory. Force a save.
+store.save
+```
+
+Note: If you set the saveInterval value to anything other one, keep in mind that some objects may still be left unsaved after being added or modified. To make sure they're saved properly, call:
+
+```ruby
+store.save
+```
+
+Choosing a good saveInterval value is more art than science. While testing NanoStore using a medium-sized dictionary (iTunes MP3 dictionary) setting saveInterval to 1000 resulted in the best performance. You may want to test with different numbers and fine-tune it for your data set.
+
+## Credit
+
+- Based on [NanoStore](https://github.com/tciuro/NanoStore) from Tito Ciuro, Webbo, L.L.C.
+
+## License
+
+BSD License

data/Rakefile

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

data/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    true
+  end
+end

data/lib/nano-store.rb

@@ -0,0 +1 @@
+require "nano_store"

data/lib/nano_store/bag.rb

@@ -0,0 +1,98 @@
+module NanoStore
+  class Bag < NSFNanoBag
+    ## Accessors
+    alias_method :saved, :savedObjects
+    alias_method :unsaved, :unsavedObjects
+    alias_method :removed, :removedObjects
+    
+    def changed?
+      self.hasUnsavedChanges
+    end
+
+    ## Adding and Removing Objects
+    
+    # Add an object to bag
+    # @return self
+    def <<(object)
+      error_ptr = Pointer.new(:id)
+      self.addObject(object, error:error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+
+    # Clear the bag - remove all objects
+    alias_method :clear, :removeAllObjects
+
+    # Add an object or array of objects to bag
+    # Return the bag
+    def +(object_or_array)
+      error_ptr = Pointer.new(:id)
+      if object_or_array.is_a?(Array)
+        self.addObjectsFromArray(object_or_array, error:error_ptr)
+      else
+        self.addObject(object_or_array, error:error_ptr)
+      end
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+
+    # Remove object from bag
+    def delete(object)
+      self.removeObject(object)
+      self
+    end
+    
+    # Remove object from bag with key
+    # params: 
+    # key - a key or array of keys
+    def delete_key(key)
+      if key.is_a?(Array)
+        self.removeObjectsWithKeysInArray(key)
+      else
+        self.removeObjectWithKey(key)
+      end
+      self
+    end
+    
+    # Add an object or array of objects to bag
+    # Return the bag
+    def -(object_or_array)
+      error_ptr = Pointer.new(:id)
+      if object_or_array.is_a?(Array)
+        self.removeObjectsInArray(object_or_array, error:error_ptr)
+      else
+        self.removeObject(object, error_ptr)
+      end
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+    
+    ## Saving, Reloading and Undoing
+    
+    def save
+      error_ptr = Pointer.new(:id)
+      result = self.saveAndReturnError(error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+
+    def reload
+      error_ptr = Pointer.new(:id)
+      result = self.reloadBagWithError(error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+
+    def undo
+      error_ptr = Pointer.new(:id)
+      result = self.undoChangesWithError(error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+    
+    ## Inflating and Deflating
+
+    alias_method :inflate, :inflateBag
+    alias_method :deflate, :deflateBag
+  end
+end

data/lib/nano_store/model.rb

@@ -0,0 +1,142 @@
+module NanoStore
+  module ModelInstanceMethods
+    def save
+      raise NanoStoreError, 'No store provided' unless self.class.store
+
+      error_ptr = Pointer.new(:id)
+      self.class.store.addObject(self, error:error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+  
+    def delete
+      raise NanoStoreError, 'No store provided' unless self.class.store
+
+      error_ptr = Pointer.new(:id)
+      self.class.store.removeObject(self, error: error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+    
+    def method_missing(method, *args)
+      matched = method.to_s.match(/^([^=]+)(=)?$/)
+      name = matched[1]
+      modifier = matched[2]
+
+      if self.class.attributes.include?(name.to_sym) || name == "_id"
+        if modifier == "="
+          if args[0].nil?
+            self.info.delete(name.to_sym)
+          else
+            self.info[name.to_sym] = args[0]
+          end
+        else
+          self.info[name.to_sym]
+        end
+      else
+        super
+      end
+    end
+  end
+
+  module ModelClassMethods
+    # initialize a new object
+    def new(data={})
+      extra_keys = (data.keys - self.attributes)
+      if extra_keys.size > 0
+        raise NanoStoreError, "fields #{extra_keys.join(', ')} is not a defined fields"
+      end
+
+      object = self.nanoObjectWithDictionary(data)
+      object
+    end
+    
+    # initialize a new object and save it
+    def create(data={})
+      object = self.new(data)
+      object.save
+    end
+
+    def attribute(name)
+      @attributes << name
+    end
+    
+    def attributes
+      @attributes
+    end
+
+    def store
+      if @store.nil?
+        return NanoStore.shared_store 
+      end
+      @store
+    end
+
+    def store=(store)
+      @store = store
+    end
+    
+    def count
+      self.store.count(self)
+    end
+    
+    def all
+      search = NSFNanoSearch.searchWithStore(self.store)
+      error_ptr = Pointer.new(:id)
+      searchResults = search.searchObjectsWithReturnType(NSFReturnObjects, error:error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      searchResults.values
+    end
+    
+    # find model by criteria
+    #
+    # Return array of models
+    #
+    # Example:
+    #
+    #   User.find(:name, NSFEqualTo, "Bob") => [<User#1>]
+    #
+    def find(attribute, match, value)
+      search = search_with_store(self.store, attribute, match, value)
+      error_ptr = Pointer.new(:id)
+      searchResults = search.searchObjectsWithReturnType(NSFReturnObjects, error:error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      searchResults.values
+    end
+    
+    # find model keys by criteria
+    #
+    # Return array of model keys
+    #
+    # Example:
+    #
+    #   User.find(:name, NSFEqualTo, "Bob") => [<User#1>]
+    #
+    def find_keys(attribute, match, value)
+      search = search_with_store(self.store, attribute, match, value)
+      error_ptr = Pointer.new(:id)
+      searchResults = search.searchObjectsWithReturnType(NSFReturnKeys, error:error_ptr)
+      raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+      searchResults
+    end
+
+    def inherited(subclass)
+      subclass.instance_variable_set(:@attributes, [])
+      subclass.instance_variable_set(:@store, nil)
+    end
+    
+    private
+    def search_with_store(store, attribute, match, value)
+      search = NSFNanoSearch.searchWithStore(self.store)
+      search.attribute = attribute.to_s
+      search.match = match
+      search.value = value
+      search
+    end
+  end
+
+  class Model < NSFNanoObject
+    include ModelInstanceMethods
+    extend ModelClassMethods
+  end
+end

data/lib/nano_store/nano_store.rb

@@ -0,0 +1,36 @@
+module NanoStore  
+  class NanoStoreError < StandardError; end
+
+  def self.store(type=:memory, path=nil)
+    error_ptr = Pointer.new(:id)
+
+    case type
+    when :memory
+      store = NSFNanoStore.createAndOpenStoreWithType(NSFMemoryStoreType, path:nil, error: error_ptr)
+    when :temporary, :temp
+      store = NSFNanoStore.createAndOpenStoreWithType(NSFTemporaryStoreType, path:nil, error: error_ptr)
+    when :persistent, :file
+      store = NSFNanoStore.createAndOpenStoreWithType(NSFPersistentStoreType, path:path, error: error_ptr)
+    else
+      raise NanoStoreError.new("unexpected store type (#{type}), must be one of: :memory, :temporary or :persistent")
+    end
+
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]    
+    store
+  end
+  
+  def self.shared_store
+    @shared_store
+  end
+  
+  def self.shared_store=(store)
+    @shared_store = store
+  end
+
+  # set debug mode
+  # if YES, debug mode is on; otherwise debug mode is disabled.
+  def self.debug=(debug)
+    NSFSetIsDebugOn(debug)
+  end
+
+end

data/lib/nano_store/store_extension.rb

@@ -0,0 +1,150 @@
+class NSFNanoStore
+  def engine
+    self.nanoStoreEngine
+  end
+  
+  def changed?
+    self.hasUnsavedChanges
+  end
+  
+  def save_interval=(interval)
+    self.setSaveInterval(interval)
+  end
+
+  ## Open and Close store
+
+  def close
+    error_ptr = Pointer.new(:id)
+    closed = self.closeWithError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    closed
+  end
+  
+  def open
+    error_ptr = Pointer.new(:id)
+    opened = self.openWithError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    opened
+  end
+  
+  def closed?
+    self.isClosed
+  end
+  
+  ## Adding and Removing Objects
+
+  def <<(objects)
+    error_ptr = Pointer.new(:id)
+    if objects.is_a?(Array)
+      self.addObjectsFromArray(objects, error:error_ptr)
+    else
+      self.addObject(objects, error:error_ptr)
+    end
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    self
+  end
+  
+  def +(object)
+    error_ptr = Pointer.new(:id)
+    self.addObject(object, error:error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    self
+  end
+  
+  # delete a object or array of objects from the array
+  def delete(objects)
+    error_ptr = Pointer.new(:id)
+    if objects.is_a?(Array)
+      result = self.removeObjectsInArray(objects, error:error_ptr)
+    else
+      result = self.removeObject(objects, error:error_ptr)
+    end
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+  
+  # delete all objects from store
+  def clear
+    error_ptr = Pointer.new(:id)
+    result = self.removeAllObjectsFromStoreAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+  
+  # delete object with keys
+  # param: keys - array of key
+  def delete_keys(keys)
+    error_ptr = Pointer.new(:id)
+    result = self.removeObjectsWithKeysInArray(keys, error:error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result    
+  end
+
+  ## Save and Maintenance
+  
+  # Saves the uncommitted changes to the document store.
+  def save
+    error_ptr = Pointer.new(:id)
+    result = saveStoreAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+  
+  # Discards the uncommitted changes that were added to the document store. 
+  alias_method :discard, :discardUnsavedChanges
+  
+  # Compact the database file size.
+  def compact
+    error_ptr = Pointer.new(:id)
+    result = self.compactStoreAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+  
+  # Remove all indexes from the document store. 
+  def clear_index
+    error_ptr = Pointer.new(:id)
+    result = self.clearIndexesAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+
+  # Recreate all indexes from the document store. 
+  def rebuild_index
+    error_ptr = Pointer.new(:id)
+    result = self.rebuildIndexesAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+  
+  # Makes a copy of the document store to a different location and optionally compacts it to its minimum size. 
+  def save_store(path, compact=true)
+    error_ptr = Pointer.new(:id)
+    result = self.saveStoreToDirectoryAtPath(path, compactDatabase:compact, error:error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    result
+  end
+
+  # Count number of this class objects in store  
+  def count(clazz)
+    self.countOfObjectsOfClassNamed(clazz.to_s)
+  end
+  
+  # Create a transaction
+  def transaction
+    error_ptr = Pointer.new(:id)
+    beginTransactionAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+
+    begin
+      yield self
+    rescue StandardError => e
+      rollbackTransactionAndReturnError(error_ptr)
+      raise e
+    end
+    success = commitTransactionAndReturnError(error_ptr)
+    raise NanoStoreError, error_ptr[0].description if error_ptr[0]
+    success
+  end
+
+end

data/lib/nano_store/version.rb

@@ -0,0 +1,3 @@
+module NanoStore
+  VERSION = "0.2.3"
+end

data/lib/nano_store.rb

@@ -0,0 +1,14 @@
+require "nano_store/version"
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'nano_store/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+
+  app.pods ||= Motion::Project::CocoaPods.new(app)
+  app.pods.dependency 'NanoStore', '~> 2.0.1'
+end