ar_loader 0.0.4

data/lib/engine/jruby/jexcel_file.rb

@@ -0,0 +1,182 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2010
+# License::   MIT
+#
+# An Excel file helper. Create and populate XSL files
+#
+# The maximum number of columns and rows in an Excel file is fixed at 256 Columns and 65536 Rows
+# 
+# POI jar location needs to be added to class path.
+#
+#  TODO -  Check out http://poi.apache.org/poi-ruby.html
+#
+class Object
+  def add_to_classpath(path)
+    $CLASSPATH << File.join( ArLoader.root_path, 'lib', path.gsub("\\", "/") )
+  end
+end
+
+require 'java'
+require 'rubygems'
+
+add_to_classpath 'java/poi-3.6.jar'
+
+class JExcelFile
+  include_class 'org.apache.poi.poifs.filesystem.POIFSFileSystem'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFCell'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFWorkbook'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFCellStyle'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFDataFormat'
+
+  include_class 'java.io.ByteArrayOutputStream'
+  include_class 'java.util.Date'
+  include_class 'java.io.FileInputStream'
+
+  attr_accessor :book, :row, :current_sheet
+  
+  attr_reader   :sheet
+
+  MAX_COLUMNS = 256.freeze
+  MAX_ROWS = 65536.freeze
+
+  # The HSSFWorkbook uses 0 based indexes
+  
+  def initialize()
+    @book = nil
+  end
+
+  def open(filename)
+    inp = FileInputStream.new(filename)
+
+    @book = HSSFWorkbook.new(inp)
+
+    sheet(0)  # also sets @current_sheet
+  end
+  
+  def create(sheet_name)
+    @book = HSSFWorkbook.new()
+    @sheet = @book.createSheet(sheet_name.gsub(" ", ''))
+    date_style = @book.createCellStyle()
+    date_style.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"))
+  end
+
+  # Return the current or specified HSSFSheet
+  def sheet(i = nil)
+    @current_sheet = i if i
+    @sheet = @book.getSheetAt(@current_sheet)
+    @sheet
+  end
+
+  def num_rows
+    @sheet.getPhysicalNumberOfRows
+  end
+
+  # Process each row. (type is org.apache.poi.hssf.usermodel.HSSFRow)
+
+  def each_row
+    @sheet.rowIterator.each { |row| yield row }
+  end
+
+
+  # Create new row, bring index in line with POI usage (our 1 is their 0)
+  def create_row(index)
+    @row = @sheet.createRow(index)
+    @row
+  end
+  
+  def set_cell(row, column, data)
+    @row = @sheet.getRow(row) || create_row(row)
+    @row.createCell(column).setCellValue(data)
+  end
+
+  def value(row, column)
+    raise TypeError, "Expect row argument of type HSSFRow" unless row.is_a?(Java::OrgApachePoiHssfUsermodel::HSSFRow)
+    #puts "DEBUG - CELL VALUE : #{column} => #{ cell_value( row.getCell(column) ).inspect}"
+    cell_value( row.getCell(column) )
+  end
+  
+  def cell_value(cell)
+    return nil unless cell
+    #puts "DEBUG CELL TYPE : #{cell} => #{cell.getCellType().inspect}"
+    case (cell.getCellType())
+      when HSSFCell::CELL_TYPE_FORMULA  then return cell.getCellFormula()
+      when HSSFCell::CELL_TYPE_NUMERIC  then return cell.getNumericCellValue()
+      when HSSFCell::CELL_TYPE_STRING   then return cell.getStringCellValue()
+      when HSSFCell::CELL_TYPE_BOOLEAN  then return cell.getBooleanCellValue()
+      when HSSFCell::CELL_TYPE_BLANK    then return ""
+    end
+  end
+  
+  def save( filename )
+    File.open( filename, 'w') {|f| f.write(to_s) }
+  end
+
+
+  # The internal representation of a Excel File
+  
+  def to_s
+    outs = ByteArrayOutputStream.new
+    @book.write(outs);
+    outs.close();
+    String.from_java_bytes(outs.toByteArray)
+  end
+ 
+end
+  
+module ExcelHelper
+  require 'java'
+
+  include_class 'org.apache.poi.poifs.filesystem.POIFSFileSystem'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFCell'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFWorkbook'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFCellStyle'
+  include_class 'org.apache.poi.hssf.usermodel.HSSFDataFormat'
+  include_class 'java.io.ByteArrayOutputStream'
+  include_class 'java.util.Date'
+
+  # ActiveRecord Helper - Export model data to XLS file format
+  #
+  def to_xls(items=[])
+
+    @excel = ExcelFile.new(items[0].class.name)
+    
+    @excel.create_row(0)
+  
+    sheet = @excel.sheet
+
+    # header row
+    if !items.empty?
+      row = sheet.createRow(0)
+      cell_index = 0
+      items[0].class.columns.each do |column|
+        row.createCell(cell_index).setCellValue(column.name)
+        cell_index += 1
+      end
+    end
+
+    # value rows
+    row_index = 1
+    items.each do |item|
+      row = sheet.createRow(row_index);
+
+      cell_index = 0
+      item.class.columns.each do |column|
+        cell = row.createCell(cell_index)
+        if column.sql_type =~ /date/ then
+          millis = item.send(column.name).to_f * 1000
+          cell.setCellValue(Date.new(millis))
+          cell.setCellStyle(dateStyle);
+        elsif column.sql_type =~ /int/ then
+          cell.setCellValue(item.send(column.name).to_i)
+        else
+          value = item.send(column.name)
+          cell.setCellValue(item.send(column.name)) unless value.nil?
+        end
+        cell_index += 1
+      end
+      row_index += 1
+    end
+    @excel.to_s
+  end
+end

data/lib/engine/jruby/method_mapper_excel.rb

@@ -0,0 +1,44 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Jan 2011
+# License::   MIT
+#
+# JAVA SPECIFIC LOAD
+require 'java'
+require 'rubygems'
+require 'jexcel_file'
+require 'method_mapper'
+
+class MethodMapperExcel < MethodMapper
+    
+  attr_accessor :excel, :sheet
+
+  # Read the headers from a spreadsheet and map to ActiveRecord members/associations
+
+  def initialize( file_name, klass, sheet_number = 0 )
+    super()
+    
+    @excel = JExcelFile.new
+
+    @excel.open(file_name)
+
+    @sheet = @excel.sheet( sheet_number )
+
+    @header_row = @sheet.getRow(0)
+
+    raise "ERROR: No headers found - Check Sheet #{@sheet} is completed sheet and Row 1 contains headers" unless @header_row
+
+    @headers = []
+    (0..JExcelFile::MAX_COLUMNS).each do |i|
+      cell = @header_row.getCell(i)
+      break unless cell
+      @headers << "#{@excel.cell_value(cell).to_s}".strip
+    end
+
+    # Gather list of all possible 'setter' methods on AR class (instance variables and associations)
+    MethodMapperExcel.find_operators( klass )
+
+    # Convert the list of headers into suitable calls on the Active Record class
+    find_method_details( klass, @headers )
+  end
+end

data/lib/engine/mapping_file_definitions.rb

@@ -0,0 +1,88 @@
+# This class provides a value map (hash) from a text mapping file
+#
+# The map file is  a text file of delimeted key -> values pairs
+#
+#  SUPPORTED FILE FORMATS:
+#
+#  2 column e.g. a,b
+#   creates a simple hash {a => b)
+#
+#  3 column e.g. a,b,c
+#   a,b becomes the key, c is the vaule
+#   creates a hash { [a,b] => c }
+#
+#  4 column e.g. a,b,c,d
+#   a,b  becomes the key, c,d the value
+#   creates a hash { [a,b] => [c,d] }
+#
+#  TODO allow mapping file to be an xml file
+#
+class ValueMapFromFile < Hash
+
+  def intialize(file_path, delim = ',')
+    @delegate_to = {}
+    @delim = delim
+    load_map(file_path)
+  end
+
+  def load_map(file_path = nil, delim = ',')
+    @file = file_path unless file_path.nil?
+    @delim = delim
+
+    raise BadConfigError.new("Can not read map file: #{@file}") unless File.readable?(@file)
+
+    File.open(@file).each_line do |line|
+      next unless(line && line.chomp!)
+
+      values = line.split(@delim)
+
+      case values.nitems
+        when 2: self.store(values[0], values[1])
+        when 3: self.store([values[0], values[1]], values[2])
+        when 4: self.store([values[0], values[1]],[values[2], values[3]])
+      else
+        raise BadConfigError.new("Bad key,value row in #{@file}: #{values.nitems} number of columns not supported")
+      end
+    end
+
+    return self
+  end
+end
+
+
+# Expects file of format [TradeType,LDN_TradeId,HUB_TradeId,LDN_AssetId,HUB_AssetId,LDN_StrutureId,HUB_StructureId,LDN_ProductType,HUB_ProductType]
+# Convets in to and araya containing rows [LDN_TradeId, LDN_AssetId, HUB_TradeId, HUB_AssetId]
+class AssetMapFromFile < Array
+
+  def intialize(file_path, delim = ',')
+    @delegate_to = {}
+    @delim = delim
+    load_map(file_path)
+  end
+
+  def load_map(file_path = nil, delim = ',')
+    @file = file_path unless file_path.nil?
+    @delim = delim
+
+    raise BadConfigError.new("Can not read asset map file: #{@file}") unless File.readable?(@file)
+
+    File.open(@file).each_line do |line|
+      next unless(line && line.chomp!)
+      # skip the header row
+      next if line.include?('TradeType')
+
+      values = line.split(@delim)
+
+      self.push(Array[values[1], values[3], values[2], values[4]])
+    end
+
+    return self
+  end
+
+  def write_map(file_path = nil, delim = ',')
+    mapfile = File.open( file_path, 'w')
+
+    self.each{|row| mapfile.write(row.join(delim)+"\n")}
+  end
+
+end

data/lib/engine/method_detail.rb

@@ -0,0 +1,139 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2010
+# License::   MIT
+#
+# Details::   This class provides information and access to the individual methods
+#             on an AR model. Populated by, and coupled with MethodMapper,
+#             which does the model interrogation work.
+#             Enables 'loaders' to iterate over the MethodMapper results set,
+#             and assign values to AR object, without knowing anything about that receiving object.
+#
+# =>
+require 'to_b'
+
+class MethodDetail
+  
+  # When looking up an association, try each of these in turn till a match
+  #  i.e find_by_name .. find_by_title and so on
+  @@insistent_find_by_list ||= [:id, :name, :title]
+
+  attr_accessor :klass, :name, :assignment, :col_type
+  attr_accessor :has_many, :has_many_class_name, :has_many_class
+  attr_accessor :belongs_to, :belongs_to_class_name, :belongs_to_class
+
+  @@default_values = {}
+  @@prefixes = {}
+  
+ 
+  def initialize(klass, name, assignment, belongs_to, has_many, col_type = nil)
+    @klass, @name, @assignment, @has_many, @belongs_to, @col_type = klass, name, assignment, has_many, belongs_to, col_type
+
+    if(@has_many)
+      begin
+        @has_many_class = Kernel.const_get(@has_many.classify)
+        @has_many_class_name = @has_many.classify
+      rescue
+      end
+    end
+
+    if(@belongs_to)
+      begin
+        @belongs_to_class = Kernel.const_get(@belongs_to.classify)
+        @belongs_to_class_name = @belongs_to.classify
+      rescue
+        # TODO - try other forms of the name, set to nil, or bomb out ?
+      end
+    end
+  end
+
+  def assign( record, value )
+    #puts "DEBUG: assign: [#{@name}]"
+
+    data = value
+
+    if(@@default_values[@name])
+      puts "WARNING nil value supplied for [#{@name}] - Using default : [#{@@default_values[@name]}]"
+      data = @@default_values[@name]
+    else
+      puts "WARNING nil value supplied for [#{@name}] - No default"
+    end if(data.nil?)
+    
+    data = "#{@@prefixes[@name]}#{data}" if(@@prefixes[@name])
+
+    if( @belongs_to )
+      
+      #puts "DEBUG : BELONGS_TO #{@belongs_to} - Lookup #{data} in DB"
+      insistent_belongs_to(record, data)
+
+    elsif( @assignment && @col_type )
+      #puts "DEBUG : COl TYPE defined for #{@name} : #{@assignment} => #{data} #{@col_type.inspect}"
+      record.send( @assignment, @col_type.type_cast( data ) )
+
+    elsif( @assignment )
+      #puts "DEBUG : No COL TYPE found for #{@name} : #{@assignment} => #{data}"
+      insistent_assignment(record, data)
+    end
+  end
+
+  # Attempt to find the associated object via id, name, title ....
+  def insistent_belongs_to( record, value )
+
+    @@insistent_find_by_list.each do |x|
+      begin
+        item = @belongs_to_class.send( "find_by_#{x}", value)
+        if(item)
+          record.send("#{@belongs_to}=", item)
+          break
+        end
+      rescue => e
+        puts e.inspect
+        if(x == @@insistent_method_list.last)
+          puts  "I'm sorry I have failed to assign [#{value}] to #{@assignment}"
+          raise "I'm sorry I have failed to assign [#{value}] to #{@assignment}" unless value.nil?
+        end
+      end
+    end
+  end
+
+  def insistent_assignment( record, value )
+    @@insistent_method_list ||= [:to_i, :to_f, :to_b]
+    begin
+      record.send(@assignment, value)
+    rescue => e
+      puts e.inspect
+      @@insistent_method_list.each do |f|
+        begin
+          record.send(@assignment, value.send( f) )
+          break
+        rescue => e
+          #puts "DEBUG: insistent_assignment: #{e.inspect}"
+          if f == @@insistent_method_list.last
+            puts  "I'm sorry I have failed to assign [#{value}] to #{@assignment}"
+            raise "I'm sorry I have failed to assign [#{value}] to #{@assignment}" unless value.nil?
+          end
+        end
+      end
+    end
+  end
+
+  def self.set_default_value( name, value )
+    @@default_values[name] = value
+  end
+
+  def self.default_value(name)
+    @@default_values[name]
+  end
+
+  def self.set_prefix( name, value )
+    @@prefixes[name] = value
+  end
+
+  def self.default_value(name)
+    @@prefixes[name]
+  end
+  
+  def pp
+    "#{@name} => #{@assignment} : #{@has_many}"
+  end
+end

data/lib/engine/method_mapper.rb

@@ -0,0 +1,157 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2010
+# License::   MIT
+#
+# Details::   A base class that stores details of all possible associations on AR classes and,
+#             given user supplied class and name, attempts to find correct attribute/association.
+#
+#             Derived classes define where the user supplied list of names originates from.
+#
+#             Example usage, load from a spreadsheet where the column names are only
+#             an approximation of the actual associations. Given a column heading of
+#             'Product Properties' on class Product,  find_method_detail() would search AR model,
+#             and return details of real has_many association 'product_properties'.
+#
+#             This real association can then be used to send spreadsheet row data to the AR object.
+#             
+require 'method_detail'
+
+class MethodMapper
+
+  attr_accessor :header_row, :headers
+  attr_accessor :methods
+  
+  @@has_many     = Hash.new
+  @@belongs_to   = Hash.new
+  @@assignments  = Hash.new
+  @@column_types = Hash.new
+
+  def initialize
+    @methods = []
+    @headers = []
+  end
+
+  # Build complete picture of the methods whose names listed in method_list
+  # Handles method names as defined by a user or in file headers where names may
+  # not be exactly as required e.g handles capitalisation, white space, _ etc
+  
+  def find_method_details( klass, method_list )
+    @methods = method_list.collect { |x| MethodMapper::find_method_detail( klass, x ) }
+  end
+
+  def method_names()
+    @methods.collect( &:name )
+  end
+
+  def check_mandatory( mandatory_list )
+    method_list = method_names()
+
+    mandatory_list.each { |x| raise "Mandatory column missing - need a '#{x}' column" unless(method_list.index(x)) }
+  end
+
+  # Create picture of the operators for assignment available on an AR model,
+  # including via associations (which provide both << and = )
+  #
+  def self.find_operators(klass, options = {} )
+
+    if( options[:reload] || @@has_many[klass].nil? )
+      @@has_many[klass] = klass.reflect_on_all_associations(:has_many).map { |i| i.name.to_s }
+      klass.reflect_on_all_associations(:has_and_belongs_to_many).inject(@@has_many[klass]) { |x,i| x << i.name.to_s }
+    end
+
+    # puts "DEBUG: Has Many Associations:", @@has_many[klass].inspect
+
+    if( options[:reload] || @@belongs_to[klass].nil? )
+      @@belongs_to[klass] = klass.reflect_on_all_associations(:belongs_to).map { |i| i.name.to_s }
+    end
+
+    # puts "DEBUG: Belongs To Associations:", @@belongs_to[klass].inspect
+
+    if( options[:reload] || @@assignments[klass].nil? )
+      @@assignments[klass] = (klass.column_names + klass.instance_methods.grep(/=/).map{|i| i.gsub(/=/, '')})
+      @@assignments[klass] = @@assignments[klass] - @@has_many[klass] if(@@has_many[klass])
+      @@assignments[klass] = @@assignments[klass] - @@belongs_to[klass] if(@@belongs_to[klass])
+      
+      @@assignments[klass].uniq!
+
+      @@assignments[klass].each do |assign|
+        found = klass.columns.find{ |col| col.name == assign }
+        @@column_types[column_key(klass, assign)] = found if found
+      end
+    end
+  end
+
+  # Find the proper format of name, appropriate call + column type for a given name.
+  # e.g Given users entry in spread sheet check for pluralization, missing underscores etc
+  #
+  # If not nil returned method can be used directly in for example klass.new.send( call, .... )
+  #
+  def self.find_method_detail( klass, name )
+    true_name, assign, belongs_to, has_many = nil, nil, nil, nil
+    
+    # TODO - check out regexp to do this work better plus Inflections ??
+    [
+      name,
+      name.gsub(' ', '_'),
+      name.gsub(' ', ''),
+      name.gsub(' ', '_').downcase,
+      name.gsub(' ', '').downcase,
+      name.gsub(' ', '_').underscore
+
+    ].each do |n|
+      has_many   = (@@has_many[klass]    && @@has_many[klass].include?(n))   ?  n : nil
+      belongs_to = (@@belongs_to[klass]  && @@belongs_to[klass].include?(n)) ?  n : nil
+      assign     = (@@assignments[klass] && @@assignments[klass].include?(n))?  n + '=' : nil
+
+      if(assign || has_many || belongs_to)
+        true_name = n
+        break
+      end
+    end
+
+    return MethodDetail.new(klass, true_name, assign, belongs_to, has_many, @@column_types[column_key(klass, true_name)])
+  end
+
+  def self.clear
+    @@has_many.clear
+    @@assignments.clear
+    @@column_types.clear
+  end
+
+  def self.column_key(klass, column)
+    "#{klass.name}:#{column}"
+  end
+
+  def self.has_many
+    @@has_many
+  end
+  def self.assignments
+    @@assignments
+  end
+  def self.column_types
+    @@column_types
+  end
+
+  def self.has_many_for(klass)
+    @@has_many[klass]
+  end
+  def self.assignments_for(klass)
+    @@assignments[klass]
+  end
+
+  def self.column_type_for(klass, column)
+    @@column_types[column_key(klass, column)]
+  end
+
+
+  def find_or_new( klass, condition_hash = {} )
+    @records[klass] = klass.find(:all, :conditions => condition_hash)
+    if @records[klass].any?
+      return @records[klass].first
+    else
+      return klass.new
+    end
+  end
+  
+end

data/lib/engine/method_mapper_csv.rb

@@ -0,0 +1,28 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Jan 2011
+# License::   MIT
+#
+# Details::   Extract the headings from a user supplied CSV file, and map heading names
+#             to the attributes and/or assocaiitons of an AR Model defined by supplied klass.
+#
+require 'method_mapper'
+
+class MethodMapperCsv < MethodMapper
+    
+  # Read the headers from CSV file and map to ActiveRecord members/associations
+
+  def initialize( file_name, klass, sheet_number = 0 )
+    super
+    
+    File.open(file_name) do
+      @headers =  @header_row.split(/,/)
+    end
+
+    # Gather list of all possible 'setter' methods on AR class (instance variables and associations)
+    self.find_operators( klass )
+
+    # Convert the list of headers into suitable calls on the Active Record class
+    find_method_details( klass, @headers )
+  end
+end

data/lib/engine/word.rb

@@ -0,0 +1,70 @@
+# Author::    Tom Statter
+# License::   MIT ?
+#
+# NOTES ON INVESTIGATING OLE METHODS in irb
+#
+# visible = @word_app.ole_method_help( 'Visible' )   # Get a Method Object
+
+# log( visible.return_type_detail.to_s )           # => ["BOOL"]
+# log( visible.invoke_kind.to_s )                  # => "PROPERTYGET"
+# log( visible.params.to_s )                       # => []
+
+# @fc.ole_method_help( 'Report' ).params[1].ole_type_detail
+#
+# prefs = @word_app.Preferences.Strings.ole_method_help( 'Set' ).params
+#   => [index, newVal]
+#
+# WORD_OLE_CONST.constants
+#
+# WORD_OLE_CONST.constants.sort.grep /CR/
+#   => ["ClHideCRLF", "LesCR", "LesCRLF"]
+#
+# WORD_OLE_CONST.const_get( 'LesCR' ) or WORD_OLE_CONST::LesCR
+#   => 1
+require 'win32ole'
+
+# Module for constants to be loaded int
+
+module WORD_OLE_CONST
+end
+
+class Word
+    
+  attr_reader :wd, :doc
+
+  def initialize( visible )
+    @wd = WIN32OLE.new('Word.Application')
+
+    WIN32OLE.const_load(@wd, WORD_OLE_CONST) if WORD_OLE_CONST.constants.empty?
+
+    @wd.Visible = visible
+  end
+
+  def open(file)
+    @doc = @wd.Documents.Open(file)
+    @doc
+  end
+
+  def save()
+    @doc.Save()
+    @doc
+  end
+
+  # Format : From WORD_OLE_CONST e.g WORD_OLE_CONST::WdFormatHTML
+  #
+  def save_as(name, format)
+    @doc.SaveAs(name, format)
+    return @doc
+  end
+
+  # WdFormatFilteredHTML
+  # WdFormatHTML
+  def save_as_html(name)
+    @doc.SaveAs(name, WORD_OLE_CONST::WdFormatHTML)
+    return @doc
+  end
+
+  def quit
+    @wd.quit()
+  end
+end