ribs 0.0.1 → 0.0.2

data/README

@@ -14,6 +14,11 @@ you to use Hibernate to persist your Ruby objects. There are many
 things planned for Ribs, but currently it only supports quite basic
 operations.
 
+Ribs is explicitly defined to solve several data access patterns for
+most Ruby development. In one end it means scaling down from something
+very much like ActiveRecord, but on the other end supports such things
+as Repository, Data Mapper, Unit of Work and Identity Map.
+
 == Definitions
 
 To get started, you first need to define a database connection for
@@ -37,15 +42,25 @@ See the define method and the Ribs::DB class for more information on
 what's available.
 
 To actually make a Ruby class a database backed objects, you use the
-method {Kernel#Ribs!}[link:classes/Kernel.html#M000038] In the simple case you don't need to actually
-provide any configuration, but support is available for renaming
-columns, deciding which one is the primary key, and also avoid making
-columns part of the object. The simple case looks like this:
+method {Kernel#Ribs!}[link:classes/Kernel.html#M000038] In the simple
+case you don't need to actually provide any configuration, but support
+is available for renaming columns, deciding which one is the primary
+key, and also avoid making columns part of the object. The simplest
+case looks like this:
 
+  class Blog
+  end
+
+That is more or less the same as doing
+  
   class Blog
     Ribs!
   end
 
+This method call will not do anything that won't be done implicitly at
+the first usage of it as a Ribs model. This means that if you follow
+conventions exactly, you don't need to configure anything at all.
+
 It can also be written as:
 
   class Blog; end
@@ -65,22 +80,31 @@ To redefine which table to use, the names of the columns, and where
 the primary key is, you need to provide a block to the {Ribs!}[link:classes/Kernel.html#M000038] method:
 
   class Blog
-    Ribs! do |r|
-      r.table :blogs
-
-      r.primary_key :blog_id
+    Ribs! :table => :blogs do |r|
+      r.blog_id.primary_key!
 
-      r.col :title, :blog_title
+      r.blog_title :column => :title
 
-      r.avoid :irrelevant_column
+      r.irrelevant_column.avoid!
     end
   end
 
 This code will back the model against the "blogs" table, have the
 column name blog_id represent the primary key, and map the column
-title to the property blog_title. Note that primary_key[link:classes/Ribs/Rib.html#M000028] can take a
-second parameter that is the property name. Finally, avoid[link:classes/Ribs/Rib.html#M000029] tells Ribs
-to avoid a specific column.
+title to the property blog_title. Finally, avoid! tells Ribs
+to avoid a specific column, so it won't try to map that.
+
+If you have a primary key that you want to have a different name, or a
+column you want to avoid but it's not nullable, you can use these
+variations instead:
+
+  class Blog
+    Ribs! :table => :blogs do |r|
+      r.blog_id :primary_key, :column => :id
+
+      r.irrelevant_column :avoid, :default => "value to insert:
+    end
+  end
 
 Currently Ribs only supports simple data types. It doesn't include
 associations, and have no support for setting default values, or
@@ -93,46 +117,52 @@ Once you have a defined model, you can work with it in several
 different ways.
 
 If you want to create new instances you can do it much like with
-ActiveRecord:
+ActiveRecord, except that you always need to surround a call to
+anything regarding the database with an invocation to the method
+R. This method takes either a class or an instance, and returns a
+repository proxy for the argument. You can also send in a specific
+database name if you want to work with another database then the
+default one.:
 
   blog = Blog.new
   blog.blog_id = 1
   blog.blog_title = "Foobar"
-  blog.save
+  R(blog).save
 
-The new method can take the parameters as a hash of symbols too:
+The new-method returned from R can take the parameters as a hash of
+symbols too:
 
-  blog = Blog.new(
+  blog = R(Blog).new(
     :blog_id => 1,
     :blog_title => "Foobar")
-  blog.save
+  R(blog).save
 
 And as a short hand a create method is available:
 
-  blog = Blog.create(
+  blog = R(Blog).create(
     :blog_id => 1,
     :blog_title => "Foobar")
 
 To find a specific entry:
 
-  blog = Blog.find(1)
+  blog = R(Blog).get(1)
 
 Or to find all entries:
 
-  blogs = Blog.find(:all)
+  blogs = R(Blog).all
 
 To update an entry:
   
   blog.blog_title = "New title"
-  blog.save
+  R(blog).save
 
 To destroy an existing entry:
 
-  blog.destroy!
+  R(blog).destroy!
 
 Or to destroy it based on id:
  
-  Blog.destroy(1)
+  R(Blog).destroy(1)
 
 == License
 

data/Rakefile

@@ -43,7 +43,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
   s.name   = "ribs"
   s.summary = "Ribs wraps Hibernate, to provide a good ORM for JRuby"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
   s.author = 'Ola Bini'
   s.description = s.summary
   s.homepage = 'http://ribs.rubyforge.org'

data/lib/ribs.rb

@@ -22,9 +22,11 @@ require 'ribs.jar'
 require 'bigdecimal'
 
 require 'ribs/db'
+require 'ribs/rib'
 require 'ribs/definition'
-require 'ribs/session'
+require 'ribs/handle'
 require 'ribs/meat'
+require 'ribs/repository'
 require 'ribs/core_ext/time'
 
 # The Ribs module includes most functionality needed for Ribs. The
@@ -34,21 +36,40 @@ require 'ribs/core_ext/time'
 module Ribs
   class << self
 
-    # The with_session method provides an easy way of working with a
-    # low level Ribs session. It will get a session for the database
-    # in question, yield that session to the block and then release
-    # the session when finished. This should generally not be needed,
+    # The with_handle method provides an easy way of working with a
+    # low level Ribs Handle. It will get a handle for the database
+    # in question, yield that handle to the block and then release
+    # the handle when finished. This should generally not be needed,
     # but wrapping a block if code with this method is a good way of
-    # opening a session and make sure it doesn't get fully closed
+    # opening a handle and make sure it doesn't get fully closed
     # until after the block.
     # 
-    # +from+ decides which database definition to get a session for.
+    # +from+ decides which database definition to get a handle for.
     #
-    def with_session(from = :default)
-      s = Ribs::Session.get(from)
-      yield s
+    def with_handle(from = :default)
+      h = Ribs::Handle.get(from)
+      yield h
     ensure
-      s.release
+      h.release
+    end
+
+    # Defines a model with the given name, defining attribute
+    # accessors and also providing the Ribs mapping from the block
+    def define_model(name, options = {}, &block)
+      base = Object
+      cls = Class.new
+      names = name.to_s.split(/::/)
+      names[0..-2].each do |nm|
+        if !base.constants.include?(nm)
+          base.const_set nm, Module.new
+        end
+        base = base.const_get nm
+      end
+      base.const_set names.last, cls
+
+      Ribs!({:on => cls}.merge(options), &block)
+      R(cls).define_accessors
+      cls
     end
   end
 end

data/lib/ribs/db.rb

@@ -146,7 +146,7 @@ module Ribs
         properties.set_property(key, value)
       end
       @configuration = Configuration.new.add_properties(properties)
-      @configuration.set_interceptor org.jruby.ribs.EntityNameInterceptor.new
+      @configuration.set_interceptor org.jruby.ribs.RubyInterceptor.new(self, (self.default? ? :default : self.name).to_s)
       @mappings = @configuration.create_mappings
       reset_session_factory!
     end
@@ -157,26 +157,26 @@ module Ribs
       @session_factory = @configuration.build_session_factory
     end
     
-    # Fetch a new Ribs session connected to the this database. Returns
-    # a Ribs::Session object.
-    def session
+    # Fetch a new Ribs handle connected to the this database. Returns
+    # a Ribs::Handle object.
+    def handle
       sessions = (Thread.current[:ribs_db_sessions] ||= {})
       if curr = sessions[self.object_id]
         curr[1] += 1 #reference count
-        Session.new(self, curr[0])
+        Handle.new(self, curr[0])
       else
         sess = @session_factory.open_session
         sessions[self.object_id] = [sess,1]
-        Session.new(self, sess)
+        Handle.new(self, sess)
       end
     end
     
-    # Release a Ribs::Session object that is connected to this
-    # database. That Session object should not be used after this
+    # Release a Ribs::Handle object that is connected to this
+    # database. That Handle object should not be used after this
     # method has been invoked.
-    def release(session)
+    def release(handle)
       res = Thread.current[:ribs_db_sessions][self.object_id]
-      if res[0] == session.hibernate_session
+      if res[0] == handle.hibernate_session
         res[1] -= 1
         if res[1] == 0
           res[0].close

data/lib/ribs/definition.rb

@@ -1,80 +1,40 @@
 module Ribs
-  # Ribs::ClassMethods contains all the methods that gets mixed in to
-  # a model class.
-  module ClassMethods
-    # Get the metadata for the current model
-    attr_reader :ribs_metadata
+  # Keeps track of defined Ribs
+  @ribs = {}
 
-    # Create a new instance of this model object, optionally setting
-    # properties based on +attrs+.
-    def new(attrs = {})
-      obj = super()
-      attrs.each do |k,v|
-        obj.send("#{k}=", v)
-      end
-      obj
-    end
-
-    # First creates a model object based on the values in +attrs+ and
-    # then saves this to the database directly.
-    def create(attrs = {})
-      val = new(attrs)
-      val.save
-      val
-    end
-    
-    # Depending on the value of +id_or_sym+, tries to find the model
-    # with a specified id, or if +id_or_sym+ is <tt>:all</tt> returns
-    # all instances of this model.
-    def find(id_or_sym)
-      Ribs.with_session do |s|
-        s.find(self.ribs_metadata.persistent_class.entity_name, id_or_sym)
-      end
+  class << self
+    # Returns the specific metadata for a combination of model class
+    # and database identifier. If there is no such entry, tries to
+    # find the default entry for the model class.
+    def metadata(db, model)
+      @ribs[[db, model]] || @ribs[model]
     end
 
-    # Destroys the model with the id +id+.
-    def destroy(id)
-      Ribs.with_session do |s|
-        s.delete(find(id))
-      end
-    end
-    
-    
-    # TODO: add inspect here
-  end
-  
-  # Ribs::InstanceMethods provides the methods that gets mixed in to
-  # all instances of a model object.
-  module InstanceMethods
-    # Returns the Meat instance for this instance.
-    def __ribs_meat
-      @__ribs_meat ||= Ribs::Meat.new(self)
-    end
-        
-    # Returns an inspection based on current values of the data in the
-    # database.
-    def inspect
-      "#<#{self.class.name}: #{self.__ribs_meat.properties.inspect}>"
-    end
-    
-    # Saves this instance to the database. If the instance already
-    # exists, it will update the database, otherwise it will create
-    # it.
-    def save
-      Ribs.with_session do |s|
-        s.save(self)
+    # Adds metadata for a specific model and an optional database. If
+    # the database is nil, it will add the model as a default metadata
+    def add_metadata_for(db, model, metadata)
+      if db
+        @ribs[[db, model]] = metadata
+      else
+        @ribs[model] = metadata
       end
     end
     
-    # Removes this instance from the database.
-    def destroy!
-      __ribs_meat.destroyed = true
-      Ribs.with_session do |s|
-        s.delete(self)
+    # Tries to find metadata for the model in question and defines new
+    # metadata with define_ribs if no existing metadata exists. This
+    # means that you should do your database definitions before using
+    # the method R for that model.
+    def metadata_for(db, model, from)
+      if (v = metadata(db, model))
+        return v
       end
+
+      metadata = Ribs::MetaData.new
+      define_ribs(model, :db => db, :metadata => metadata, :from => from)
+      metadata
     end
   end
-  
+
   # Collects all the meta data about a specific Ribs model
   class MetaData
     # The table to connect to
@@ -84,7 +44,14 @@ module Ribs
     attr_accessor :persistent_class
     # The Rib that defines all the mapping data
     attr_accessor :rib
+    # Should this object be saved in an identity map?
+    attr_accessor :identity_map
     
+    # Should this object be saved in an identity map?
+    def identity_map?
+      self.identity_map
+    end
+
     # Return the property instance for the given +name+.
     def [](name)
       self.persistent_class.get_property(name.to_s) rescue nil
@@ -93,56 +60,24 @@ module Ribs
     # Return all the properties for this model.
     def properties
       self.persistent_class.property_iterator.to_a.inject({}) do |h, value|
-        h[value.name] = value
+        if !value.respond_to?(:getRubyValue)
+          h[value.name] = value
+        end
         h
       end
     end
-  end
 
-  # Contains the mapping data that gets created when calling the
-  # {Ribs!} method.
-  class Rib
-    # List of all the columns defined
-    attr_reader :columns
-    # List of all primary keys defined
-    attr_reader :primary_keys
-    # List of all columns to avoid
-    attr_reader :to_avoid
-
-    # Initializes object
-    def initialize
-      @columns = { }
-      @primary_keys = { }
-      @to_avoid = []
-    end
-    
-    # Gets or sets the table name to work with. If +name+ is nil,
-    # returns the table name, if not sets the table name to +name+.
-    def table(name = nil)
-      if name
-        @table = name
-      else
-        @table
+    # Return all the properties for this model.
+    def properties_and_identity
+      (self.persistent_class.property_iterator.to_a + [self.persistent_class.identifier_property]).inject({}) do |h, value|
+        if !value.respond_to?(:getRubyValue)
+          h[value.name] = value
+        end
+        h
       end
     end
-    
-    # Adds a new column mapping for a specific column.
-    def col(column, property = column, options = {})
-      @columns[column.to_s.downcase] = [property.to_s, options]
-    end
-
-    # Adds a new primary key mapping for a column.
-    def primary_key(column, property = column, options = {})
-      @primary_keys[column.to_s.downcase] = property.to_s
-      @columns[column.to_s.downcase] = [property.to_s, options]
-    end
-    
-    # Avoids all the provided columns
-    def avoid(*columns)
-      @to_avoid += columns.map{|s| s.to_s.downcase}
-    end
   end
-  
+
   Table = org.hibernate.mapping.Table
   Column = org.hibernate.mapping.Column
   Property = org.hibernate.mapping.Property
@@ -156,8 +91,15 @@ module Ribs
     # The Ruby class
     attr_accessor :ruby_class
     
+    # Initialize data for this RootClass
     def initialize(*args)
       super
+      @data = {}
+    end
+    
+    # Sets a specific data element
+    def []=(key, value)
+      @data[key] = value
     end
     
     # Get the Ruby class. Implementation of the WithRubyClass
@@ -165,6 +107,29 @@ module Ribs
     def getRubyClass
       @ruby_class
     end
+    
+    # Gets a specific data element
+    def getRubyData(key)
+      @data[key]
+    end
+  end
+
+  # A Hibernate Property that can contain a Ruby value too.
+  class RubyValuedProperty < org.hibernate.mapping.Property
+    include org.jruby.ribs.WithRubyValue
+
+    # The Ruby class
+    attr_accessor :ruby_value
+    
+    # Creation
+    def initialize(*args)
+      super
+    end
+    
+    # Implement the interface - return the actual Ruby value
+    def getRubyValue
+      @ruby_value
+    end
   end
   
   class << self
@@ -175,19 +140,34 @@ module Ribs
     # +options+ have several possible values:
     # * <tt>:db</tt> - the database to connect this model to
     #
+    # This method is in urgent need of refactoring.
+    #
     def define_ribs(on, options = {})
       rib = Rib.new
       yield rib if block_given?
        
-      define_metadata_on_class on
-      rm = on.ribs_metadata
-      rm.rib = rib
+      unless options[:metadata]
+        options[:metadata] = Ribs::MetaData.new      
+      end
 
+      rm = options[:metadata]
+      Ribs::add_metadata_for(options[:db], on, rm)
+      rm.identity_map = options.key?(:identity_map) ? options[:identity_map] : true
+
+      unless options[:from]
+        options[:from] = R(on, options[:db] || :default)
+      end
+
+      rm.rib = rib
+      rib_data = rib.__column_data__
+      
+      
       db = nil
-      with_session(options[:db] || :default) do |s|
-        db = s.db
-        m = s.meta_data
-        name = rib.table || table_name_for(on.name, m)
+      with_handle(options[:db] || :default) do |h|
+        db = h.db
+        m = h.meta_data
+
+        name = table_name_for((options[:table] || on.name), m)
 
         tables = m.get_tables nil, nil, name.to_s, %w(TABLE VIEW ALIAS SYNONYM).to_java(:String)
         if tables.next
@@ -222,25 +202,35 @@ module Ribs
           pc.add_tuplizer(org.hibernate.EntityMode::MAP, "org.jruby.ribs.RubyTuplizer")
           
           rm.persistent_class = pc
+          rm.persistent_class["meatspace"] = options[:from] if options[:from]
           
           table.column_iterator.each do |c|
-            unless rib.to_avoid.include?(c.name.downcase)
+            unless rib_data.to_avoid.include?(c.name.downcase)
               prop = Property.new
               prop.persistent_class = pc
-              prop.name = ((v=rib.columns[c.name.downcase]) && v[0]) || c.name
+              prop.name = ((v=rib_data.columns.find{ |key, val| val[0].to_s.downcase == c.name.downcase}) && v[0]) || c.name
               val = SimpleValue.new(table)
               val.add_column(c)
               val.type_name = get_type_for_sql(c.sql_type, c.sql_type_code)
               prop.value = val
-              
-              if (!rib.primary_keys.empty? && rib.primary_keys[c.name.downcase]) || c.name.downcase == 'id'
+              if (!rib_data.primary_keys.empty? && rib_data.primary_keys.include?(prop.name)) || c.name.downcase == 'id'
                 pc.identifier_property = prop
                 pc.identifier = val
               else
                 pc.add_property(prop)
               end
-              
-              define_meat_accessor(on, prop.name)
+            else
+              if !c.nullable
+                prop = RubyValuedProperty.new
+                prop.ruby_value = rib_data.default_values[c.name.downcase]
+                prop.persistent_class = pc
+                prop.name = ((v=rib_data.columns[c.name.downcase]) && v[0]) || c.name
+                val = SimpleValue.new(table)
+                val.add_column(c)
+                val.type_name = get_type_for_sql(c.sql_type, c.sql_type_code)
+                prop.value = val
+                pc.add_property(prop)
+              end
             end
           end
           pc.create_primary_key
@@ -257,21 +247,6 @@ module Ribs
     JTypes = java.sql.Types
     
     private
-    # Defines the actual accessor for a specific property on a
-    # class. This will define methods that use the Meat to get data.
-    def define_meat_accessor(clazz, name)
-      downcased = name.downcase
-      clazz.class_eval <<CODE
-  def #{downcased}
-    self.__ribs_meat[:"#{name}"]
-  end
-
-  def #{downcased}=(value)
-    self.__ribs_meat[:"#{name}"] = value
-  end
-CODE
-    end
-
     # Returns the Java type for a specific combination of a type name
     # and an SQL type code
     def get_type_for_sql(name, code)
@@ -305,25 +280,14 @@ CODE
     # Tries to figure out if a table name should be in lower case or
     # upper case, and returns the table name based on that.
     def table_name_for(str, metadata)
+      str = str.to_s.gsub(/::/, '_')
       if metadata.stores_lower_case_identifiers
         str.downcase
       elsif metadata.stores_upper_case_identifiers
-        str.upcase!
+        str.upcase
       else
         str
       end
     end
-    
-    # Defines the meta data information on a class, and mixes in
-    # ClassMethods and InstanceMethods to it.
-    def define_metadata_on_class(clazz)
-      clazz.instance_variable_set :@ribs_metadata, Ribs::MetaData.new
-      class << clazz
-        include ClassMethods
-      end
-      clazz.class_eval do 
-        include InstanceMethods
-      end
-    end
   end
 end