dohruby 0.2.1 → 0.3

data/lib/doh/mysql/require_dbtypes.rb

@@ -0,0 +1,8 @@
+module DohDb
+
+def self.require_dbtypes
+  lib_dbtypes_file = File.join(DohApp::home, 'lib/dbtypes.rb')
+  require(lib_dbtypes_file) if File.exist?(lib_dbtypes_file)
+end
+
+end

data/lib/doh/mysql/smart_row.rb

@@ -0,0 +1,156 @@
+require 'doh/mysql/writable_row'
+require 'doh/util/to_display'
+require 'doh/mysql/virtual'
+
+module DohDb
+
+class RowDisplayProxy
+  def initialize(row)
+    @row = row
+  end
+
+  def method_missing(sym, *ignore_args)
+    @row.send(sym.to_s).to_display
+  end
+end
+
+class AbstractSmartRow < AbstractRow
+  attr_accessor :table
+  attr_reader :changed_keys
+
+  def initialize(keys, values)
+    @keys = keys.dup
+    @values = values.dup
+    @changed_keys = Set.new
+    @cached_virtuals = {}
+  end
+
+  def initialize_copy(orig)
+    @keys = @keys.dup
+    @values = @values.dup
+    @changed_keys = @changed_keys.dup
+    @cached_virtuals = @cached_virtuals.dup
+    @display_proxy = nil
+  end
+
+  def display(key = nil)
+    if key.nil?
+      @display_proxy ||= RowDisplayProxy.new(self)
+    else
+      get(key).to_display
+    end
+  end
+
+  def set(key, value, flag_changed = true)
+    index = @keys.index(key)
+    if index
+      if @values[index] != value
+        @values[index] = value
+        @changed_keys.add(key)
+      end
+    else
+      @keys.push(key)
+      @values.push(value)
+      @changed_keys.add(key)
+    end
+    value
+  end
+  alias []= set
+
+  def clear_changed_keys
+    @changed_keys.clear
+  end
+
+  def method_missing(sym, *args)
+    name = sym.to_s
+    if name.end_with?('=')
+      guess_missing_set(name[0..-2], args.first)
+    else
+      guess_missing_get(name)
+    end
+  end
+
+  def merge!(hash)
+    hash.each_pair { |key, value| set(key, value) }
+  end
+
+  def delete(key)
+    index = @keys.index(key)
+    return unless index
+    @keys.delete_at(index)
+    @values.delete_at(index)
+  end
+
+  def record_id=(value)
+    set(primary_key, value)
+  end
+
+  def db_insert
+    newid = DohDb::insert_hash(self, @table)
+    if newid != 0
+      set(primary_key, newid, false)
+    end
+    newid
+  end
+
+  def db_update
+    return if @changed_keys.empty?
+    before_db_update
+    builder = BuildSQL::SimpleUpdateRow.new(@table, nil, get(primary_key), primary_key)
+    @changed_keys.each {|key| builder.setc(key, get(key).to_sql)}
+    DohDb::query(builder)
+    after_db_update
+    @changed_keys.clear
+  end
+
+protected
+  def primary_key
+    DohDb::find_primary_key(@table)
+  end
+
+  def before_db_update
+  end
+
+  def after_db_update
+  end
+
+  def guess_missing_get(key)
+    return get(key) if key?(key)
+    retval = get_virtual_field(key)
+    raise "unknown field: #{key}" unless retval
+    retval
+  end
+
+  def guess_missing_set(key, value)
+    set(key, value)
+  end
+
+  def get_virtual_field(name)
+    cached = @cached_virtuals[name]
+    return cached if cached
+    if idvalue = get(name + '_id')
+      @cached_virtuals[name] = DohDb::LinkedRow.build(name, idvalue.to_i)
+    else
+      nil
+    end
+  end
+end
+
+class SmartRow < AbstractSmartRow
+  def initialize(*args)
+    parsed_args = parse_initialize_args(*args)
+    if parsed_args.size == 3
+      @table = parsed_args.pop
+    end
+    super(*parsed_args)
+  end
+end
+
+class CustomSmartRow < AbstractSmartRow
+  def initialize(*args)
+    super(*parse_initialize_args(*args))
+    @table = self.class.default_table
+  end
+end
+
+end

data/lib/doh/mysql/to_sql.rb

@@ -8,6 +8,12 @@ class Object
   end
 end
 
+class NilClass
+  def to_sql
+    'NULL'
+  end
+end
+
 class Numeric
   def to_sql
     to_s
@@ -37,3 +43,9 @@ class BigDecimal
     to_s('F')
   end
 end
+
+class Array
+  def to_sql
+    '(' + collect { |elem| elem.to_sql }.join(',') + ')'
+  end
+end

data/lib/doh/mysql/typed_row_builder.rb

@@ -4,8 +4,9 @@ require 'doh/mysql/default_type_guesser'
 module DohDb
 
 class TypedRowBuilder
-  def initialize(guesser = nil)
-    @guesser = guesser || DefaultTypeGuesser.new
+  def initialize(row_klass = nil, guesser = nil)
+    @row_klass = row_klass || ReadOnlyRow
+    @guesser = guesser || DefaultTypeGuesser
   end
 
   def build_rows(result_set)
@@ -18,7 +19,7 @@ class TypedRowBuilder
       row.each_with_index do |field, index|
         typed_values[index] = @guesser.guess_type(field, meta_info[index])
       end
-      retval.push(ReadOnlyRow.new(field_names, typed_values))
+      retval.push(@row_klass.new(field_names, typed_values))
     end
     retval
   end

data/lib/doh/mysql/types.rb

@@ -0,0 +1,33 @@
+module DohDb
+
+@@column_types = {}
+def self.register_column_type(database, table, column, klass)
+  database = '__global__' # until database support is available
+  @@column_types[database] ||= {}
+  table = '__global__' if table.nil?
+  @@column_types[database][table] ||= {}
+  @@column_types[database][table][column] = klass
+end
+
+def self.find_column_type(database, table, column)
+  database = '__global__' # until database support is available
+  db_hash = @@column_types[database]; return nil unless db_hash
+  table = '__global__' if table.nil?
+  table_hash = db_hash[table]; return nil unless table_hash
+  table_hash[column]
+end
+
+def self.link_database_types(dest_db, source_db)
+  @@column_types[dest_db] = @@column_types[source_db]
+end
+
+@@row_types = {}
+def self.register_row_type(table, klass)
+  @@row_types[table] = klass
+end
+
+def self.find_row_type(table)
+  @@row_types[table]
+end
+
+end

data/lib/doh/mysql/unquoted.rb

@@ -6,4 +6,12 @@ class Unquoted < String
   end
 end
 
+def self.unquoted(str)
+  Unquoted.new(str)
+end
+
+NOW = Unquoted.new('NOW()').freeze
+TODAY = Unquoted.new('CURDATE()').freeze
+NULL = Unquoted.new('NULL').freeze
+
 end

data/lib/doh/mysql/version.rb

@@ -0,0 +1,102 @@
+require 'doh/mysql/connector_instance'
+require 'yaml'
+
+module DohDb
+
+def self.locked_filename(database)
+  File.join(DohApp::home, 'database', database, 'migrate/locked.yml')
+end
+
+def self.migration_filename(database, version, upordown = 'up')
+  version_str = version.to_s.rjust(3, '0')
+  File.join(DohApp::home, 'database', database, "migrate/#{version_str}_#{upordown}.sql")
+end
+
+def self.current_database_version(database = nil)
+  if database.nil?
+    table = 'version'
+  else
+    table = database + '.version'
+  end
+  DohDb::select_field("SELECT version FROM #{table}").to_i
+end
+
+def self.latest_database_version(database = nil)
+  locked_version = locked_database_version(database)
+  unlocked_version = locked_version + 1
+  unlocked_migration_file = migration_filename(database, unlocked_version)
+  if File.exist?(unlocked_migration_file)
+    unlocked_version
+  else
+    locked_version
+  end
+end
+
+def self.locked_version_info(database = nil)
+  database ||= (DohDb::connector_instance && DohDb::connector_instance.database) || DohApp::config['primary_database']
+  filename = locked_filename(database)
+  return [0, nil] unless File.exist?(filename)
+  YAML.load_file(filename)
+end
+
+def self.locked_database_version(database = nil)
+  locked_version_info(database).first
+end
+
+def self.locked_svn_revision(database = nil)
+  locked_version_info(database).last
+end
+
+def self.update_locked_file(database)
+  locked_file = locked_filename(database)
+  if File.exist?(locked_file)
+    new_version = YAML.load_file(locked_file).first + 1
+  else
+    new_version = 0
+    need_to_add = true
+  end
+
+  file_to_check = ''
+  if need_to_add
+    file_to_check = File.join(DohApp::home, "database")
+  else
+    unlocked_migration_file = migration_filename(database, new_version)
+    return [true, "nothing to lock"] unless File.exist?(unlocked_migration_file)
+
+    svnout = `svn st #{unlocked_migration_file}`
+    unless svnout.strip.empty?
+      return [false, "svn status shows local changes to #{unlocked_migration_file} -- this needs to be resolved before updating the migration locked file"]
+    end
+
+    file_to_check = unlocked_migration_file
+  end
+
+  `svn update #{file_to_check}`
+  svnout = `svn st -v #{file_to_check}`.split("\n")
+  svnout =~ /(\d+)/
+  revision = svnout.collect {|elem| elem =~ /(\d+)/; $1.to_i}.max
+  if !revision
+    return [false, "unable to extract svn revision from: '#{svnout}'"]
+  end
+
+  outfile = File.new(locked_file, 'w')
+  outfile.puts([new_version, revision.to_i].inspect)
+  outfile.close
+
+  if need_to_add
+    svnout = `svn add #{locked_file}`
+    if svnout[0,1] != 'A'
+      return [false, "failed to svn add #{locked_file}"]
+    end
+  end
+
+  msg = "migrate lock for #{database} database, version #{new_version}"
+  svnout = `svn ci -m \"#{msg}\"  #{locked_file}`
+  unless svnout.index("Committed revision")
+    return [false, "failed to svn ci #{locked_file}"]
+  end
+
+  [true, "#{locked_file} successfully updated"]
+end
+
+end

data/lib/doh/mysql/virtual.rb

@@ -0,0 +1,17 @@
+require 'doh/mysql/metadata_util'
+require 'doh/mysql/readonly_row'
+require 'doh/mysql/types'
+
+module DohDb
+
+class LinkedRow
+  def self.build(field, idvalue)
+    return ReadOnlyRow.new([], []) if idvalue.to_i == 0
+    table = field.sub(/_id/, '')
+    table = table.rafter('_') unless DohDb::table_exist?(table)
+    raise "unable to determine child table name for field #{field}" unless DohDb::table_exist?(table)
+    DohDb::select_row("SELECT * FROM #{table} WHERE #{DohDb::find_primary_key(table)} = #{idvalue}", DohDb::find_row_type(table) || :smart)
+  end
+end
+
+end

data/lib/doh/mysql/writable_row.rb

@@ -0,0 +1,58 @@
+require 'doh/mysql/abstract_row'
+require 'set'
+
+module DohDb
+
+class WritableRow < AbstractRow
+  attr_reader :changed_keys
+
+  # can accept 2 arguments: keys array, values array
+  # or 1 argument: a hash
+  def initialize(*args)
+    keys, values = parse_initialize_args(*args)
+    @keys = keys.dup
+    @values = values.dup
+    @changed_keys = Set.new
+  end
+
+  def initialize_copy(orig)
+    super(orig)
+    @changed_keys = Set.new
+  end
+
+  def set(key, value)
+    index = @keys.index(key)
+    if index
+      @values[index] = value
+    else
+      @keys.push(key)
+      @values.push(value)
+    end
+    @changed_keys.add(key)
+    value
+  end
+  alias []= set
+
+  def clear_changed_keys
+    @changed_keys.clear
+  end
+
+  def method_missing(sym, *args)
+    name = sym.to_s
+    if name.lastn(1) == '='
+      key = name[0..-2]
+      assign = true
+    else
+      key = name
+    end
+    raise RuntimeError.new("unknown field: " + name) unless key?(key)
+
+    if assign
+      set(key, args.first)
+    else
+      get(key)
+    end
+  end
+end
+
+end

data/lib/doh/mysql.rb

@@ -2,4 +2,5 @@ require 'doh/mysql/cache_connector'
 require 'doh/mysql/connector_instance'
 require 'doh/mysql/handle'
 require 'doh/mysql/to_sql'
-require 'doh/mysql/hash_util'
+require 'doh/mysql/db_date'
+require 'doh/mysql/unquoted'

data/lib/doh/paypal/paypal.rb

@@ -0,0 +1,20 @@
+require 'doh/util/http_helper'
+module DohPaypal
+
+#     <form method=post action="https://www.sandbox.paypal.com/cgi-bin/webscr">
+#     <input type="hidden" name="cmd" value="_notify-synch">
+#     <input type="hidden" name="tx" value="5GW002680B422045J">
+#     <input type="hidden" name="at" value="cIPgiu5oHqqMBQmjXdlEozmRH5N1XwT0Bk2gaPeg_6S433QYY9Cj9REL3Hu">
+#     <input type="submit" value="PDT">
+#     </form>
+
+  #this downloads the payment data for a transaction, passing in the tx that paypal sends to us
+  def self.get_tx_info(tx_str)
+    hash = {'cmd' => '_notify-synch', 'tx' => tx_str, 'at' => DohApp::config['paypal_identity_string']}
+    http = Doh::HttpHelper.new("https://#{DohApp::config['paypal_url']}/cgi-bin/webscr")
+    http.post(hash)
+  end
+
+
+
+end

data/lib/doh/paypal/pdt.rb

@@ -0,0 +1,14 @@
+module DohPaypal
+#     <form method=post action="https://www.sandbox.paypal.com/cgi-bin/webscr">
+#     <input type="hidden" name="cmd" value="_notify-synch">
+#     <input type="hidden" name="tx" value="5GW002680B422045J">
+#     <input type="hidden" name="at" value="cIPgiu5oHqqMBQmjXdlEozmRH5N1XwT0Bk2gaPeg_6S433QYY9Cj9REL3Hu">
+#     <input type="submit" value="PDT">
+#     </form>
+
+  def self.get_tx_info(tx_str)
+    hash = {'cmd' => '_notify-synch', 'tx' => tx_str, 'at' => DohApp::config['paypal_identity_string']}
+    http = Doh::HttpHelper.new("https://#{DohApp::config['paypal_url']}/cgi-bin/webscr")
+    http.post(hash)
+  end
+end

data/lib/doh/paypal.rb

@@ -0,0 +1 @@
+require 'doh/paypal/paypal'

data/lib/doh/rails/form_helpers.rb

@@ -0,0 +1,53 @@
+module DohRails
+module FormHelpers
+
+def self.get_label_html(options)
+  if options.key?(:label)
+    label_html = "<label for='#{DohRails::FormHelpers::get_id(options)}'>#{options[:label]}</label>"
+    options.delete(:label)
+  end
+  return label_html
+end
+
+def self.get_id(options)
+  options[:name] ? options[:name] : "obj_#{options.hash}"
+end
+
+def self.option_str(options)
+  options.to_a.collect{|key, value| "#{key}='#{value}'"}.join(' ')
+end
+
+def doh_field(type, options)
+  label_html = DohRails::FormHelpers::get_label_html(options)
+  "#{label_html}<input id='#{DohRails::FormHelpers::get_id(options)}' type='#{type}' #{DohRails::FormHelpers::option_str(options)}"
+end
+
+def doh_text_field(options)
+  doh_field('text', options)
+end
+
+def doh_hidden_field(options)
+  doh_field('hidden', options)
+end
+
+def doh_checkbox(options)
+  doh_field('checkbox', options)
+end
+
+#kjmtodo modify to set default value based on model / field name
+def doh_select(select_array, options = {})
+  label_html = DohRails::FormHelpers::get_label_html(options)
+  result = ''
+  result += label_html
+  result += "<select id='#{DohRails::FormHelpers::get_id(options)}' #{DohRails::FormHelpers::option_str(options)}>\n"
+  select_list = select_array.collect do |elem|
+    "<option value=\"#{elem[0]}\">#{elem[1]}</option>"
+  end
+  result += select_list.join("\n")
+  result += "</select>"
+  result
+end
+
+
+end
+end

data/lib/doh/rails/login.rb

@@ -0,0 +1,143 @@
+require 'doh/mysql'
+require 'digest'
+
+module DohRails
+module Login
+  attr_accessor :login_model, :login_controller, :username_fieldname, :password_fieldname, :login_table, :login_db_name, :password_db_name, :index_page, :login_page
+
+  #set the attr_accessors or override them
+
+  def login_controller
+    @login_controller || 'application'
+  end
+
+  def login_model
+    @login_model || 'login_model'
+  end
+
+  def username_fieldname
+    @username_fieldname || 'username'
+  end
+
+  def password_fieldname
+    @password_fieldname || 'password'
+  end
+
+  def login_table
+    @login_table || 'login'
+  end
+
+  def login_db_name
+    @login_db_name || 'login'
+  end
+
+  def login_page
+    @login_page || 'login'
+  end
+
+  def index_page
+    @index_page || 'index'
+  end
+
+  def password_db_name
+    @password_db_name || 'password'
+  end
+
+  def login_page_hit
+  end
+
+  def login_failed
+    flash[:notice] = 'Please enter a valid username / password'
+  end
+
+  def login_succeeded
+  end
+
+  def login_redirect
+    flash[:notice] = 'Please log in'
+  end
+
+  def login_required
+    if !authenticated?
+      dohlog.debug "not authenticated, redirecting to  #{login_page}"
+      session[:dohrails_original_uri] = request.request_uri
+      dohlog.debug("storing original uri #{request.request_uri.inspect}")
+      login_redirect
+      redirect_to :controller => login_controller, :action => login_page
+      return false
+    end
+  end
+
+  def authenticated?
+    if @authentication_checked
+      return @authenticated
+    end
+    dohlog.debug("authenticated? called -- session[:dohrails_login_username] = #{session[:dohrails_login_username]}")
+    @authenticated = authenticate_username_key(session[:dohrails_login_username], session[:dohrails_login_key]) if !session[:dohrails_login_username].to_s.strip.empty? && !session[:dohrails_login_key].to_s.strip.empty?
+    @authentication_checked = true
+    return @authenticated
+  end
+
+  # override this to have custom behavior
+  def authenticate_username_key(username, key)
+    begin
+      row = DohDb::select_optional_row("SELECT * FROM #{login_table} WHERE #{login_db_name} = #{username.to_sql}")
+      if row
+        if key == get_session_key(username, row[password_db_name])
+          self.instance_variable_set("@#{login_table}_row", row)
+          dohlog.debug("authenticate_username returning true")
+          return true
+        end
+      end
+    rescue Exception => e
+      dohlog.warn("got error: #{e.inspect} (called from authenticate_username_key) -- are you missing the table: #{login_table.inspect}?")
+    end
+    dohlog.debug("authenticate_username returning nil")
+    return nil
+  end
+
+  def get_session_key(username, password)
+    Digest::SHA1.hexdigest("#{username}**#{password}")
+  end
+
+  def logged_in?
+    authenticated?
+  end
+
+  def login
+    login_page_hit
+    if request.post?
+      login_params = params[login_model]
+      session[:dohrails_login_username] = login_params[username_fieldname]
+      session[:dohrails_login_key] = get_session_key(login_params[username_fieldname], login_params[password_fieldname])
+      if authenticated?
+        login_succeeded
+        if session[:dohrails_original_uri]
+          dohlog.debug("redirecting to original uri: #{session[:dohrails_original_uri].inspect}")
+          redirect_to session[:dohrails_original_uri]
+          session[:dohrails_original_uri] = nil
+        else
+          dohlog.debug("no original uri, redirecting to index")
+          redirect_to :controller => login_controller, :action => index_page
+        end
+      else
+        dohlog.debug("login_helper called, not authenticated -- redirecting to login page")
+        login_failed
+        redirect_to :controller => login_controller, :action => login_page
+      end
+    end
+  end
+
+  def logged_out
+    flash[:notice] = 'You are now logged out'
+  end
+
+  def logout
+    session[:dohrails_login_username] = ''
+    session[:dohrails_login_key] = ''
+    logged_out
+    redirect_to :controller => login_controller, :action => login_page
+  end
+
+end
+end

data/lib/doh/test/error_acceptor.rb

@@ -17,7 +17,7 @@ end
 def self.check_for_unhandled_errors
   errors = DohTest::error_acceptor.events
   unless errors.empty?
-    STDERR.puts("#{errors.size} unhandled errors were written to the log file:")
+    STDERR.puts("#{errors.size} unhandled errors were written to the log file (call DohTest::pop_error after a test if the test is expected to generate an error):")
     formatter = DohLogger::Formatter.new("[%severity] : %msg\nexception: %exception\nstack:\n%call_stack")
     errors.each {|elem| STDERR.puts(formatter.replace(elem))}
     exit 1