mongolitedb 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c4ba47f1829ac304ccd6b11f7ef4ea97e06b4c1
-  data.tar.gz: 020c5c5191f247972874ac9f4c474e4ca7272ed8
+  metadata.gz: 61d2c498c08966845f3e8d5ac13c8858599f831b
+  data.tar.gz: 514b684b4a2c21f75437f68bdf1b39b7cb8baea0
 SHA512:
-  metadata.gz: c7012586e2c0a364f5952de9c9e932fe01fd9c183f951eeb6807295cf718c92af3143527a5a2d30c0a504788727ac370b0463213bd73393342ca094d82fcba74
-  data.tar.gz: cd39d1355be855655dde02048e8523017c658067e90d4719cc29f5866850b2118eb754d34e3bb78255e9747dd52d98c5ddfdb6a1d877209284ef7b9130487722
+  metadata.gz: f89e5e7be09e0992104210f61c7eb3340f23b1628422075f4973a510e29a4c5b5e524eff969363ab50c44c3a5bcf63d71135dd612e4e18c3cd9f4932f82f3b9c
+  data.tar.gz: c5a076ba07eb8f8a2d77da70ef8f7b8f55ae05d898ad89371084981bb90638fdf3d23c437cfb75f416638893703b467bd86715c70b1d68f43047bd9673b7abc0

data/lib/matcher.rb

@@ -0,0 +1,87 @@
+require 'predicate_matcher'
+
+class Matcher
+  def initialize(query)
+    @query = query
+  end
+
+  def match(obj)
+    if @query.length > 1
+      # We always have an implied $and for multiple entries
+      matcher = AndMatcher.new({"$and" => @query.map{|k,v| {k => v}}})
+    elsif @query.length == 0
+      matcher = EmptyMatcher.new(@query)
+    else 
+      # we only have one entry
+      case @query.keys.first
+      when "$or"
+        matcher = OrMatcher.new(@query)
+      when "$nor"
+        matcher = NorMatcher.new(@query)
+      when "$and"
+        matcher = AndMatcher.new(@query)
+      else
+        matcher = AttrMatcher.new(@query)
+      end
+    end
+    return matcher.match(obj)
+  end
+end
+
+class AttrMatcher < Matcher
+  def match(obj)
+    attribute = @query.keys.first
+    if attribute.include?(".")
+      value = obj
+      attribute.split(".").each do |attr|
+        value = value[attr]
+        if value.nil?
+          return false
+        end
+      end
+    else
+      value = obj[@query.keys.first]
+    end
+    predicate = @query.values.first
+    if predicate.kind_of? Hash
+      matcher = PredicateMatcher.new(predicate)
+      return matcher.match(value)
+    else
+      return value == predicate
+    end
+  end
+end
+
+class AndMatcher < Matcher
+  def match(obj)
+    does_it_match = true 
+    @query.values.first.each do |subquery|
+      matcher = Matcher.new(subquery)
+      does_it_match &&= matcher.match(obj) 
+    end  
+    return does_it_match
+  end 
+end
+
+class EmptyMatcher < Matcher
+  def match(obj)
+    true
+  end
+end
+
+class OrMatcher < Matcher
+  def match(obj)
+    does_it_match = false
+    @query.values.first.each do |subquery|
+      matcher = Matcher.new(subquery)
+      does_it_match ||= matcher.match(obj)
+    end
+    return does_it_match
+  end
+end
+
+class NorMatcher < Matcher
+  def match(obj)
+    return !OrMatcher.new(@query).match(obj)
+  end
+end

data/lib/mongolitedb.rb

@@ -1,160 +1,92 @@
 require 'json'
+require 'matcher'
 
 class MongoLiteDB
-    def initialize(filename="db.nsl")
-        @filename = filename
-        if not File.exists?(@filename)
-            open(@filename, 'w'){|f| f.write(
-                {
-                    "max_index" => 0,
-                    "objects" => []
-                }.to_json
-            )}
-        end
+  def initialize(filename="db.nsl")
+    @filename = filename
+    if not File.exists?(@filename)
+      open(@filename, 'w'){|f| f.write(
+        {
+          "max_index" => 0,
+          "objects" => []
+        }.to_json
+      )}
     end
-    def insert(objects)
-        if not objects.kind_of?(Array)
-           objects  = [objects]
-        end
-        write_to_disk do |db|
-            objects.each do |object|
-                object_copy = object.clone
-                object_copy["id"] = db["max_index"]
-                db["max_index"] += 1
-                db["objects"] << object_copy
-            end
-        end
+  end
+  def insert(objects)
+    if not objects.kind_of?(Array)
+      objects  = [objects]
     end
-    def find(query)
-        entries = []
-        load_from_disk do |db|
-            each_match(db, query) do |obj|
-                entries << obj
-            end  
-        end
-        return entries
+    write_to_disk do |db|
+      objects.each do |object|
+        object_copy = object.clone
+        object_copy["id"] = db["max_index"]
+        db["max_index"] += 1
+        db["objects"] << object_copy
+      end
     end
-        
-    def update(query, attr)
-        write_to_disk do |db|
-            each_match(db, query) do |obj|
-                obj.update(attr) 
-            end 
-        end     
+  end
+  def find(query)
+    entries = []
+    load_from_disk do |db|
+      each_match(db, query) do |obj|
+        entries << obj
+      end  
     end
-    def delete(query)
-        write_to_disk do |db|
-            each_match(db, query) do |obj|
-                db["objects"].delete(obj)
-            end
-        end
+    return entries
+  end
+  def update(query, attr)
+    write_to_disk do |db|
+      each_match(db, query) do |obj|
+        obj.update(attr) 
+      end 
+    end     
+  end
+  def delete(query)
+    write_to_disk do |db|
+      each_match(db, query) do |obj|
+        db["objects"].delete(obj)
+      end
     end
+  end
 
-    private
-    def write_to_disk
-        f = open(@filename, 'r+')
-        f.flock(File::LOCK_EX)
-        db = JSON.parse f.read
-        yield db
-    ensure
-        if f
-            if db
-                f.rewind
-                f.write db.to_json
-                f.flush
-                f.truncate f.pos
-            end
-            f.close
-        end
+  private
+  def write_to_disk
+    f = open(@filename, 'r+')
+    f.flock(File::LOCK_EX)
+    db = JSON.parse f.read
+    yield db
+  ensure
+    if f
+      if db
+        f.rewind
+        f.write db.to_json
+        f.flush
+        f.truncate f.pos
+      end
+      f.close
     end
+  end
 
-    def load_from_disk
-        f = open(@filename, 'r+')
-        f.flock(File::LOCK_SH)
-        db = JSON.parse f.read
-        yield db
-    ensure
-        if f
-            f.close
-        end 
-    end
+  def load_from_disk
+    f = open(@filename, 'r+')
+    f.flock(File::LOCK_SH)
+    db = JSON.parse f.read
+    yield db
+  ensure
+    if f
+      f.close
+    end 
+  end
 
-    def each_match(db, query)
-        db["objects"].clone.each do |obj|
-            yield(obj) unless not match(obj, query)
-        end
+  def each_match(db, query)
+    db["objects"].clone.each do |obj|
+      yield(obj) unless not match(obj, query)
     end
+  end
 
-    def match(obj, query)
-        # query is either an array in the form of [key, value] or a hash
-        # if query is an Array, key is a string, value can be anything
-        #   if value is an array, we should expect a keyword for key
-        #   if value is an hash, we should expect it's only key to be a keyword
-        #   if value is a string or FixNum , we should check for attribute match
-        # if query is Hash, then we break it into individual queries and recursively call them (as arrays)
-        if query.kind_of? Array
-            if query[1].kind_of? Array
-                case query[0]
-                when "$or"
-                    match = false
-                    query[1].each do |attr|
-                        is_a_match = match(obj, attr)
-                        match ||= is_a_match
-                    end
-                    return match
-                else
-                    raise NotImplementedError
-                end
-            elsif query[1].kind_of? Hash
-                match = true
-                query[1].each do |k,v|
-                    case k
-                    when "$in"
-                        local_match = false
-                        v.each do |value|
-                            is_a_match = match(obj, [query[0], value])
-                            local_match ||= is_a_match
-                        end
-                        match &&= local_match
-                    when "$exists"
-                        match &&= (not obj[query[0]].nil?) == v
-                    when "$nin"
-                        local_match = true
-                        v.each do |value|
-                            is_a_match = match(obj, [query[0], value])
-                            local_match &&= (not is_a_match)
-                        end
-                        match &&= local_match
-                    when "$gt"
-                        return obj[query[0]] > v
-                    when "$gte"
-                        return obj[query[0]] >= v
-                    when "$lt"
-                        return obj[query[0]] < v
-                    when "$lte"
-                        return obj[query[0]] <= v
-                    when "$ne"
-                        return obj[query[0]] != v
-                    when "$mod"
-                        return obj[query[0]] % v[0] == v[1]
-                    else
-                        raise NotImplementedError
-                    end
-                end
-                return match
-            else
-                match = (obj[query[0]] == query[1])
-                return match
-            end
-        elsif query.kind_of? Hash
-          match = true
-          query.to_a.each do |attr|
-              is_a_match = match(obj, attr)
-              match &&= is_a_match
-          end
-          return match
-        else
-            raise NotImplementedError
-        end
-    end
+  def match(obj, query)
+    matcher = Matcher.new(query)
+    return matcher.match(obj)
+  end
 end

data/lib/predicate_matcher.rb

@@ -0,0 +1,45 @@
+class PredicateMatcher
+  def initialize(predicate)
+    @predicate = predicate
+  end
+  def match(value)
+    if @predicate.length > 1
+      matcher = AndPredicateMatcher.new(@predicate)
+      return matcher.match(value)
+    end
+    case @predicate.keys.first
+    when "$exists"
+      return @predicate.values.first == !value.nil? 
+    when "$in"
+      return @predicate.values.first.include?(value)
+    when "$nin"
+      return !@predicate.values.first.include?(value)
+    when "$gt"
+      return value > @predicate.values.first
+    when "$gte"
+      return value >= @predicate.values.first
+    when "$lt"
+      return value < @predicate.values.first
+    when "$lte"
+      return value <= @predicate.values.first
+    when "$ne"
+      return value != @predicate.values.first
+    when "$mod"
+      return value % @predicate.values.first[0] == @predicate.values.first[1]
+    else
+      raise NotImplementedError
+    end  
+  end
+end
+
+class AndPredicateMatcher < PredicateMatcher
+  def match(value)
+    does_it_match = true
+    @predicate.each do |k,v|
+      matcher = PredicateMatcher.new({k => v})  
+      does_it_match &&= matcher.match(value)
+    end
+    return does_it_match
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongolitedb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Peter Hamilton
@@ -17,6 +17,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/mongolitedb.rb
+- lib/matcher.rb
+- lib/predicate_matcher.rb
 homepage: https://github.com/hamiltop/MongoLiteDB
 licenses: []
 metadata: {}
@@ -36,7 +38,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: MongoLiteDB embedded database