mongodb-mongo-activerecord-ruby 0.0.1

data/lib/mongo_record/convert.rb

@@ -0,0 +1,45 @@
+#--
+# Copyright (C) 2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+# Mongo stores trees of JSON-like documents. These +to_mongo_value+ methods
+# covert objects to Hash values, which are converted by the Mongo driver
+# to the proper types.
+
+class Object
+  # Convert an Object to a Mongo value. Used by MongoRecord::Base when saving
+  # data to Mongo.
+  def to_mongo_value
+    self
+  end
+end
+
+class Array
+  # Convert an Array to a Mongo value. Used by MongoRecord::Base when saving
+  # data to Mongo.
+  def to_mongo_value
+    self.collect {|v| v.to_mongo_value}
+  end
+end
+
+class Hash
+  # Convert an Hash to a Mongo value. Used by MongoRecord::Base when saving
+  # data to Mongo.
+  def to_mongo_value
+    h = {}
+    self.each {|k,v| h[k] = v.to_mongo_value}
+    h
+  end
+end

data/lib/mongo_record/log_device.rb

@@ -0,0 +1,113 @@
+#--
+# Copyright (C) 2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module MongoRecord
+
+  # A destination for Ruby's built-in Logger class. It writes log messages
+  # to a Mongo database collection. Each item in the collection consists of
+  # two fields (besides the _id): +time+ and +msg+. +time+ is automatically
+  # generated when +write+ is called.
+  #
+  # If we are running outside of the cloud, all log messages are echoed to
+  # $stderr.
+  #
+  # The collection is capped, which means after the limit is reached old
+  # records are deleted when new ones are inserted. See the new method and
+  # the Mongo documentation for details.
+  #
+  # Example:
+  #
+  #   logger = Logger.new(MongoRecord::LogDevice('my_log_name'))
+  #
+  # The database connection defaults to the global $db. You can set the
+  # connection using MongoRecord::LogDevice.connection= and read it with
+  # MongoRecord::LogDevice.connection.
+  #
+  #   # Set the connection to something besides $db
+  #   MongoRecord::LogDevice.connection = connect('my-database')
+  class LogDevice
+
+    DEFAULT_CAP_SIZE = (10 * 1024 * 1024)
+
+    @@connection = nil
+
+    class << self # Class methods
+
+      # Return the database connection. The default value is
+      # <code>$db</code>.
+      def connection
+        conn = @@connection || $db
+        raise "connection not defined" unless conn
+        conn
+      end
+
+      # Set the database connection. If the connection is set to +nil+, then
+      # <code>$db</code> will be used.
+      def connection=(val)
+        @@connection = val
+      end
+
+    end
+
+    # +name+ is the name of the Mongo database collection that will hold all
+    # log messages. +options+ is a hash that may have the following entries:
+    #
+    # <code>:size</code> - Optional. The max size of the collection, in
+    # bytes. If it is nil or negative then +DEFAULT_CAP_SIZE+ is used.
+    #
+    # <code>:max</code> - Optional. Specifies the maximum number of log
+    # records, after which the oldest items are deleted as new ones are
+    # inserted.
+    #
+    # <code>:stderr</code> - Optional. If not +nil+ then all log messages will
+    # be copied to $stderr.
+    #
+    # Note: a non-nil :max requires a :size value. The collection will never
+    # grow above :size. If you leave :size nil then it will be
+    # +DEFAULT_CAP_SIZE+.
+    #
+    # Note: once a capped collection has been created, you can't redefine
+    # the size or max falues for that collection. To do so, you must drop
+    # and recreate (or let a LogDevice object recreate) the collection.
+    def initialize(name, options = {})
+      @collection_name = name
+      options[:capped] = true
+      options[:size] ||= DEFAULT_CAP_SIZE
+      options[:size] = DEFAULT_CAP_SIZE if options[:size] <= 0
+
+      # It's OK to call createCollection if the collection already exists.
+      # Size and max won't change, though.
+      #
+      # Note we can't use the name "create_collection" because a DB JSObject
+      # does not have normal keys and returns collection objects as the
+      # value of all unknown names.
+      self.class.connection.create_collection(@collection_name, options)
+
+      @console = options[:stderr]
+    end
+
+    # Write a log message to the database. We save the message and a timestamp.
+    def write(str)
+      $stderr.puts str if @console
+      self.class.connection.collection(@collection_name).insert({:time => Time.now, :msg => str})
+    end
+
+    # Close the log. This method is a sham. Nothing happens. You may
+    # continue to use this LogDevice.
+    def close
+    end
+  end
+end

data/lib/mongo_record/sql.rb

@@ -0,0 +1,237 @@
+#--
+# Copyright (C) 2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module MongoRecord
+
+  module SQL
+
+    # A simple tokenizer for SQL.
+    class Tokenizer
+
+      attr_reader :sql
+
+      def initialize(sql)
+        @sql = sql
+        @length = sql.length
+        @pos = 0
+        @extra_tokens = []
+      end
+
+      # Push +tok+ onto the stack.
+      def add_extra_token(tok)
+        @extra_tokens.push(tok)
+      end
+
+      # Skips whitespace, setting @pos to the position of the next
+      # non-whitespace character. If there is none, @pos will == @length.
+      def skip_whitespace
+        while @pos < @length && [" ", "\n", "\r", "\t"].include?(@sql[@pos,1])
+          @pos += 1
+        end
+      end
+
+      # Return +true+ if there are more non-whitespace characters.
+      def more?
+        skip_whitespace
+        @pos < @length
+      end
+
+      # Return the next string without its surrounding quotes. Assumes we have
+      # already seen a quote character.
+      def next_string(c)
+        q = c
+        @pos += 1
+        t = ''
+        while @pos < @length
+          c = @sql[@pos, 1]
+          case c
+          when q
+            if @pos + 1 < @length && @sql[@pos + 1, 1] == q # double quote
+              t += q
+              @pos += 1
+            else
+              @pos += 1
+              return t
+            end
+          when '\\'
+            @pos += 1
+            return t if @pos >= @length
+            t << @sql[@pos, 1]
+          else
+            t << c
+          end
+          @pos += 1
+        end
+        raise "unterminated string in SQL: #{@sql}"
+      end
+
+      # Return +true+ if the next character is a legal starting identifier
+      # character.
+      def identifier_char?(c)
+        c =~ /[\.a-zA-Z0-9_]/ ? true : false
+      end
+
+      # Return +true+ if +c+ is a single or double quote character.
+      def quote?(c)
+        c == '"' || c == "'"
+      end
+
+      # Return the next token, or +nil+ if there are no more.
+      def next_token
+        return @extra_tokens.pop unless @extra_tokens.empty?
+
+        skip_whitespace
+        c = @sql[@pos, 1]
+        return next_string(c) if quote?(c)
+
+        first_is_identifier_char = identifier_char?(c)
+        t = c
+        @pos += 1
+        while @pos < @length
+          c = @sql[@pos, 1]
+          break if c == ' '
+
+          this_is_identifier_char = identifier_char?(c)
+          break if first_is_identifier_char != this_is_identifier_char && @length > 0
+          break if !this_is_identifier_char && quote?(c)
+
+          t << c
+          @pos += 1
+        end
+
+        case t
+        when ''
+          nil
+        when /^\d+$/
+          t.to_i
+        else
+          t
+        end
+      end
+
+    end
+
+    # Only parses simple WHERE clauses right now. The parser returns a query
+    # Hash suitable for use by Mongo.
+    class Parser
+
+      # Parse a WHERE clause (without the "WHERE") ane return a query Hash
+      # suitable for use by Mongo.
+      def self.parse_where(sql, remove_table_names=false)
+        Parser.new(Tokenizer.new(sql)).parse_where(remove_table_names)
+      end
+
+      def initialize(tokenizer)
+        @tokenizer = tokenizer
+      end
+
+      # Given a regexp string like '%foo%', return a Regexp object. We set
+      # Regexp::IGNORECASE so that all regex matches are case-insensitive.
+      def regexp_from_string(str)
+        if str[0,1] == '%'
+          str = str[1..-1]
+        else
+          str = '^' + str
+        end
+
+        if str[-1,1] == '%'
+          str = str[0..-2]
+        else
+          str = str + '$'
+        end
+        Regexp.new(str, Regexp::IGNORECASE)
+      end
+
+      # Parse a WHERE clause (without the "WHERE") and return a query Hash
+      # suitable for use by Mongo.
+      def parse_where(remove_table_names=false)
+        filters = {}
+        done = false
+        while !done && @tokenizer.more?
+          name = @tokenizer.next_token
+          raise "sql parser can't handle nested stuff yet: #{@tokenizer.sql}" if name == '('
+          name.sub!(/.*\./, '') if remove_table_names # Remove "schema.table." from "schema.table.col"
+
+          op = @tokenizer.next_token
+          op += (' ' + @tokenizer.next_token) if op.downcase == 'not'
+          op = op.downcase
+
+          val = @tokenizer.next_token
+
+          case op
+          when "="
+            filters[name] = val
+          when "<"
+            filters[name] = { :$lt => val }
+          when "<="
+            filters[name] = { :$lte => val }
+          when ">"
+            filters[name] = { :$gt => val }
+          when ">="
+            filters[name] = { :$gte  => val }
+          when "<>", "!="
+            filters[name] = { :$ne => val }
+          when "like"
+            filters[name] = regexp_from_string(val)
+          when "in"
+            raise "'in' must be followed by a list of values: #{@tokenizer.sql}" unless val == '('
+            filters[name] = { :$in => read_array }
+          when "between"
+            conjunction = @tokenizer.next_token.downcase
+            raise "syntax error: expected 'between X and Y', but saw '" + conjunction + "' instead of 'and'" unless conjunction == 'and'
+            val2 = @tokenizer.next_token
+            val2, val = val, val2 if val > val2 # Make sure val <= val2
+            filters[name] = { :$gte => val, :$lte => val2 }
+          else
+            raise "can't handle sql operator [#{op}] yet: #{@tokenizer.sql}"
+          end
+
+          break unless @tokenizer.more?
+
+          tok = @tokenizer.next_token.downcase
+          case tok
+          when 'and'
+            next
+          when 'or'
+              raise "sql parser can't handle ors yet: #{@tokenizer.sql}"
+          when 'order', 'group', 'limit'
+            @tokenizer.add_extra_token(tok)
+            done = true
+          else
+            raise "can't handle [#{tok}] yet"
+          end
+        end
+        filters
+      end
+
+      private
+
+      # Read and return an array of values from a clause like "('a', 'b',
+      # 'c')". We have already read the first '('.
+      def read_array
+        vals = []
+        while @tokenizer.more?
+          vals.push(@tokenizer.next_token)
+          sep = @tokenizer.next_token
+          return vals if sep == ')'
+          raise "missing ',' in 'in' list of values: #{@tokenizer.sql}" unless sep == ','
+        end
+        raise "missing ')' at end of 'in' list of values: #{@tokenizer.sql}"
+      end
+    end
+
+  end
+end

data/lib/mongo_record/subobject.rb

@@ -0,0 +1,111 @@
+#--
+# Copyright (C) 2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'mongo_record/base'
+
+module MongoRecord
+
+  # A MongoRecord::Subobject is an MongoRecord::Base subclass that disallows
+  # many operations. Subobjects are those that are contained within and
+  # saved with some other object.
+  #
+  # Using MongoRecord::Subobject is completely optional.
+  #
+  # As an example, say a Student object contains an Address. You might want
+  # to make Address a subclass of Subobject so that you don't accidentally
+  # try to save an address to a collection by itself.
+  class Subobject < Base
+
+    class << self # Class methods
+
+      # Subobjects ignore the collection name.
+      def collection_name(coll_name)
+      end
+
+      # Disallow find.
+      def find(*args)
+        complain("found")
+      end
+
+      # Disallow count.
+      def count(*args)
+        complain("counted")
+      end
+
+      # Disallow delete.
+      def delete(id)
+        complain("deleted")
+      end
+      alias_method :remove, :delete
+
+      # Disallow destroy.
+      def destroy(id)
+        complain("destroyed")
+      end
+
+      # Disallow destroy_all.
+      def destroy_all(conditions = nil)
+        complain("destroyed")
+      end
+
+      # Disallow delete_all.
+      def delete_all(conditions=nil)
+        complain("deleted")
+      end
+
+      private
+
+      def complain(cant_do_this)
+        raise "Subobjects can't be #{cant_do_this} by themselves. Use a subobject query."
+      end
+
+    end                       # End of class methods
+
+    public
+
+    # Subobjects do not have their own ids.
+    def id=(val); raise "Subobjects don't have ids"; end
+
+    # Subobjects do not have their own ids.
+    # You'll get a deprecation warning if you call this outside of Rails.
+    def id; raise "Subobjects don't have ids"; end
+
+    # to_param normally returns the id of an object. Since subobjects don't
+    # have ids, this is disallowed.
+    def to_param; raise "Subobjects don't have ids"; end
+
+    # Disallow new_record?
+    def new_record?; raise "Subobjects don't have ids"; end
+
+    # Disallow create.
+    def create
+      self.class.complain("created")
+    end
+
+    # Disallow udpate.
+    def update
+      self.class.complain("updated")
+    end
+
+    # Disallow delete and remove.
+    def delete
+      self.class.complain("deleted")
+    end
+    alias_method :remove, :delete
+
+  end
+
+end