ActiveExcel 0.0.1

data/History.txt

@@ -0,0 +1,7 @@
+=== 0.0.1 / 2009-06-04
+
+* 1 major enhancement
+
+  * Initial creation of package
+  
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/active_excel
+lib/active_excel.rb
+test/test_active_excel.rb

data/README.txt

@@ -0,0 +1,48 @@
+= active_excel
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'active_excel'
+
+Hoe.spec 'active_excel' do |p|
+  #self.rubyforge_name = 'active_excelx' # if different than 'active_excel'
+  #p.developer('FIX', 'FIX@example.com')
+  #Hoe.new('ActiveExcel', ActiveExcel::VERSION) do |p|
+  p.name = "ActiveExcel"
+  p.author = "Rob Whitener"
+  p.description = "Excel as the container of model objects"
+  p.email = 'robwhitener@gmail.com'
+  p.summary = <<EXCEL
+Use Excel to contain model objects.  Each row in a sheet represents an object, each sheet in a workbook
+represents a class.  Make sure that you rename your sheets - this gem uses ActiveSupport to take advantage
+of the pluralization familiar to Rails developers.  Modeled liberally on ActiveRecord, not quite as cool but
+hopefully useful enough.  Cheers.
+EXCEL
+  p.url = "http://robsexocortex.blogspot.com/2009/06/activeexcel.html"
+  p.clean_globs = ['test/actual'] # Remove this directory on "rake clean"
+  p.remote_rdoc_dir = '' # Release to root
+  #p.changes = p.paragraphs_of('CHANGELOG', 0..1).join("\n\n")
+  # * extra_deps - An array of rubygem dependencies.
+#end
+end
+
+# vim: syntax=ruby

data/bin/active_excel

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/active_excel.rb

@@ -0,0 +1,432 @@
+require 'win32ole'
+require 'activesupport'
+
+class ExcelConstants
+  XLBLACK = 1
+  XLRED = 3
+  XLGREEN = 4
+  XLBLUE = 5
+  XLYELLOW = 6
+  XLMAGENTA = 7
+  XLCYAN = 8
+  XLBROWN = 9
+  XLOLIVE = 10
+  XLROYAL = 11
+  XLVOMIT = 12
+  XLPURPLE = 13
+  XLNOCOLOR = -4142
+end
+
+module ActiveExcel
+  VERSION = '0.0.1'
+  #This class conatins the main Excel functionality that will be inherited
+  #by objects which intend to wrap data in the spreadsheet
+  class Root
+    attr_accessor :workbook, :workbook_name, :id, :fields, :dirty, :is_new, :this_workbook
+    @@excel = nil
+    @@sheets = nil
+    @@workbook = nil
+    @@sheet_name = nil
+
+    def initialize()
+      #this will be called by the new method and will be called for
+      #each instance of any subclass that is created.
+      #The initialize routine will handel adding attributes to the
+      #new instance based on the fieldnames from the spreadsheet.
+      #If Find was used to get an object out of the sheet, then the
+      #attributes will be populated.  Each instance will also have
+      #an id field that corresponds to its row number in the spreadsheet
+      @fields = nil
+      @this_workbook = @@workbook
+      add_attributes
+      @id = -1 #the id can have a default value of -1, since there is no -1 row in a sheet
+      @dirty = false
+      @is_new = true
+
+    end
+
+    class << self ###Class methods
+
+      #Config is a hash that expects the following parameters
+      # :wkbook -> The name of the workbook to open
+      # :path -> pathe where the workbook can be found if the workbook isn't in the my docs folder
+      def workbook_connect(config=nil)
+          @workbook_name = config[:wkbook]
+          if config[:path]
+            #there was a path specified, prepend that to the workbook name
+            @workbook_name = config[:path] + "/" + @workbook_name
+            puts "Fully Qualified Workbook Path:>> #{@workbook_name}"
+          else
+             #otherwise, figure out where MyDocuments is
+             @workbook_name = ENV['USERPROFILE'] + "\\" + "My Documents" + "\\" + @workbook_name
+          end
+          #create the Excel application
+
+          begin
+            @@excel = WIN32OLE::connect('Excel.Application') if !@@excel
+          rescue
+            @@excel = WIN32OLE::new('Excel.Application')
+          end
+
+          #we now have a connection to a workbook.
+          #first, check to see if the desired workbook is open, if it is put that in @@workbook
+          if @@excel.Workbooks.Count > 0 then
+            #there are workbooks open, grab the one we want by name
+            @@workbook = nil
+            for wkbk in @@excel.Workbooks
+              if wkbk.Name == config[:wkbook] then
+                 @@workbook = wkbk
+              end
+            end
+
+          end
+
+          #at this point if @@workbook is nil, then go ahead and open it.
+          if @@workbook == nil then
+            @@workbook = @@excel.Workbooks.Open(@workbook_name)
+          end
+          @@excel.Visible = 1
+          #get all the sheet names
+          @@sheets ||= {}
+          i = 1
+          for worksheet in @@workbook.Worksheets
+             @@sheets[i] = worksheet.Name
+             i += 1
+          end    
+          @@workbook
+      end
+
+      def sheet_names
+        @@sheets
+      end
+
+      def load_constants
+        begin
+            ExcelConstants::XLDown #try to access a constant,
+          rescue
+            #if an error is thrown, load them.
+            WIN32OLE.const_load(@@excel, ExcelConstants) #load Excel constants into the module.
+          end
+      end
+
+      def connected?
+        return @@excel ? true : false
+      end
+
+      def workbook_disconnect
+        #this method will save any changes to the workbook and then close it down.
+        @@workbook.Save if @@workbook
+        @@workbook.Close if @@workbook
+        @@workbook = nil
+      end
+
+      def excel_disconnect
+        @@excel.Quit if @@excel
+        @@excel = nil
+      end
+
+      #Define a sheet name to use, in case the naming convention doesn't work for
+      #particular situations
+      def set_sheet_name(sht)
+        #Add the sheetname as a class variable
+        class_eval{ class_variable_set(:"@@sheet_name",sht.to_s)}
+      end
+
+      #This method will find one or more records in the spreadsheet and
+      #return them as ActiveExcel objects.
+      def find(rec_no)
+        
+        if rec_no.is_a? Integer
+          #if its just an integer, then look up by id
+          return find_by_id(rec_no)
+        elsif rec_no.is_a? Hash
+          return nil
+        elsif rec_no.is_a? Symbol
+          case rec_no
+            when :all then return find_all
+            when :first then find_first
+            when :last then find_last
+          end
+        end
+        set_sheet_name(self.class.to_s.tableize)
+
+      end
+
+      def find_by_id(i)
+        return nil if i < 2 #The rowid has to be 2 or greater
+        o = new #create a new object, this will also set the workseet
+        o.this_workbook = @@workbook.clone
+        @wksheet = get_the_worksheet
+
+        #iterate over the list of field names
+        @columns.each_pair do |k,v|
+          #Access the Cell by passing in the Letter cooresponding to the field name and the
+          #Row index (1 based)
+          value = @wksheet.Range("#{v}#{i}").Value
+          o.send(:"#{k.to_s}=",value)
+
+        end
+        o.dirty = false
+        o.is_new = false
+        o.id=i
+        o #return the new object
+      end
+
+      def find_all
+        #basically, grab all the records except the header, roll them into ActiveExcel objects
+        obj_array = Array.new #make a new array to hold the objects
+        #figure out the current region size
+        current_region = get_the_current_region
+        2.upto(current_region.Rows.Count) do |i|
+          o = new
+          o.this_workbook = @@workbook.clone
+          1.upto(current_region.Columns.Count) do |j|
+            field = get_the_field_name_for_index(j-1) #the letters array is 0 based, but excel is 1 based.
+            o.send(:"#{field}=",@wksheet.Cells(i,j).Value.to_s)
+            o.is_new = false
+            o.dirty = false
+            o.id = i
+          end
+          obj_array << o
+        end
+        obj_array
+      end
+
+      #Returns a list of column names.  If the columns hash hasn't been created, it will create the
+      #columns hash by scanning the first row of the CurrentRegion (Which is defined as a region on the
+      #active worksheet bounded by blank cells).
+      def column_names(sheet = nil)
+        if !@columns
+          if sheet
+            #if a sheet name was passed in we can just use that to get the column names
+            @wksheet = @@workbook.Worksheets(sheet)
+          else
+            #Test to see if a sheet_name class variable has been set
+            #if it has, then use that value other wise use the class name
+            classvar = self.class_eval{class_variable_get(:"@@sheet_name")}
+            classname = classvar ? classvar : self.class.to_s.tableize
+            puts "Tableized: #{classname}"
+            @wksheet = @@workbook.Worksheets(classname)
+          end
+            #now, grab the collumn names and put them into a hash name=>col_letter
+            row = @wksheet.Cells.CurrentRegion.Rows(1)
+            @columns = {}
+            @letters = []
+            col_name = "A"
+            row.Cells.each do |c|
+              #c represents a Cell in the worksheet
+              @columns[c.Value.to_sym] = col_name.clone
+              @letters << col_name.clone
+              col_name.succ! #advance the col_name one letter
+            end
+        end
+        #return a list of the keys
+        keys = []
+        @columns.each_key {|k| keys << k}
+        keys
+      end
+
+      def columns
+        return @columns
+      end
+
+      def wksheet
+        return @wksheet
+      end
+
+      #This implementation of method_missing will provide methods that will allow records
+      #to be looked up using find_by_<field_name>(value).  For simplicity sake, this first
+      #iteration will only allow the search of individual fields.
+      def method_missing(methodid,*args,&blk)
+        #make sure the columns hash has been built
+        puts("METHOD ID --> #{methodid.to_s}")
+        column_names if !@columns
+
+        #if the words 'find_ and 'by' are not part of method id, then get out.
+        return if methodid.to_s !~ /find_.*by/
+
+        field = methodid.to_s.split("by_").last
+        letter = @columns[field.to_sym]  #grab the column letter
+        col_index = @letters.index(letter) + 1 #get the column index, add 1 because Excel is one based.
+
+        if methodid.to_s.index("find_all_by")
+          return find_all_by_attribute(field,col_index,args[0])
+        else
+          return find_by_attribute(field,col_index,args[0])
+        end
+      end
+
+      #this method is caled from within method missing to return all objects
+      #that can be found which contain a particular value for a particular field
+      def find_all_by_attribute(field,col_index,args)
+          lookup_records(field,col_index,args,false)
+      end
+
+      #This method is called by method_missing to return the first object in the sheet which
+      #contains a particular value for a particular field.
+      def find_by_attribute(field,col_index,args)
+        lookup_records(field,col_index,args)    
+      end
+
+      def lookup_records(field,col_index,args,first=true)
+        i = 1 #keep track of the row number with this variable
+        @wksheet = get_the_worksheet
+        current_region = get_the_current_region
+        records = Array.new
+        current_region.each do |range|
+          if @wksheet.Cells(i,col_index).Value == args then
+            #the value of the cell in the range matches the value passed into the
+            #missing method.  Create a new object and return it
+            o = new
+            o.this_workbook = @@workbook.clone
+            1.upto(current_region.Columns.Count) do |j|
+              #get the column letter
+              l = @letters[j-1]
+              #from the hash, go backward from the column letter to the field name
+              field = @columns.index(l)
+              o.send(:"#{field.to_s}=",@wksheet.Cells(i,j).Value.to_s)
+            end
+            o.id = i
+            o.dirty = false
+            o.is_new = false
+            return o if first
+            records << o
+            break if i == current_region.Rows.Count
+          end
+          i+=1
+        end
+        records
+      end
+
+    #Get the CurrentRegion of the spreadsheet as a standard range
+    def get_the_current_region
+      @wksheet = get_the_worksheet
+      curr_reg_addr = @wksheet.Cells.CurrentRegion.address.to_s.gsub(/\$/,'') #remove $ from address
+      current_region = @wksheet.Range(curr_reg_addr)
+    end
+
+    #returns the field name for a given column letter
+    def get_the_field_name_for_index(index)
+      l = @letters[index]
+      @columns.index(l)
+    end
+
+    def get_the_worksheet
+      puts("-----------------------------")
+      puts("\tself.name.tableize: #{self.name.tableize}")
+      puts("\tsheet_name: #{@@sheet_name}")
+      @@sheet_name = self.name.tableize if !@@sheet_name
+      puts("\tThe SheetName being used is: #{@@sheet_name}\n")
+      puts("-----------------------------")
+      @@workbook.Worksheets(@@sheet_name)
+
+    end
+
+    end ###End class methods####
+
+    #allows the workbook that an individual object comes from to be stored in the object.
+    #def this_workbook=(wkbk)
+    #  @this_workbook = wkbk
+    #end
+    #
+    #def this_workbook
+    #  @this_workbook
+    #end
+
+     #Define the attributes of the instance based on what is in the
+      #spreadheet
+      def add_attributes
+        #we should be able to use the column_names here    
+        if !@@sheet_name then
+          @fields = self.class.column_names(self.class.to_s.tableize)
+        else
+          @fields = self.class.column_names()
+        end
+        #add a getter/setter pair for each column name
+        @fields.each do |c|
+          #add the setter method
+          self.class_eval do
+             define_method(:"#{c.to_s}=") do |v|
+               instance_variable_set(:"@#{c.to_s}",v)
+               instance_variable_set(:"@dirty",true)
+             end
+          end
+
+          #add the getter method
+          self.class_eval do
+            define_method(c) do
+              instance_variable_get(:"@#{c.to_s}")
+            end
+          end
+        end
+
+      end 
+
+     #This method will save the object back into the spreadsheet.  THIS DOES NOT SAVE
+     #CHANGES TO THE ACTUAL SPREADSHEET THAT IS IN MEMORY.
+     #
+     def save
+       update_or_create
+     end
+
+     #Returns whether or not this is a dirty object or not
+    def dirty?
+      dirty
+    end
+
+    def color_cell(name,const)
+      #first, get the cell name
+      letter = self.class.columns[name.to_sym]
+      #get the sheet name, if we don't already have it
+      @wksheet = @@workbook.worksheets(self.class.to_s.tableize) if !@wksheet
+      #color the cell
+      @wksheet.Range("#{letter}#{self.id}").Interior.ColorIndex = const
+    end
+
+    def get_cell_color(name)
+      #get the cell name
+      letter = self.class.columns[name.to_sym]
+      @wksheet = @@workbook.worksheets(self.class.to_s.tableize) if !@wksheet
+      #get the cell color
+      @wksheet.Range("#{letter}#{self.id}").Interior.ColorIndex
+    end
+
+    private
+    #This method will determine whether to update an existing record
+    #or create a brand new one
+    def update_or_create
+      res = (is_new == true) ? create : update
+      res != false
+    end
+
+    #This method will create a brand new row in the sheet
+    def create
+      #determine the last row in the table
+      row = self.class.wksheet.Cells.CurrentRegion.Rows.Count
+      row += 1 #add 1 to the row to point to the next empty row
+      self.class.columns.each_pair do |k,v|
+        #k: will be the field name
+        #v: will be the column letter
+        self.class.wksheet.Range("#{v}#{row}").Value =  self.send(k)
+
+      end
+      self.dirty = false
+      self.is_new = false
+      self.id = row
+    end
+
+    #this method will save the existing record
+    def update
+      self.class.columns.each_pair do |k,v|
+        #k: will be the field name
+        #v: will be the column letter
+        self.class.wksheet.Range("#{v}#{self.id}").Value = self.send(k)
+      end
+      self.dirty = false   
+    end
+
+
+
+    end #End of Root class
+
+end #End of Module

data/test/test_active_excel.rb

@@ -0,0 +1,180 @@
+require "test/unit"
+require File.dirname(__FILE__)+ "/../lib/active_excel"
+
+#this is a subclass of ActiveExcel::Root, it will be used
+#to help verify inherited behaviors and connections
+class OtherRecord < ActiveExcel::Root
+  
+end
+
+class NoSheet < ActiveExcel::Root
+  set_sheet_name :other_records
+end
+
+class X12CarbonCopyTest < ActiveExcel::Root
+
+end
+
+class TestActiveExcel < Test::Unit::TestCase
+
+  def setup
+     @wkbk = ActiveExcel::Root.workbook_connect({:wkbook=>"gxstestsubs_billing.xls"})
+     #ActiveExcel::Root.load_constants if !@const_loaded
+     #@const_loaded = true
+  end
+
+  def teardown
+    puts "Closing down excel....."
+    ActiveExcel::Root.workbook_disconnect
+    ActiveExcel::Root.excel_disconnect
+    @wkbk = nil
+    GC.start
+    sleep(2)
+  end
+
+  def test_connect_to_workbook
+    #this test verifies that a workbook can be connected to by passing in a hash
+    #config = {:wkbook=>"gxstestsubs_billing.xls"}
+    #ActiveExcel::Root.workbook_connect(config)
+    assert_not_nil @wkbk
+    assert_equal 3,@wkbk.Worksheets.Count
+
+
+  end
+
+  #def test_connect_to_two_different_workbooks
+  #  #this test verifies that ActiveExcel won't crash if two Excel workbooks are open.
+  #  #the first one will be opened by the set up method, and the second will be a connection
+  #  #to SmallCCTests_FEReq_FEPart_FERecip.xls
+  #
+  #  #first, grab an OtherRecord object, this will store the first workbook in the object:
+  #  orec = OtherRecord.find(3)
+  #  #now, open up the second one.
+  #  ActiveExcel::Root.workbook_connect({:wkbook=>"SmallCCTests_FEReq_FEPart_FERecip.xls"})
+  #  ActiveExcel::Root.set_sheet_name :x12_carbon_copy_tests
+  #  x12 = X12CarbonCopyTest.find(2)
+  #  assert_not_equal(orec.this_workbook, x12.this_workbook )
+  #  ActiveExcel::Root.set_sheet_name = nil
+  #end
+
+  def test_column_names
+    #ae = ActiveExcel::Root.new
+    h = ActiveExcel::Root.column_names("other_records")
+    0.upto(3) do |i|
+      assert_equal true,h.include?(:"Field#{i+1}") 
+    end
+    assert_equal "A",ActiveExcel::Root.columns[:Field1]
+    assert_equal "B",ActiveExcel::Root.columns[:Field2]
+    assert_equal "C",ActiveExcel::Root.columns[:Field3]
+    assert_equal "D",ActiveExcel::Root.columns[:Field4]
+  end
+
+  def test_using_a_subclass
+    oe = OtherRecord.new
+    h = oe.class.column_names
+    0.upto(3) do |i|
+      assert_equal true,h.include?(:"Field#{i+1}")
+    end
+  end
+
+  def test_specifying_a_sheet_name
+    
+    ns = NoSheet.new
+    #assert_equal "other_records",NoSheet.sheet_name 
+    h = ns.class.column_names
+    0.upto(3) do |i|
+      assert_equal true,h.include?(:"Field#{i+1}")
+    end
+  end
+
+  def test_verify_that_attr_added_dynamically
+    orec = OtherRecord.new
+    orec.Field1 = "A new value"
+    orec.Field4 = "BLAH BLAH"
+    assert_equal "A new value",orec.Field1  
+    assert_equal -1,orec.id
+    assert_equal nil,orec.Field2
+    assert_equal nil,orec.Field3
+    assert_equal "BLAH BLAH",orec.Field4
+  end
+
+  def test_find_a_record_with_a_specific_id
+
+    #simply passing in an integer will cause it to find by id
+    orec = OtherRecord.find(3)
+    assert_equal "Value2",orec.Field1
+    assert_equal "Value10",orec.Field2
+    assert_equal "Value18",orec.Field3
+    assert_equal "Value26",orec.Field4 
+  end
+
+  def test_find_by_attr_name
+    orec = OtherRecord.find_by_Field2("Value11")
+    assert_equal 4,orec.id
+    assert_equal "Value3",orec.Field1
+    assert_equal "Value11",orec.Field2
+    assert_equal "Value19",orec.Field3
+    assert_equal "Value27",orec.Field4
+  end
+
+  def test_find_all_by_attr_name
+    orecs = OtherRecord.find_all_by_Field1("Value8")
+    assert_equal 2,orecs.size
+    orec1 = orecs[0]
+    orec2 = orecs[1]
+    assert_equal "Value8",orec1.Field1
+    assert_equal "Value16",orec1.Field2
+    assert_equal "Value8", orec2.Field1
+    assert_equal "Value160",orec2.Field2 
+  end
+
+  def test_find_by_attr_name_with_underscore
+    orec = OtherRecord.find_by_Field_Five("Value35")
+    assert_equal "Value3",orec.Field1
+    assert_equal "Value11",orec.Field2
+    assert_equal "Value19",orec.Field3
+    assert_equal "Value27",orec.Field4
+    assert_equal "Value35",orec.Field_Five 
+  end
+
+  def test_save_an_edited_record
+    orec = OtherRecord.find_by_Field3("Value23")
+    orec.Field1="UPDATED"
+    orec.Field2="RECORD"
+    orec.save
+
+    teardown()
+    #sleep(5) #go to sleep for 5 seconds so I can watch the taskmanager
+
+    #open it back up now
+    ActiveExcel::Root.workbook_connect({:wkbook=>"gxstestsubs_billing.xls"})
+
+    uprec = OtherRecord.find_by_Field3("Value23")
+    assert_equal "UPDATED",uprec.Field1
+    assert_equal "RECORD",uprec.Field2
+
+    #change them again and ensure that the object has been marked dirty.
+    uprec.Field1 = "Value7"
+    uprec.Field2 = "Value15"
+
+    assert_equal true,uprec.dirty?
+    uprec.save
+  end
+
+  def test_find_all_records_in_sheet
+    recs = OtherRecord.find(:all)
+    assert_equal 9,recs.size
+    0.upto(7) do |i|
+      assert_equal "OtherRecord",recs[i].class.to_s
+      assert_equal "Value#{i+1}",recs[i].send(:"Field1") 
+    end
+  end
+
+  def test_colorize_cell
+    #this verifies that we can color a cell using an excel constant
+    oe = OtherRecord.find(4)
+    oe.color_cell("Field1",ExcelConstants::XLGREEN)
+    oe.color_cell("Field3",ExcelConstants::XLRED)
+    oe.save
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: ActiveExcel
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Rob Whitener
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-02 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: Excel as the container of model objects
+email: robwhitener@gmail.com
+executables: 
+- active_excel
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/active_excel
+- lib/active_excel.rb
+- test/test_active_excel.rb
+has_rdoc: true
+homepage: http://robsexocortex.blogspot.com/2009/06/activeexcel.html
+licenses: []
+
+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: active_excel
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Use Excel to contain model objects.  Each row in a sheet represents an object, each sheet in a workbook represents a class.  Make sure that you rename your sheets - this gem uses ActiveSupport to take advantage of the pluralization familiar to Rails developers.  Modeled liberally on ActiveRecord, not quite as cool but hopefully useful enough.  Cheers.
+test_files: 
+- test/test_active_excel.rb