motion-yapper 0.0.1 → 0.0.2

data/lib/yapper/document/selection.rb

@@ -3,6 +3,26 @@ module Yapper::Document
     extend MotionSupport::Concern
 
     module ClassMethods
+      def all(options={})
+        Criteria.new(self, {}, options)
+      end
+
+      def where(criteria, options={})
+        Criteria.new(self, criteria, options)
+      end
+
+      def asc(*fields)
+        Criteria.new(self, {}, {}).sort(fields, :asc)
+      end
+
+      def desc(*fields)
+        Criteria.new(self, {}, {}).sort(fields, :desc)
+      end
+
+      def count
+        all.count
+      end
+
       def find(id)
         return nil if id.nil?
 
@@ -11,16 +31,6 @@ module Yapper::Document
         attrs ? object_for_attrs(attrs) : nil
       end
 
-      def all(options={})
-        results = []
-        each_result_proc = proc do |key, attrs, stop|
-          results << object_for_attrs(attrs)
-        end
-
-        db.execute { |txn| txn.enumerateKeysAndObjectsInCollection(self._type, usingBlock: each_result_proc) }
-        results
-      end
-
       def when(id, &block)
         observer = nil
         observer_block = proc do |data|
@@ -42,59 +52,117 @@ module Yapper::Document
         end
       end
 
-      def where(criteria, options={})
-        values = []; query_str = ''
-
-        # Sort keys so that query string is always the same and is cached
-        criteria.sort.each do |field, value|
-          raise "#{field} is not indexed" if self.indexes[field].nil?
-
-          query_str.blank? ? query_str = "WHERE " : query_str += " AND "
-          query_str += "#{field} = ?"
-
-          # XXX Casting should only happen if the type of the field allows for it
-          value = case value.class.to_s
-                  when 'Time'
-                    value.to_i
-                  else
-                    value
-                  end
-          values << value
-        end
+      private
 
-        options.each do |option, params|
-          case option
-          when :order
-            params.each do |sort_field, direction|
-              if query_str.include?("ORDER by")
-                query_str += ", "
-              else
-                query_str += " ORDER by "
-              end
-              query_str += "#{sort_field} #{direction.upcase}"
-            end
-          else
-            raise "#{option} not a valid option on #where"
-          end
-        end
+      def object_for_attrs(attrs)
+        Object.qualified_const_get(self._type).new(attrs.deep_dup, :new => false, :pristine => true)
+      end
+    end
+  end
 
-        query = YapDatabaseQuery.alloc.initWithQueryString(query_str, queryParameters: values)
+  class Criteria
+    def initialize(klass, criteria, options)
+      @klass    = klass
+      @criteria = criteria
+      @options  = options
+    end
 
-        results = []
-        each_result_proc = proc do |collection, key, attrs, stop|
-          results << object_for_attrs(attrs)
-        end
+    def count
+      count_ptr = Pointer.new(:uint)
+      @klass.db.execute { |txn| txn.ext("#{@klass._type}_IDX").getNumberOfRows(count_ptr, matchingQuery: query) }
+      count_ptr.value
+    end
+
+    def first
+      asc(:id).limit(1).to_a.first
+    end
+
+    def last
+      desc(:id).limit(1).to_a.first
+    end
 
-        db.execute { |txn| txn.ext("#{self._type}_IDX").enumerateKeysAndObjectsMatchingQuery(query, usingBlock: each_result_proc) }
+    def to_a
+      results = []
 
-        results
+      each_result_proc = proc do |collection, key, attrs, stop|
+        results << object_for_attrs(attrs)
       end
 
-      private
+      @klass.db.execute { |txn| txn.ext("#{@klass._type}_IDX").enumerateKeysAndObjectsMatchingQuery(query, usingBlock: each_result_proc) }
 
-      def object_for_attrs(attrs)
-        Object.qualified_const_get(self._type).new(attrs.deep_dup, :new => false, :pristine => true)
+      results
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def where(criteria)
+      self.class.new(@klass, @criteria.merge(criteria), @options)
+    end
+
+    def limit(limit)
+      self.class.new(@klass, @criteria, @options.merge(:limit => limit))
+    end
+
+    def sort(fields, direction)
+      order = @options[:order].to_a + fields.map { |f| [f,direction] }
+      self.class.new(@klass, @criteria, @options.merge(:order => order))
+    end
+
+    def asc(*fields)
+      sort(fields, :asc)
+    end
+
+    def desc(*fields)
+      sort(fields, :desc)
+    end
+
+    private
+
+    def query
+      values = []; query_str = ''
+
+      # Sort keys so that query string is always the same and is cached
+      @criteria.sort.each do |field, value|
+        raise "#{field} is not indexed" if @klass.indexes[field].nil?
+
+        query_str.blank? ? query_str = "WHERE " : query_str += " AND "
+        query_str += "#{field} = ?"
+
+        # XXX Casting should only happen if the type of the field allows for it
+        value = case value.class.to_s
+                when 'Time'
+                  value.to_i
+                else
+                  value
+                end
+        values << value
       end
+
+      @options.each do |option, params|
+        case option
+        when :order
+          params.each do |sort_field, direction|
+            if query_str.include?("ORDER by")
+              query_str += ", "
+            else
+              query_str += " ORDER by "
+            end
+            query_str += "#{sort_field} #{direction.upcase}"
+          end
+        when :limit
+          query_str += " LIMIT #{params}"
+        else
+          raise "#{option} not a valid option on #where"
+        end
+      end
+
+      YapDatabaseQuery.alloc.initWithQueryString(query_str, queryParameters: values)
+    end
+
+    def object_for_attrs(attrs)
+      Object.qualified_const_get(@klass._type).new(attrs.deep_dup, :new => false, :pristine => true)
     end
   end
 end

data/lib/yapper/extensions.rb

@@ -41,40 +41,28 @@ class Time
   end
 end
 
-class Object
-  def as_json
-    self
-  end
-end
-
 class Hash
-  def as_json
-    hash = self.class.new
-    self.each { |k,v| hash[k] = v.as_json }
-    hash
-  end
-end
-
-class NSDictionary
-  def as_json
-    to_hash.as_json
+  def to_canonical
+    self.keys.to_canonical + self.values.to_canonical
   end
 end
 
 class Array
-  def as_json
-    self.map { |v| v.as_json }
+  def to_canonical
+    self.map { |v| v.class.to_s == 'Class' ? v.to_s : v}.map(&:to_canonical).sort.join
   end
 end
 
-class NSArray
-  def as_json
-    self.map { |v| v.as_json }
+class String
+  def to_canonical
+    self
   end
 end
 
-class Time
-  def as_json
-    self.to_iso8601
+class Symbol
+  def to_canonical
+    to_s
   end
 end
+
+class Boolean; end

data/lib/yapper/settings.rb

@@ -0,0 +1,43 @@
+motion_require 'yapper'
+
+module Yapper::Settings
+  PREFIX = 'yapper-'
+  extend self
+
+  mattr_accessor :db_version
+
+  def get(key)
+    value = storage.objectForKey(storage_key(key))
+
+    # RubyMotion currently has a bug where the strings returned from
+    # standardUserDefaults are missing some methods (e.g. to_data).
+    # And because the returned object is slightly different than a normal
+    # String, we can't just use `value.is_a?(String)`
+    value.class.to_s == 'String' ? value.dup : value
+  end
+
+  def set(key, value)
+    storage.setObject(value, forKey: storage_key(key))
+    storage.synchronize
+  end
+
+  def delete(key)
+    storage.removeObjectForKey(storage_key(key))
+    storage.synchronize
+  end
+
+  def purge
+    storage.dictionaryRepresentation.keys.each { |key| self.delete(key.gsub(/^#{PREFIX}/,'')) if key =~ /^#{PREFIX}/ }
+    storage.synchronize
+  end
+
+  private
+
+  def storage_key(key)
+    "#{PREFIX}#{key}"
+  end
+
+  def storage
+    NSUserDefaults.standardUserDefaults
+  end
+end

data/lib/yapper/timestamps.rb

@@ -1,3 +1,5 @@
+motion_require 'document.rb'
+
 module Yapper::Timestamps
   extend MotionSupport::Concern
 

data/lib/yapper/version.rb

@@ -1,3 +1,3 @@
 module Yapper
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/integration/{where_spec.rb → criteria_spec.rb}

@@ -1,4 +1,4 @@
-describe '#where' do
+describe 'Criteria' do
   before do
     class WhereDocument
       include Yapper::Document
@@ -6,8 +6,10 @@ describe '#where' do
       field :field1, :type => String
       field :field2, :type => Integer
       field :field3, :type => Time
+      field :field4, :type => String
+      field :field5, :type => Boolean
 
-      index :field1, :field2, :field3
+      index :field1, :field2, :field3, :field5
     end
     class AnotherWhereDocument
       include Yapper::Document
@@ -22,16 +24,32 @@ describe '#where' do
   after { Object.send(:remove_const, 'WhereDocument') }
   after { Object.send(:remove_const, 'AnotherWhereDocument') }
 
+  describe 'when changing the index definition' do
+    it "reindexes the fields" do
+      WhereDocument.create(:field1 => 'field1', :field4 => 'field4')
+
+      lambda {
+        WhereDocument.where(:field4 => 'field4').first
+      }.should.raise
+
+      WhereDocument.class_eval do
+        index :field4
+      end
+
+      WhereDocument.where(:field4 => 'field4').count.should == 1
+    end
+  end
+
   describe 'with no documents created' do
     it 'returns []' do
-      WhereDocument.where(:field1 => 'xxx').should == []
+      WhereDocument.where(:field1 => 'xxx').to_a.should == []
     end
   end
 
   describe 'when searching with a non indexed field' do
     it 'raises' do
       lambda {
-        AnotherWhereDocument.where(:field2 => 'xxx')
+        AnotherWhereDocument.where(:field2 => 'xxx').first
       }.should.raise
     end
   end
@@ -42,10 +60,54 @@ describe '#where' do
       WhereDocument.create(:field1 => 'field1_value', :field2 => 2)
       WhereDocument.create(:field1 => 'field1_value', :field2 => 3)
       WhereDocument.create(:field1 => 'field1_value', :field2 => 4)
+      WhereDocument.create(:field1 => 'field1_other_value', :field2 => 1)
       WhereDocument.create(:field1 => 'field1_other_value', :field2 => 2, :field3 => @now)
+      WhereDocument.create(:field5 => true)
       AnotherWhereDocument.create(:field1 => 'field1_value', :field2 => 2)
     end
 
+    describe '#all' do
+      it 'returns all documents' do
+        WhereDocument.all.to_a.count.should == 6
+      end
+
+      describe 'with a document that has no indexes' do
+        before do
+          class NoIndexDocument
+            include Yapper::Document
+
+            field :field1
+          end
+        end
+
+        it 'still returns' do
+          NoIndexDocument.all.count.should == 0
+          NoIndexDocument.all.to_a.count.should == 0
+        end
+      end
+    end
+
+    describe '#count' do
+      it 'returns all documents' do
+        WhereDocument.count.should == 6
+      end
+    end
+
+    describe 'chaining' do
+      it 'where, all' do
+        WhereDocument.all.where(:field1 => 'field1_value').where(:field2 => 2).count.should == 1
+      end
+
+      it 'where, desc, asc' do
+        WhereDocument.where(:field1 => 'field1_value').asc(:field2).first.field2.should == 2
+      end
+
+      it 'desc, asc' do
+        WhereDocument.where(:field1 => 'field1_value').desc(:field1).desc(:field2).first.field2.should == 4
+        WhereDocument.where(:field1 => 'field1_value').desc(:field1).asc(:field2).first.field2.should == 2
+      end
+    end
+
     it 'can search by string' do
       WhereDocument.where(:field1 => 'field1_value').count.should == 3
     end
@@ -58,12 +120,17 @@ describe '#where' do
       WhereDocument.where(:field3 => @now).count.should == 1
     end
 
+    it 'can search by boolean' do
+      WhereDocument.where(:field5 => true).count.should == 1
+      WhereDocument.where(:field5 => false).count.should == 0
+    end
+
     it 'returns [] when looking up a non-existant doc' do
-      WhereDocument.where(:field1 => 'xxx').should == []
+      WhereDocument.where(:field1 => 'xxx').to_a.should == []
     end
 
     it 'can select docments matching on multiple fields' do
-      WhereDocument.where(:field1 => 'field1_value', :field2 => 2).count.should == 1
+      WhereDocument.where(:field1 => 'field1_value', :field2 => 2).to_a.count.should == 1
     end
 
     describe 'when documents are updated' do
@@ -104,13 +171,14 @@ describe '#where' do
         WhereDocument.create(:field1 => 'apple')
         WhereDocument.create(:field1 => 'squash')
         WhereDocument.create(:field1 => 'carrot')
+        WhereDocument.create(:field1 => nil)
       end
       it 'can sort documents ascending' do
-        WhereDocument.where({}, :order => { :field1 => :asc }).collect(&:field1).should == ['apple', 'carrot', 'squash']
+        WhereDocument.asc(:field1).to_a.collect(&:field1).should == [nil, 'apple', 'carrot', 'squash']
       end
 
       it 'can sort documents descending' do
-        WhereDocument.where({}, :order => { :field1 => :desc }).collect(&:field1).should == ['squash', 'carrot', 'apple']
+        WhereDocument.desc(:field1).to_a.collect(&:field1).should == ['squash', 'carrot', 'apple', nil]
       end
     end
 
@@ -121,11 +189,11 @@ describe '#where' do
         WhereDocument.create(:field3 => Time.utc(2013,1,1,14,00))
       end
       it 'can sort documents ascending' do
-        WhereDocument.where({}, :order => { :field3 => :asc }).collect(&:field3).should == [Time.utc(2013,1,1,9,00), Time.utc(2013,1,1,10,00), Time.utc(2013,1,1,14,00)]
+        WhereDocument.asc(:field3).to_a.collect(&:field3).should == [Time.utc(2013,1,1,9,00), Time.utc(2013,1,1,10,00), Time.utc(2013,1,1,14,00)]
       end
 
       it 'can sort documents descending' do
-        WhereDocument.where({}, :order => { :field3 => :desc }).collect(&:field3).should == [Time.utc(2013,1,1,14,00), Time.utc(2013,1,1,10,00), Time.utc(2013,1,1,9,00)]
+        WhereDocument.desc(:field3).to_a.collect(&:field3).should == [Time.utc(2013,1,1,14,00), Time.utc(2013,1,1,10,00), Time.utc(2013,1,1,9,00)]
       end
     end
   end