mongo_record 0.4.2

data/lib/mongo_record/convert.rb

@@ -0,0 +1,64 @@
+# Copyright 2009 10gen, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# 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
+
+  # From Rails
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  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
+
+  # Same symbolize_keys method used in Rails
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end

data/lib/mongo_record/log_device.rb

@@ -0,0 +1,111 @@
+# Copyright 2009 10gen, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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,235 @@
+# Copyright 2009 10gen, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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,109 @@
+# Copyright 2009 10gen, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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
+
+      # Disallow create.
+      def create(values_hash)
+        complain("created")
+      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 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

data/lib/mongo_record.rb

@@ -0,0 +1,21 @@
+# Copyright 2009 10gen, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Include files for using Mongo, MongoRecord::Base, and a database logger.
+
+require 'rubygems'
+require 'mongo'
+require 'mongo_record/base'
+require 'mongo_record/subobject'
+require 'mongo_record/log_device'

data/mongo-activerecord-ruby.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = 'mongo_record'
+  s.version = '0.4.2'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'ActiveRecord-like models for the 10gen Mongo DB'
+  s.description = 'MongoRecord is an ActiveRecord-like framework for the 10gen Mongo database. For more information about Mongo, see http://www.mongodb.org.'
+
+  s.add_dependency('mongo', ['>= 0.15'])
+
+  s.require_paths = ['lib']
+
+  s.files = ['examples/tracks.rb', 'lib/mongo_record.rb',
+             'lib/mongo_record/base.rb',
+             'lib/mongo_record/convert.rb',
+             'lib/mongo_record/log_device.rb',
+             'lib/mongo_record/sql.rb',
+             'lib/mongo_record/subobject.rb',
+             'README.rdoc', 'Rakefile',
+             'mongo-activerecord-ruby.gemspec',
+             'LICENSE']
+  s.test_files = ['tests/address.rb',
+                  'tests/course.rb',
+                  'tests/student.rb',
+                  'tests/class_in_module.rb',
+                  'tests/test_log_device.rb',
+                  'tests/test_mongo.rb',
+                  'tests/test_sql.rb',
+                  'tests/track2.rb',
+                  'tests/track3.rb']
+
+  s.has_rdoc = true
+  s.rdoc_options = ['--main', 'README.rdoc', '--inline-source']
+  s.extra_rdoc_files = ['README.rdoc']
+
+  s.authors = ['Jim Menard', 'Mike Dirolf']
+  s.email = 'mongodb-user@googlegroups.com'
+  s.homepage = 'http://www.mongodb.org'
+end

data/tests/address.rb

@@ -0,0 +1,12 @@
+require 'mongo_record'
+
+class Address < MongoRecord::Subobject
+
+  fields :street, :city, :state, :postal_code
+  belongs_to :student
+
+  def to_s
+    "#{street}\n#{city}, #{state} #{postal_code}"
+  end
+
+end

data/tests/class_in_module.rb

@@ -0,0 +1,11 @@
+require 'mongo_record'
+
+module MyMod
+  class A < MongoRecord::Base
+    field :something
+  end
+end
+
+class B < MongoRecord::Base
+  has_many :a, :class_name => "MyMod::A"
+end

data/tests/course.rb

@@ -0,0 +1,10 @@
+class Course < MongoRecord::Base
+
+  # Declare Mongo collection name and ivars to be saved
+  collection_name :courses
+  field :name
+
+  def to_s
+    "Course #{name}"
+  end
+end

data/tests/student.rb

@@ -0,0 +1,34 @@
+require 'mongo_record'
+require File.join(File.dirname(__FILE__), 'address')
+
+class Score < MongoRecord::Base
+
+  field :grade
+  has_one :for_course, :class_name => 'Course' # Mongo will store course db reference, not duplicate object
+
+  def passed?
+    @grade >= 2.0
+  end
+
+  def to_s
+    "#@for_course: #@grade"
+  end
+
+end
+
+class Student < MongoRecord::Base
+
+  collection_name :students
+  fields :name, :email, :num_array, :created_at, :created_on, :updated_on
+  has_one :address
+  has_many :scores, :class_name => "Score"
+
+  def initialize(row=nil)
+    super
+    @address ||= Address.new
+  end
+
+  def add_score(course_id, grade)
+    @scores << Score.new(:for_course => Course.find(course_id), :grade => grade)
+  end
+end