mudnaes-dbstruct 0.1.1

data/README

@@ -0,0 +1,56 @@
+This is a very simple framework to be able to access database rows as 
+objects without forcing you to inherit from a Model class. Instead
+you create the class-hierarchy you want and use mixin to add
+persistance functionality to the object.
+
+It a lot simpler than an real Object-Relation-Mapper since it's ignores relations.
+
+The benefit of this framework is that you can write code like this:
+
+class AnObject 
+  include DBStruct
+  @non_persisted_field
+  attr_accessor :non_persisted_field
+  
+  def initialize(*args)
+    @non_persisted_field = args[0]
+  end
+  
+  def return_value_from_field
+    return @non_persisted_field
+  end
+end
+
+Create a simple migration:
+
+class CreateDb < Sequel::Migration
+  def up
+    create_table :person do
+      primary_key :id
+      text :name
+      float :amount
+      integer :age
+    end
+  end
+end
+
+An then start coding. To create new field you only have to add it to the migration. 
+
+  DB = Sequel.sqlite '', :logger => [Logger.new($stdout)]
+  CreateDb.apply(DB,:up)
+  AnObject.bind_table(DB,:person)
+
+  r = AnObject.template
+  r.name = 'Donald'
+  r.amount = 10.1
+  r.age = 77
+
+  r.insert(DB)
+
+  r.age = 98
+  r.update(DB)
+  r.delete(DB)
+
+This framework relies heavely on the work of others (Sequel and OpenStruct)
+
+Morten Udnæs. 

data/dbstruct.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name     = "dbstruct"
+  s.version  = "0.1.1"
+  s.date     = "2008-12-03"
+  s.summary  = "Easy to use library for mapping rows between objects and database"
+  s.email    = "mudnaes@gmail.com"
+  s.homepage = "http://github.com/mudnaes/dbstruct/tree/master"
+  s.description = "This is a very simple framework to be able to access database rows as objects without forcing you to inherit from a Model class. Instead you create the class-hierarchy you want and use mixin to add persistance functionality to the object."
+  s.has_rdoc = true
+  s.authors  = ["Morten Udnæs"]
+  s.files    = ["README", 
+		"dbstruct.gemspec", 
+		"lib/dbstruct.rb"]
+  s.test_files = ["spec/dbstruct_spec.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["README"]
+  s.add_dependency("diff-lcs", ["> 0.0.0"])
+  s.add_dependency("mime-types", ["> 0.0.0"])
+  s.add_dependency("open4", ["> 0.0.0"])
+end
+

data/lib/dbstruct.rb

@@ -0,0 +1,204 @@
+require 'rubygems'
+require 'ostruct'
+
+module DBStruct
+  # The purpose of this module is to have a struct inside an ordinary object
+  # to contain feilds for persistence. The fields are accessed the same way
+  # as the other fields inside the object.. 
+  # 
+  
+  
+  # Define dynamic accessors to struct fields
+  def method_missing(mid, *args) 
+    fieldname = mid.id2name
+    
+    if mid.id2name.match("=")
+      fieldname.chop!
+      if args.length != 1
+        raise ArgumentError, "Setter must have only one argument. Number of arguments found was (#{len} for 1)", caller(1)
+      end
+      
+      # Make sure fields aren't added in error (typos)
+      if !@_dbdata.marshal_dump.key?(fieldname.to_sym) & @_frozen 
+        raise ArgumentError, "Struct fields are frozen, reopen before using <field>= . Field was (#{fieldname} for 1)", caller(1)
+      end
+    end
+    
+    if @_dbdata == nil
+      super(mid, *args)
+      
+    elsif  @_dbdata.marshal_dump.key?(fieldname.to_sym)
+      @_dbdata.send(mid.id2name,args[0])
+      
+      # Route method missing to struct object  
+    elsif !@_frozen & mid.id2name.match("=")
+      @_dbdata.method_missing(mid, *args)
+      
+      # Forward methods missing not related to struct
+    else
+      super(mid, *args)
+    end
+  end
+  
+  # Used for creating an object based on an hash (primarily for loading records directly from DB
+  def load(response)
+    if response != nil
+      @_dbdata = OpenStruct.new(response)
+      @_frozen = true
+    end
+  end
+  
+  # Export hash from struct
+  def save(*args)
+    @_dbdata.marshal_dump(*args)
+  end
+  
+  def get(db, pkid)
+    @_dbdata.pkid = db[self.class.get_table].filter(:pkid =>pkid)
+  end
+  
+  
+  def insert(db)
+    @_dbdata.pkid = db[self.class.get_table].insert(save)
+  end
+  
+  def delete(db,search_criteria)
+    db[self.class.get_table].filter({:pkid =>pkid}).delete
+  end
+   
+  
+  def update(db)
+    db[self.class.get_table].filter({:pkid => pkid}).update(save)
+  end
+ 
+  
+  # Define which fields are needed. Sent in as an array of symbols or strings
+  def setup_fields(fields)
+    h = {}
+    fields.each do |field|
+      if field.kind_of? Symbol     
+        h[field.to_s] = nil
+      else
+        h[field] = nil
+      end
+    end
+    @_dbdata = OpenStruct.new(fields)
+    @_frozen = true
+  end
+  
+  # Avoid anyone referencing @_dbdata directly
+  def empty?
+    @_dbdata == nil
+  end
+  
+  # When overiding method_missing this one should also be...
+  def respond_to(*args)
+    super(*args)
+  end
+  
+  # Freeze struct so new fields aren't added by mistake
+  def freeze_fields
+    @_frozen = true
+  end
+  
+  # Unfreeze struct so new fields can be added manually. Remember to freeze afterwards
+  def unfreeze_fields
+    @_frozen = false
+  end
+  
+  #Class methods for included dbstructs
+  def self.included receiver
+    receiver.extend DBStructClassMethods
+  end
+  
+  module DBStructClassMethods
+    # Used to create objects based on database rows
+   
+    
+    
+    def create(rows)
+      list = []
+      if rows == nil
+        return list
+      end
+      rows.each do |row|
+        the_instance = self.new
+        the_instance.load(row)
+        list << the_instance
+      end
+      list
+    end 
+   
+    #Hack enable referencing modularized class-variable from instance
+    def get_table
+      return @@_table
+    end
+    
+    #Binds class to given table in the database, Sequel specific
+    def bind_table(db,table)
+      tablefields = []
+      @@_table = table
+      
+      if db.schema(table).empty?
+        raise ArgumentError, "Table [#{table}] was not found. Unable to bind object", caller(1)
+      end
+      
+      db.schema(table).each do |fields|
+        tablefields << fields[0] 
+      end
+      bind(tablefields)
+    end
+    
+    # Use this to bind a class to a table, so new objects created with template will match fields in database
+    def bind(fields)
+      
+      if fields.empty?
+        raise ArgumentError, "Trying to bind object to empty list of fields..."
+      end
+      
+      if (@@_template rescue nil) != nil
+        raise ArgumentError, "Class already bound to table: #{@@_template.to_s}. Use method rebind if new binding is needed", caller(1)
+      end
+      @@_template = {}
+      fields.each { |field| @@_template[field] = nil} 
+      return 
+    end
+    
+    # Method can rebind fields if database changes dynamicly.... I'm not sure you should need this one....
+    def rebind!(fields)
+      @@_template = {}
+      fields.each { |field| @@_template[field] = nil}
+      return 
+    end
+
+        
+  def find(db,search_criteria)
+    db[@@_table].filter(search_criteria)
+  end
+
+    
+  def delete!(db,search_criteria)
+    db[@@_table].filter(search_criteria).delete
+  end
+  
+   
+  def update!(db,search_criteria, update_criteria)
+    db[@@_table ].filter(search_criteria).update(update_criteria)
+  end
+  
+ 
+    
+    def template(*args)
+      the_instance = self.new(*args)
+      the_instance.load(@@_template)
+      the_instance
+    end  
+    
+  def find(db,search_criteria)
+    create(db[@@_table].where(search_criteria))
+    
+  end
+  
+  end
+  
+end

data/spec/dbstruct_spec.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'sequel'
+require '../lib/dbstruct'
+require 'logger'
+
+class AnObject 
+  include DBStruct
+  @non_persisted_field
+  attr_accessor :non_persisted_field
+  
+  def initialize(*args)
+    @non_persisted_field = args[0]
+    
+  end
+  
+  def return_value_from_field
+    return @non_persisted_field
+  end
+end
+
+class CreateDb < Sequel::Migration
+  def up
+    create_table :person do
+      primary_key :pkid
+      text :name
+      float :amount
+      integer :age
+    end
+  end
+end
+
+
+class DBStruct_spec
+  DB = Sequel.sqlite '', :logger => [Logger.new($stdout)]
+  CreateDb.apply(DB,:up)
+  AnObject.bind_table(DB,:person)
+
+  def self.create_test_object
+  r = AnObject.template
+  r.name = 'Donald'
+  r.amount = 10.1
+  r.age = 77
+  return r
+end
+
+  
+  context "Create empty object and access fields" do
+    setup do
+      
+    end
+    
+    specify "All fields should have accesors based on table names" do
+      r = DBStruct_spec.create_test_object
+      
+      r.name.should == 'Donald'
+      r.amount.should == 10.1
+      r.age.should == 77
+    end
+    
+    specify "should raise error when accessing field that doesn't exist in database or object" do
+      r = AnObject.template
+      lambda {r.field_does_nt_exist}.should raise_error
+    end
+    
+    specify "should be able to accesses transient (non persisted) values" do
+      r = AnObject.template
+      r.non_persisted_field = 'BOO'
+      r.non_persisted_field.should == 'BOO'
+    end
+    
+    specify "should be able to pass variables to object constructor (initialize)" do
+      r = AnObject.template('BOO')
+      r.non_persisted_field.should == 'BOO'
+    end
+    
+    specify "should be able to call ordinary method on persisted object" do
+      r = AnObject.template("BOO")
+      r.return_value_from_field.should == "BOO"
+    end
+  end
+  
+  
+  context "Use instance to perform insert, read, update and delete" do
+    setup do
+    end
+    
+    specify "should be able to insert and read object" do
+      i = DBStruct_spec.create_test_object
+      
+      lambda {i.insert(DB)}.should_not raise_error
+      from_db = AnObject.find(DB,{:age => 77}).first
+      from_db.name == i.name.should 
+      from_db.amount == i.amount.should 
+      from_db.age == i.age.should
+      
+      i.amount = 12.1
+      i.update(DB)
+      from_db = AnObject.find(DB,{:age => 77}).first
+      from_db.name == i.name.should 
+      from_db.amount == i.amount.should 
+      from_db.age == i.age.should
+      
+      lambda {AnObject.delete!(DB,{:age => 77})}.should_not raise_error
+      #i.delete(DB)
+      deleted = AnObject.find(DB,{:age => 77})
+      deleted.should == []
+    end
+  end
+  
+  context "Using class to perform statements that changes multiple rows" do
+    specify "should update multiple rows" do
+      i1 = DBStruct_spec.create_test_object
+      i1.insert(DB)
+      i2 = DBStruct_spec.create_test_object
+      i2.insert(DB)
+      lambda {AnObject.update!(DB, {:name => 'Donald'}, :name => 'Dolly')}.should_not raise_error
+   
+      from_db = AnObject.find(DB,{:name => 'Dolly'}).first
+      from_db.name.should == 'Dolly'      
+    end
+    
+    specify "should delete multiple rows" do
+      
+    end
+  end
+  
+  context "Use indirect approach to save and store objects" do
+    setup do
+    end
+    
+    specify "should be able to insert and read object indirectly" do
+      r = DBStruct_spec.create_test_object
+      r.age = 88
+      DB[:person].insert(r.save)
+      
+      row = DB[:person].filter({:age => 88})
+      from_db = AnObject.create(row).first
+      from_db.name.should == r.name 
+      from_db.age.should == r.age
+      from_db.amount == r.amount
+    end
+  end 
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: mudnaes-dbstruct
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- "Morten Udn\xC3\xA6s"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-03 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: This is a very simple framework to be able to access database rows as objects without forcing you to inherit from a Model class. Instead you create the class-hierarchy you want and use mixin to add persistance functionality to the object.
+email: mudnaes@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- dbstruct.gemspec
+- lib/dbstruct.rb
+has_rdoc: true
+homepage: http://github.com/mudnaes/dbstruct/tree/master
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Easy to use library for mapping rows between objects and database
+test_files: 
+- spec/dbstruct_spec.rb