ribs 0.0.1

data/lib/ribs/definition.rb

@@ -0,0 +1,329 @@
+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
+
+    # 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
+    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)
+      end
+    end
+    
+    # Removes this instance from the database.
+    def destroy!
+      __ribs_meat.destroyed = true
+      Ribs.with_session do |s|
+        s.delete(self)
+      end
+    end
+  end
+  
+  # Collects all the meta data about a specific Ribs model
+  class MetaData
+    # The table to connect to
+    attr_accessor :table
+    # The persistent class that Hibernate uses as a definition for
+    # this model.
+    attr_accessor :persistent_class
+    # The Rib that defines all the mapping data
+    attr_accessor :rib
+    
+    # Return the property instance for the given +name+.
+    def [](name)
+      self.persistent_class.get_property(name.to_s) rescue nil
+    end
+
+    # Return all the properties for this model.
+    def properties
+      self.persistent_class.property_iterator.to_a.inject({}) do |h, value|
+        h[value.name] = value
+        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
+      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
+  SimpleValue = org.hibernate.mapping.SimpleValue
+
+  # A simple helper class that allows the Java parts of the system to
+  # get the Ruby class from the PersistentClass instance.
+  class RubyRootClass < org.hibernate.mapping.RootClass
+    include org.jruby.ribs.WithRubyClass
+
+    # The Ruby class
+    attr_accessor :ruby_class
+    
+    def initialize(*args)
+      super
+    end
+    
+    # Get the Ruby class. Implementation of the WithRubyClass
+    # interface.
+    def getRubyClass
+      @ruby_class
+    end
+  end
+  
+  class << self
+    # Define a rib for the class +on+. If a block is given, will first
+    # yield an instance of Rib to it and then base the mapping
+    # definition on that.
+    #
+    # +options+ have several possible values:
+    # * <tt>:db</tt> - the database to connect this model to
+    #
+    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
+
+      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)
+
+        tables = m.get_tables nil, nil, name.to_s, %w(TABLE VIEW ALIAS SYNONYM).to_java(:String)
+        if tables.next
+          table = Table.new(tables.get_string(3))
+          rm.table = table
+          c = tables.get_string(1)
+          table.catalog = c if c && c.length > 0
+          c = tables.get_string(2)
+          table.schema = c if c && c.length > 0
+          
+          columns_rs = m.get_columns table.catalog, table.schema, table.name, nil
+
+          while columns_rs.next
+            c = Column.new(columns_rs.get_string(4))
+            c.default_value = columns_rs.get_string(13)
+            c.length = columns_rs.get_int(7)
+            c.nullable = columns_rs.get_string(18) == 'YES'
+            c.precision = columns_rs.get_int(10)
+            c.scale = columns_rs.get_int(9)
+            c.sql_type = columns_rs.get_string(6)
+            c.sql_type_code = java.lang.Integer.new(columns_rs.get_int(5))
+
+            table.add_column(c)
+          end
+          columns_rs.close rescue nil
+          tables.close rescue nil
+          
+          pc = RubyRootClass.new
+          pc.ruby_class = on
+          pc.entity_name = on.name
+          pc.table = table
+          pc.add_tuplizer(org.hibernate.EntityMode::MAP, "org.jruby.ribs.RubyTuplizer")
+          
+          rm.persistent_class = pc
+          
+          table.column_iterator.each do |c|
+            unless rib.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
+              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'
+                pc.identifier_property = prop
+                pc.identifier = val
+              else
+                pc.add_property(prop)
+              end
+              
+              define_meat_accessor(on, prop.name)
+            end
+          end
+          pc.create_primary_key
+          db.mappings.add_class(pc)
+        else
+          tables.close rescue nil
+          raise "No table found for: #{name}"
+        end
+      end
+      
+      db.reset_session_factory!
+    end
+
+    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)
+      case code
+      when JTypes::VARCHAR
+        "string"
+      when JTypes::INTEGER
+        "int"
+      when JTypes::TIME
+        "java.sql.Time"
+      when JTypes::DATE
+        "java.sql.Date"
+      when JTypes::TIMESTAMP
+        "java.sql.Timestamp"
+      when JTypes::BLOB
+        "java.sql.Blob"
+      when JTypes::CLOB
+        "java.sql.Clob"
+      when JTypes::DOUBLE
+        "double"
+      when JTypes::SMALLINT
+        "boolean"
+      when JTypes::DECIMAL
+        "java.math.BigDecimal"
+      else
+        $stderr.puts [name, code].inspect
+        nil
+      end
+    end
+    
+    # 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)
+      if metadata.stores_lower_case_identifiers
+        str.downcase
+      elsif metadata.stores_upper_case_identifiers
+        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

data/lib/ribs/meat.rb

@@ -0,0 +1,33 @@
+module Ribs
+  # The Meat is what actually includes data. This is the holder object
+  # for all data that comes from a database. This allows Ribs to avoid
+  # polluting model objects with loads of instance variables. Instead
+  # everything is kept in one instance of Meat. The Meat also keeps
+  # track of whether the object is persistent or if it's been
+  # destroyed. Note that Meat is very implementation dependent, and
+  # should not be relied upon.
+  class Meat
+    # All the data for this instance
+    attr_reader :properties
+    # Is this instance persistent yet, or not?
+    attr_accessor :persistent
+    # Has this instance been destroyed?
+    attr_accessor :destroyed
+    
+    # +inside+ is the instance this Meat belongs to.
+    def initialize(inside)
+      @inside = inside
+      @properties = {}
+    end
+    
+    # Gets the current value of a property
+    def [](ix)
+      @properties[ix]
+    end
+
+    # Sets the current value of a property
+    def []=(ix, value)
+      @properties[ix] = value
+    end
+  end
+end

data/lib/ribs/session.rb

@@ -0,0 +1,237 @@
+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
+  # be released too.
+  #
+  # The methods in Session 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
+    # 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
+      # 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.
+      #
+      def get(from = :default)
+        db = case from
+             when :default
+               Ribs::DB::get
+             when Ribs::DB
+               from
+             else
+               Ribs::DB::get(from)
+             end
+        db.session
+      end
+    end
+    
+    # The current database for this session
+    attr_reader :db
+    
+    # Creates a new session that points to the provided +db+ and
+    # +hibernate_session+
+    #
+    def initialize(db, hibernate_session)
+      @db = db
+      @connected = true
+      @hibernate_session = hibernate_session
+    end
+    
+    # Releases this session 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
+      chk_conn
+      @connected = false
+      @db.release(self)
+    end
+
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def hibernate_session # :nodoc:
+      @hibernate_session
+    end
+    
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def find(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
+    end
+
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def save(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
+      tx.commit
+      obj
+    end
+
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def delete(obj) # :nodoc:
+      chk_conn
+      tx = @hibernate_session.begin_transaction
+      @hibernate_session.delete(obj)
+      tx.commit
+      obj
+    end
+    
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def meta_data # :nodoc:
+      chk_conn
+      @hibernate_session.connection.meta_data
+    end
+    
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def ddl(string) # :nodoc:
+      chk_conn
+      execute(string)
+    end
+    
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def insert(template, *data) # :nodoc:
+      chk_conn
+      conn = @hibernate_session.connection
+      stmt = conn.prepare_statement(template)
+      data.each do |d|
+        d.each_with_index do |item, index|
+          if item.kind_of?(Array)
+            set_prepared_statement(stmt, item[0], index+1, item[1])
+          else
+            set_prepared_statement(stmt, item, index+1, nil)
+          end
+        end
+        stmt.execute_update
+      end
+      conn.commit
+    ensure
+      stmt.close rescue nil
+    end
+
+    # LOW LEVEL - shouldn't be used except by Ribs
+    def select(string) # :nodoc:
+      chk_conn
+      conn = @hibernate_session.connection
+      stmt = conn.create_statement
+      rs = stmt.execute_query(string)
+      result = []
+      meta = rs.meta_data
+      cols = meta.column_count
+      while rs.next
+        row = []
+        (1..cols).each do |n|
+          row << from_database_type(rs.get_object(n))
+        end
+        result << row
+      end
+      result
+    ensure
+      rs.close rescue nil
+      stmt.close rescue nil
+    end
+    
+    private
+    # Raise a NotConnectedError if not connected
+    def chk_conn
+      raise NotConnectedError unless @connected
+    end
+    
+    # Tries to turn a Java object from the database into an equivalent
+    # Ruby object. Currently supports:
+    #
+    # * Strings
+    # * Floats
+    # * Integers
+    # * nil
+    # * booleans
+    # * Dates
+    # * Times
+    # * Timestamps
+    # * Blobs
+    # * Clobs
+    # * BigDecimals
+    def from_database_type(obj)
+      case obj
+      when String, Float, Integer, NilClass, TrueClass, FalseClass
+        obj
+      when java.sql.Date, java.sql.Time, java.sql.Timestamp
+        Time.at(obj.time/1000)
+      when java.sql.Blob
+        String.from_java_bytes(obj.get_bytes(1,obj.length))
+      when java.sql.Clob
+        obj.get_sub_string(1, obj.length)
+      when java.math.BigDecimal
+        BigDecimal.new(obj.to_s)
+      else
+        raise "Can't find correct type to convert #{obj.inspect} into"
+      end
+    end
+
+    # Tries to set an entry on a prepared statement, based on type
+    def set_prepared_statement(stmt, item, index, type)
+      case item
+      when NilClass
+        stmt.set_object index, nil
+      when String
+        case type
+        when :binary
+          stmt.set_bytes index, item.to_java_bytes
+        when :text
+          stmt.set_string index, item
+        else
+          stmt.set_string index, item
+        end
+      when Symbol
+        stmt.set_string index, item.to_s
+      when Integer
+        stmt.set_int index, item
+      when Float
+        stmt.set_float index, item
+      when Time
+        case type
+        when :date
+          stmt.set_date index, item.to_java_sql_date
+        when :time
+            stmt.set_time index, item.to_java_sql_time
+        when :timestamp
+          stmt.set_timestamp index, item.to_java_sql_time_stamp
+        end
+      when BigDecimal
+        stmt.set_big_decimal index, java.math.BigDecimal.new(item.to_s('F'))
+      when TrueClass, FalseClass
+        stmt.set_boolean index, item
+      else
+        raise "Can't find correct type to set prepared statement for #{item.inspect}"
+      end
+    end
+
+    # Executes a SQL string against the current hibernate
+    # session. This should be an updating SQL string, not a query.
+    def execute(string)
+      conn = @hibernate_session.connection
+      stmt = conn.create_statement
+      stmt.execute_update(string)
+      conn.commit
+    ensure
+      stmt.close rescue nil
+    end
+  end
+end