marjoree 0.0.1 → 0.0.9

data/lib/marjoree/fixtures.rb

@@ -0,0 +1,156 @@
+require 'test/unit'
+require 'erb'
+require 'yaml'
+require 'marjoree'
+
+class Test::Unit::TestCase
+  attr_reader :fixtures
+  @@fixture_path = 'fixtures'
+
+  def self.fixture_path=(path)
+    @@fixture_path = path
+  end
+
+  def self.fixture_path
+    @@fixture_path
+  end
+
+  def setup_with_fixtures
+  end
+
+  def teardown_with_fixtures
+  end
+
+  def self.fixtures(*tables)      
+    self.module_eval <<-EOS
+
+      def find_fixture_file( fixture_name )
+          return Dir["#{Test::Unit::TestCase.fixture_path}/**/\#{fixture_name}.yml"].first
+      end
+
+      def connect_to_db_for_fixture( path )
+          path_elements = path.split( '/' )
+          odbc_name = path_elements[ path_elements.size - 2]
+
+          connect_me_to( odbc_name.eql?( 'fixtures' ) ? 'default' : odbc_name )
+      end
+
+      def connect_to_default
+        connect_me_to 'default'
+      end
+
+      def setup_with_fixtures
+        @fixtures = [#{tables.collect{ |table| ":#{table}"}.join(',')}]
+
+        empty_fixture_tables( @fixtures )
+
+        @fixtures.each do |fixture|
+          path = find_fixture_file( fixture )
+          yaml = IO.read(path)
+          rows = YAML.load(ERB.new(yaml).result(binding)).sort
+
+          connect_to_db_for_fixture( path )
+
+          rows.each do |name, map|
+            Marjoree.execute map.to_sql(fixture)
+          end
+        end
+
+        connect_to_default
+      end
+
+      def teardown_with_fixtures
+        empty_fixture_tables( fixtures )
+      end
+
+      def empty_fixture_tables( fixtures )
+        fixtures.reverse.each do |fixture|
+          path = find_fixture_file( fixture )
+          connect_to_db_for_fixture( path )
+
+          begin
+            Marjoree.execute "DELETE FROM \#{fixture}"
+          rescue=>e
+            puts "Failed to truncate \#{fixture}: \#{e}"
+          end
+
+          connect_to_default
+        end
+      end
+    EOS
+
+    tables.each do |table|
+      module_eval <<-EOS
+        def #{table}(key)
+          path = find_fixture_file( "#{table}" )          
+          yaml = IO.read(path)
+          rows = YAML.load(ERB.new(yaml).result)
+          map = rows[key.to_s]
+
+          def map.id;
+            return fetch('id') if member?('id')
+            return fetch("id_#{table.to_s.downcase}")
+          end
+
+          def map.method_missing(name, *args)
+            return self[name.to_s] || defaults[name]
+          end
+
+          def map.with_defaults(defaults)
+            @defaults = defaults
+            self
+          end
+
+          def map.defaults
+             @defaults || {}
+          end
+          return map
+        end
+      EOS
+      unless table.to_s.downcase == table.to_s
+        module_eval <<-EOS
+          def #{table.to_s.downcase}(key)
+            #{table}(key)
+          end
+        EOS
+      end
+    end
+  end
+
+  def setup
+    setup_with_fixtures
+  end
+
+  def teardown
+    teardown_with_fixtures
+  end
+
+  def self.method_added(method)
+    case method.to_s
+    when 'setup'
+      unless method_defined?(:setup_without_fixtures)
+        alias_method :setup_without_fixtures, :setup
+        define_method(:setup) do
+          setup_with_fixtures
+          setup_without_fixtures
+        end
+      end
+    when 'teardown'
+      unless method_defined?(:teardown_without_fixtures)
+        alias_method :teardown_without_fixtures, :teardown
+        define_method(:teardown) do
+          teardown_without_fixtures
+          teardown_with_fixtures
+        end
+      end
+    end
+  end
+end
+
+class Hash
+  def to_sql(table)
+    columns = keys.join(',')
+    column_values = values.collect { |v| v.kind_of?(Numeric) ? v : "'#{v}'" }.join(',')
+    return "INSERT INTO #{table}(#{columns}) VALUES(#{column_values})"
+  end
+end

data/lib/marjoree/odbc.rb

@@ -0,0 +1,45 @@
+require 'odbc'
+
+module ODBC
+  class TimeStamp
+    alias_method :old_to_s, :to_s
+
+    def ==( pal )
+      return to_s.index( pal.to_s ) == 0
+    end
+
+    def to_s
+      datetime = old_to_s
+      date, time, fraction = datetime.split(" ")
+
+      fraction_text = (fraction == '0') ? '' : ".#{fraction}"
+      return "#{date} #{time}#{fraction_text}"
+    end
+
+    def self.from_date(date)
+      return ODBC::TimeStamp.new(date.strftime('%Y-%m-%d 0:0:0.000'))
+    end
+
+    def self.from_time(time)
+      return ODBC::TimeStamp.new(time.strftime('%Y-%m-%d %H:%M:%S.000'))
+    end
+
+    def inspect
+      "#{old_to_s.split[0]} #{old_to_s.split[1]}"
+    end
+
+  end
+
+  class Error
+    def error_code
+      start_index = to_s =~ /(\()/
+      end_index = to_s =~ /(\))/
+      end_index -= 1
+      return to_s.slice( (start_index + 1 ), (end_index - start_index ) ).to_i
+    end
+
+    def error_message
+      return to_s.split( /\]/ ).last.rstrip
+    end
+  end
+end

data/lib/marjoree/odbc_connection_wrapper.rb

@@ -0,0 +1,79 @@
+require 'erb'
+require 'yaml'
+
+class OdbcConnectionWrapper
+    @@odbc_config_path = "odbc_config/connections.yml"
+
+    def self.odbc_config_path=(path)
+      @@odbc_config_path = path      
+    end
+
+    def self.odbc_config_path
+      @@odbc_config_path
+    end
+
+    def initialize
+        yaml = IO.read("#{OdbcConnectionWrapper.odbc_config_path}")
+        @odbc_config = YAML.load(ERB.new(yaml).result(binding))
+        @odbc_connections = {}
+        @default_odbc_name = @odbc_config.size == 1 ? @odbc_config.keys.first : @odbc_config['default']['odbc_connection']
+        connect_me_to( 'default' )
+    end
+
+    def connect_me_to( odbc_name )
+        odbc_name = @default_odbc_name if odbc_name == 'default'
+        @connection = @odbc_connections[odbc_name]
+        unless @connection
+          value = @odbc_config[odbc_name]
+          @connection = ODBC.connect(odbc_name, value['username'], value['password'] )
+          @odbc_connections[odbc_name]=@connection
+        end
+        $db = @connection
+    end
+
+    def disconnect_me
+        @odbc_connections.each do |odbc_name, connection|            
+            connection.drop_all
+        end
+    end
+
+    def execute(sql, output_params = [])
+        begin
+            dbCall = @connection.prepare(sql)
+            begin
+                dbCall.execute
+                return ResultSet.new(dbCall, output_params)
+            rescue
+                raise ODBC::Error.new("Failed executing: #{sql}\nDue to: #{$!}")
+            end
+        ensure
+            dbCall.drop
+        end
+    end
+
+    def has_output_params?(proc_name)
+        begin
+            dbCall = @connection.procedure_columns proc_name
+            result_set = ResultSet.new(dbCall)
+            return result_set.contains?({ :COLUMN_TYPE => 4 })
+        ensure
+            dbCall.drop
+        end
+    end
+
+    def get_output_params(proc_name)
+        begin
+            dbCall = @connection.procedure_columns proc_name
+            result_set = ResultSet.new(dbCall)
+            result = []
+            result_set.collect do |hash|
+                if hash[:COLUMN_TYPE] == 4   #varchar
+                    result << hash
+                end
+            end
+            return result
+        ensure
+            dbCall.drop 
+        end
+    end
+end

data/lib/marjoree/result_set.rb

@@ -0,0 +1,165 @@
+class ResultSet
+  attr_reader :columns
+  attr_reader :hashes
+
+  def initialize(statement, output_param_names = [])
+    @padding = " "
+    @spacer = " "
+    @columns = statement.columns
+    @hashes = []
+
+    if output_param_names.length > 0
+      apply_output_params output_param_names, statement
+    else
+      extract_results statement
+    end
+  end
+
+  def apply_output_params(output_param_names, statement)
+    output_param_names.each do |output_param_name|
+      instance_variable_set(output_param_name, statement.fetch![0])
+      statement.more_results
+    end
+  end
+
+  def method_missing(name)
+    member_var = eval("@#{name}")
+    if !member_var.nil?
+      return member_var
+    else
+      return super
+    end
+  end
+
+  def is_output_param?(name)
+    return !eval("#{name}").nil?
+  end
+
+  def count
+    return @hashes.size
+  end
+
+  def size
+    return count
+  end
+
+  def empty?
+    return count == 0
+  end
+
+  def collect
+    @hashes.each do |hash|
+      yield hash
+    end
+  end
+
+  def has?(expected_result_set)
+    return contains?(expected_result_set.row_hashes)
+  end
+
+  def contains?(*expected_rows)
+    expected_rows.flatten.each do |expected|
+      return false unless contains_row?(expected)
+    end
+
+    return true
+  end
+
+  def contains_row?(expected)
+    expected_with_symbols = convert_keys_to_symbols(expected)
+    @hashes.each do |actual|
+      return true if actual == actual.merge(expected_with_symbols)
+    end
+
+    return false
+  end
+
+  def to_s
+    column_widths = widest_value_in_columns
+    result = create_header_row(column_widths)
+    result << "\n" + create_separator_row(column_widths)
+    @hashes.each { |row| result << "\n" + create_data_row(row, column_widths) }
+    return result
+  end
+
+  private
+
+  def create_separator_row(column_widths)
+    result = ""
+
+    column_widths.each do |width|
+      result << " "
+      num_bars = width + ( @padding.length * 2 )
+      num_bars.times { result << "-" }
+    end
+
+    result << " "
+
+    return result
+  end
+
+  def create_header_row( column_widths )
+    result = "|"
+
+    column_names.each_with_index do |header, i|
+      result << "#{@padding}" + create_entry(header, column_widths[i]) + "#{@padding}|"
+    end
+
+    return result
+  end
+
+  def create_data_row(row, column_widths)
+    result = "|"
+
+    column_names.each_with_index do |header, i|
+      result << "#{@padding}" + create_entry(row[header.to_sym].to_s, column_widths[i]) + "#{@padding}|"
+    end
+
+    return result
+  end
+
+  def create_entry( header, expected_width )
+    return header if header.length == expected_width
+
+    num_prefix_spaces = (expected_width - header.length)/2
+    num_postfix_spaces = expected_width - (num_prefix_spaces + header.length)
+    pre = ""
+    post = ""
+    num_prefix_spaces.times { pre << " " }
+    num_postfix_spaces.times { post << " " }
+
+    return pre + header + post
+  end
+
+  def widest_value_in_columns
+    result = []
+
+    column_names.each do |header|
+      largest = header.length
+      @hashes.each do |row|
+        if row[header.to_sym].to_s.length > largest
+          largest = row[header.to_sym].to_s.length
+        end
+      end
+
+      result << largest
+      puts
+    end
+
+    return result
+  end
+
+  def column_names
+    return columns.keys
+  end
+
+  def convert_keys_to_symbols(row)
+    result = {}
+    row.each { |key, value| result[key.to_sym] = value }
+    return result
+  end
+
+  def extract_results(statement)
+    statement.each_hash { |row| @hashes << convert_keys_to_symbols(row) }
+  end
+end