ribs 0.0.1 → 0.0.2

data/lib/ribs/{session.rb → handle.rb}

@@ -1,26 +1,26 @@
 module Ribs
-  # A Ribs session maps many-to-one with a Hibernate session. When
-  # there are no more Ribs sessions left, the Hibernate session will
+  # A Ribs handle maps many-to-one with a Hibernate session. When
+  # there are no more Ribs handles left, the Hibernate session will
   # be released too.
   #
-  # The methods in Session is not to be used outside the framework in
+  # The methods in Handle is not to be used outside the framework in
   # most cases, since they are internal, brittle, not based on
   # Hibernate in all cases, and very much subject to change. Currently
   # they provide capabilities that aren't part of the framework yet,
   # such as migrations and setting up test data.
   #
-  class Session
-    # This error is thrown when an operation on a session is
+  class Handle
+    # This error is thrown when an operation on a handle is
     # attempted but the internal Hibernate session has already
     # been closed.
     #
     class NotConnectedError < StandardError;end
 
     class << self
-      # Returns a session object from the database +from+. The
+      # Returns a handle object from the database +from+. The
       # available values for from is either one of the existing
       # defined database names, or <tt>:default</tt>, which will give
-      # a session to the default database.
+      # a handle to the default database.
       #
       def get(from = :default)
         db = case from
@@ -31,14 +31,14 @@ module Ribs
              else
                Ribs::DB::get(from)
              end
-        db.session
+        db.handle
       end
     end
     
-    # The current database for this session
+    # The current database for this handle
     attr_reader :db
     
-    # Creates a new session that points to the provided +db+ and
+    # Creates a new handle that points to the provided +db+ and
     # +hibernate_session+
     #
     def initialize(db, hibernate_session)
@@ -47,7 +47,7 @@ module Ribs
       @hibernate_session = hibernate_session
     end
     
-    # Releases this session from the database.  This will possibly
+    # Releases this handle from the database.  This will possibly
     # result in closing the internal Hibernate session, if this is the
     # last Ribs session pointing to that Hibernate session.
     def release
@@ -62,29 +62,35 @@ module Ribs
     end
     
     # LOW LEVEL - shouldn't be used except by Ribs
-    def find(entity_name, id) # :nodoc:
+    def get(entity_name, id) # :nodoc:
       chk_conn
-      if id == :all
-        @hibernate_session.create_criteria(entity_name).list.to_a
-      else
-        @hibernate_session.get(entity_name, java.lang.Integer.new(id))
-      end
+      @hibernate_session.get(entity_name, java.lang.Integer.new(id))
     end
 
     # LOW LEVEL - shouldn't be used except by Ribs
-    def save(obj) # :nodoc:
+    def all(entity_name) # :nodoc:
+      chk_conn
+      @hibernate_session.create_criteria(entity_name).list.to_a
+    end
+    
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def update_obj(obj) # :nodoc:
       chk_conn
       tx = @hibernate_session.begin_transaction
-      if obj.__ribs_meat.persistent
-        @hibernate_session.update(obj)
-      else
-        @hibernate_session.save(obj)
-        obj.__ribs_meat.persistent = true
-      end
+      @hibernate_session.update(obj)
       tx.commit
       obj
     end
 
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def insert_obj(obj) # :nodoc:
+      chk_conn
+      tx = @hibernate_session.begin_transaction
+      @hibernate_session.save(obj)
+      tx.commit
+      obj
+    end
+    
     # LOW LEVEL - shouldn't be used except by Ribs
     def delete(obj) # :nodoc:
       chk_conn

data/lib/ribs/repository.rb

@@ -0,0 +1,243 @@
+module Ribs
+  # Gets a Repository object for the object in question. If the object
+  # is a class, the repository returned will be a Repository::Class,
+  # otherwise it will be a Repository::Instance. Specifically, what
+  # you will get for the class FooBar will be the class
+  # Ribs::Repository::DB_default::FooBar and you will get an instance
+  # of that class if the object is an instance of FooBar. This allows
+  # you to add specific functionality to these repositories.  The
+  # class Ribs::Repository::DB_default::FooBar will also include
+  # Ribs::Repository::FooBar and extend
+  # Ribs::Repository::FooBar::ClassMethods so you can add behavior to
+  # these that map over all databases.
+  def self.Repository(obj, db = :default)
+    db_name = "DB_#{db}"
+    model_type = case obj
+          when Class
+            obj
+          else
+            obj.class
+          end
+
+    dbmod = Ribs::Repository::const_get(db_name)
+    name = model_type.name.split(/::/).join("_")
+
+    if !dbmod.constants.include?(name)
+      Repository::create_repository(name, dbmod)
+    end
+    
+    cls = dbmod::const_get(name.to_sym)
+    Ribs::Repository.ensure_repository(name, cls, model_type, db)
+
+    return cls if obj.kind_of?(Class)
+
+    ret = cls.allocate
+    ret.send :initialize
+    ret.instance_variable_set :@database, db
+    ret.instance_variable_set :@model, obj
+    ret
+  end
+  
+  # A Repository is the main gateway into all functionality in
+  # Ribs. This is where you send your objects to live in the DB, etc.
+  #
+  # A Repository is a combination implementation of both Data Mapper and Repository.
+  module Repository
+    # The ClassMethods are everything that's available when getting
+    # the repository for a specific model class. It includes most of
+    # the things you'd expect to do on the class itself in
+    # ActiveRecord - stuff like finders, creators and things like
+    # that.
+    module ClassMethods
+      include Repository
+
+      # Get the meta data for this model
+      def metadata
+        @metadata
+      end
+
+      # Define accessors for this model
+      def define_accessors
+        self.metadata.properties_and_identity.each do |name, _|
+          self.model.send :attr_accessor, name.downcase
+        end
+      end
+      
+      # Makes a specific instance of this class be marked persistent
+      def persistent(obj)
+        (@persistent ||= {})[obj.object_id] = true
+      end
+      
+      # Checks if a specific instance is marked as persistent
+      def persistent?(obj)
+        @persistent && @persistent[obj.object_id]
+      end
+
+      # Makes a specific instance of this class be marked destroyed
+      def destroyed(obj)
+        (@destroyed ||= {})[obj.object_id] = true
+      end
+      
+      # Checks if a specific instance is marked as destroyed
+      def destroyed?(obj)
+        @destroyed && @destroyed[obj.object_id]
+      end
+
+      # Create a new instance of this model object, optionally setting
+      # properties based on +attrs+.
+      def new(attrs = {})
+        obj = self.model.new
+        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)
+        R(val, self.database).save
+        val
+      end
+      
+      # Returns all instances for the current model
+      def all
+        Ribs.with_handle(self.database) do |h|
+          h.all(self.metadata.persistent_class.entity_name)
+        end
+      end
+
+      # Will get the instance with +id+ or return nil if no such entity
+      # exists.
+      def get(id)
+        Ribs.with_handle(self.database) do |h|
+          h.get(self.metadata.persistent_class.entity_name, id)
+        end
+      end
+
+      # Destroys the model with the id +id+.
+      def destroy(id)
+        Ribs.with_handle(self.database) do |h|
+          h.delete(get(id))
+        end
+      end
+    end
+    
+    # InstanceMethods are those that become available when you the
+    # repository for a specific instance. This allows things like
+    # saving and destroying a specific instance.
+    module InstanceMethods
+      include Repository
+      
+      # Get the meta data for this model
+      def metadata
+        self.class.metadata
+      end
+
+      # Removes this instance from the database.
+      def destroy!
+        self.class.destroyed(self.model)
+        Ribs.with_handle(self.database) do |h|
+          h.delete(self.model)
+        end
+      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_handle(self.database) do |h|
+          if self.class.persistent?(self.model)
+            h.update_obj(self.model)
+          else
+            h.insert_obj(self.model)
+            self.class.persistent(self.model)
+          end
+        end
+        self.model
+      end
+    end
+
+    # Every repository is tied to a specific database
+    attr_reader :database
+    # Every repository is tied to a specific model. This is either a
+    # class or an instance of a class
+    attr_reader :model
+    
+    class << self
+      # Makes sure the class sent in is actually a repostiroy. It
+      # checks all invariants for a Repository and makes them true if
+      # they aren't already.
+      def ensure_repository(name, cls, real, db)
+        unless cls.kind_of?(Repository)
+          mod1 = if Repository.constants.include?(name)
+                   Repository.const_get(name)
+                 else
+                   mod = Module.new
+                   Repository.const_set(name, mod)
+                   mod
+                 end
+          
+          unless mod1.kind_of?(Repository)
+            mod1.send :include, Repository::InstanceMethods
+          end
+
+          unless mod1.constants.include?("ClassMethods")
+            mod1.const_set(:ClassMethods, Module.new)
+          end
+          
+          cls.send :include, mod1
+          cls.send :extend, mod1.const_get(:ClassMethods)
+          cls.send :extend, Repository::ClassMethods
+          cls.instance_variable_set :@database, db
+          cls.instance_variable_set :@model, real
+          cls.instance_variable_set :@metadata, Ribs::metadata_for(db, real, cls)
+        end
+      end
+
+      # Create a repository for a model inside a database
+      def create_repository(name, dbmod)
+        c = Class.new
+        mod1 = if Repository.constants.include?(name)
+                 Repository.const_get(name)
+               else
+                 mod = Module.new
+                 Repository.const_set(name, mod)
+                 mod
+               end
+        dbmod.const_set name, c
+      end
+      
+      # Dynamically create new database modules
+      def const_missing(name)
+        if /^DB_(.*?)$/ =~ name.to_s
+          db_name = $1
+          mod = Module.new
+          mod.instance_variable_set :@database_name, db_name.to_sym
+          const_set name, mod
+          mod
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+  # Gets a Repository object for the object in question. If the object
+  # is a class, the repository returned will be a Repository::Class,
+  # otherwise it will be a Repository::Instance. Specifically, what
+  # you will get for the class FooBar will be the class
+  # Ribs::Repository::DB_default::FooBar and you will get an instance
+  # of that class if the object is an instance of FooBar. This allows
+  # you to add specific functionality to these repositories.  The
+  # class Ribs::Repository::DB_default::FooBar will also include
+  # Ribs::Repository::FooBar and extend
+  # Ribs::Repository::FooBar::ClassMethods so you can add behavior to
+  # these that map over all databases.
+  def R(obj, db=:default)
+    Ribs::Repository(obj, db)
+  end
+end

data/lib/ribs/rib.rb

@@ -0,0 +1,100 @@
+module Ribs
+  # Contains the mapping data that gets created when calling the
+  # {Ribs!} method.
+  class Rib
+    # The proxy object returned when a property name is used in a call
+    # to Rib without any parameters.
+    class RibColumn
+      # Sets the name and all the reference values
+      def initialize(name, columns, primary_keys, to_avoid, default_values)
+        @name, @columns, @primary_keys, @to_avoid, @default_values = 
+          name.to_s, columns, primary_keys, to_avoid, default_values
+      end
+      
+      # This name is a primary key
+      def primary_key!
+        @primary_keys << @name
+      end
+      
+      # This name should be avoided in the database
+      def avoid!
+        @to_avoid << @name.downcase
+      end
+      
+      # This name is mapped to a specific column
+      def column=(col)
+        @columns[@name] = [col.to_s, {}]
+      end
+    end
+
+    # Value object that contains references to the Rib data
+    class ColumnData
+      # 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
+      # List of default values for columns
+      attr_reader :default_values
+
+      # Sets all values
+      def initialize(columns, primary_keys, to_avoid, default_values)
+        @columns, @primary_keys, @to_avoid, @default_values = columns, primary_keys, to_avoid, default_values
+      end
+    end
+
+    # These are the only methods left alone - this becomes a blank
+    # slate, mostly.
+    METHODS_TO_LEAVE_ALONE = ['__id__', '__send__']
+    undef_method *(instance_methods - METHODS_TO_LEAVE_ALONE)
+    
+    # Create all value parts
+    def initialize
+      @columns = { }
+      @primary_keys = []
+      @to_avoid = []
+      @default_values = { }
+    end
+    
+    # Returns a reference object that allow access to the resulting
+    # data objects
+    def __column_data__
+      ColumnData.new(@columns, @primary_keys, @to_avoid, @default_values)
+    end
+
+    # Handles property names. The only ones that aren't possibly to
+    # use is "initialize", "__column_data__", "__id__",
+    # "method_missing" and "__send__". Everything else is
+    # kosher. ... Maybe there should be a way of getting those last
+    # ones too...
+    #
+    # If no arguments are supplied, will return a RibColumn
+    def method_missing(name, *args, &block)
+      if args.empty?
+        RibColumn.new(name, @columns, @primary_keys, @to_avoid, @default_values)
+      else
+        hsh = args.grep(Hash).first || {}
+        args.grep(Symbol).each do |ss|
+          hsh[ss] = true
+        end
+        
+        hsh = {:column => name}.merge(hsh)
+        
+        if hsh[:primary_key]
+          @primary_keys << name.to_s
+        end
+
+        if hsh[:avoid]
+          @to_avoid << name.to_s.downcase
+          if hsh[:default]
+            @default_values[name.to_s.downcase] = hsh[:default]
+          end
+        end
+        
+        @columns[name.to_s] = [hsh[:column].to_s, hsh]
+        nil
+      end
+    end
+  end
+end