vex 0.2

data/lib/vex/active_record/serialize_hash.rb

@@ -0,0 +1,125 @@
+__END__
+
+module ActiveRecord::SerializeHash
+  def self.included(base)
+    base.extend ClassMethods
+    base.alias_method_chain :reload, :serialize_hash
+    base.before_update :update_serialize_hashes
+  end
+
+  def self.jsonize(data)
+    return nil if data.nil?
+    return data.to_json unless data.is_a?(Hash)
+
+    "{" + data.to_a.
+      map do |k,v| "#{k.to_json}:#{jsonize(v)}" end.
+      sort.
+      join(",") + 
+    "}"
+  end
+
+  def self.unjsonize(data)
+    r = data.blank? ? {} : JSON.parse(data)
+    r = r.with_indifferent_access if r.respond_to?(:with_indifferent_access)
+    r
+  end
+  
+  module ClassMethods
+    def serialize_hash_attributes
+      @serialize_hash_attributes ||= Set.new
+    end
+    
+    def serialize_hash(attr)
+      serialize_hash_attributes << attr
+      
+      class_eval <<-RUBY
+      def #{attr};     @#{attr} ||= ActiveRecord::SerializeHash.unjsonize read_attribute(:#{attr}); end
+      def #{attr}=(d); write_attribute(:#{attr}, ActiveRecord::SerializeHash.jsonize(d)); @#{attr} = nil; 
+      end
+      RUBY
+    end
+
+    def hashed_attributes(*syms)
+      serialize_hash :hashed_attributes
+
+      syms.each do |sym|
+        define_method(sym)        do hashed_attributes[sym] end
+        define_method("#{sym}=")  do |val| hashed_attributes[sym] = val end
+      end
+    end
+  end
+  
+  def reload_with_serialize_hash
+    self.class.serialize_hash_attributes.each do |attr|
+      instance_variable_set "@#{attr}", nil
+    end
+    reload_without_serialize_hash
+  end
+
+  def update_serialize_hashes
+    self.class.serialize_hash_attributes.each do |attr|
+      next unless val = instance_variable_get("@#{attr}")
+      self.send "#{attr}=", val
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ActiveRecord::SerializeHash
+end
+
+module ActiveRecord::SerializeHash::Etest
+  def test_serialize_hash
+    rb = RandomBase.create!
+    
+    assert_equal({}, rb.parameters)
+    assert_nil(rb.parameters["test"])
+
+    rb.parameters[:test] = "bla"
+    assert_equal("bla", rb.parameters[:test])
+    assert_equal("bla", rb.parameters["test"])
+    
+    rb.parameters["test"] = "lurk"
+
+    assert_equal("lurk", rb.parameters[:test])
+    assert_equal("lurk", rb.parameters["test"])
+
+    rb.reload
+    assert_nil(rb.parameters["test"])
+    rb.parameters["test"] = "lurk"
+    rb.save!
+
+    rb.reload
+    assert_equal("lurk", rb.parameters[:test])
+    assert_equal("lurk", rb.parameters["test"])
+
+    rb = RandomBase.find(rb.id)
+    assert_equal("lurk", rb.parameters[:test])
+    assert_equal("lurk", rb.parameters["test"])
+  end
+
+  def test_hashed_attributes
+    rb = RandomBase.create!
+    rb.ha1 = "ha1"
+    assert_equal("ha1", rb.ha1)
+
+    rb.reload
+    assert_equal(nil, rb.ha1)
+    rb.ha1 = "ha1"
+    rb.save!
+    rb.reload
+    assert_equal("ha1", rb.ha1)
+    
+    rb = RandomBase.find(rb.id)
+    assert_equal("ha1", rb.ha1)
+  end
+  
+  def test_reload
+    rb = RandomBase.create!
+    rb.parameters[:test] = "bla"
+    
+    assert_equal("bla", rb.parameters[:test])
+    rb.reload
+    assert_nil(rb.parameters["test"])
+  end
+end

data/lib/vex/active_record/to_html.rb

@@ -0,0 +1,53 @@
+module ActiveRecord::ToHtml
+  def to_html(options = {}, &block)
+    options = { 
+      :skip_instruct => true, 
+    }.update(options)
+    
+    to_xml(options, &block).gsub( /<[^>]+>/ ) do |m|
+      if m.starts_with?("</")
+        "</div>"
+      else
+        m =~ /^<(\S+)\s*([^>]*)>$/
+        klass, args = $1, $2 
+        "<div class='#{klass}'#{args.blank? ? "" : " #{args}"}>"
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ActiveRecord::ToHtml
+end
+
+module ActiveRecord::ToHtml::Etest
+  class Data < ActiveRecord::Base
+  end
+
+  def setup
+    Data.lite_table do
+      string :name
+      string :age
+    end
+
+    Data.create! :name => "name", :age => 2
+
+    assert_equal(1, Data.count)
+  end
+  
+  def teardown
+    Data.destroy_all
+  end
+  
+  def test_to_html
+    html = <<-HTML
+<div class='active-record-to-html-etest-data'>
+  <div class='age'>2</div>
+  <div class='id' type="integer">25</div>
+  <div class='name'>name</div>
+</div>
+HTML
+
+    assert_equal html, Data.first.to_html
+  end
+end

data/lib/vex/active_record/validate.rb

@@ -0,0 +1,76 @@
+module ActiveRecord::Validate
+  def self.all(quiet=nil, &block)
+    klasses(quiet).inject(0) do |count, klass|
+      count += invalid_models(klass, quiet).length
+    end
+  end
+
+  def self.purge
+    klasses(true).each do |klass|
+      invalids = invalid_models(klass, true)
+      klass.delete_all [ "id IN (?)", invalids.map(&:id) ] unless invalids.empty?
+    end
+  end
+  
+  
+  def self.set_klass_for(opts)
+    @klass_for_table ||= {}
+    @klass_for_table.update opts.with_indifferent_access
+  end
+  
+  private
+
+  def self.klass_for_table(table)
+    @klass_for_table ||= {}
+    if klass = @klass_for_table[table]
+      klass.constantize
+    else
+      table.singularize.camelize.constantize?
+    end
+  end
+  
+  def self.klasses(quiet)
+    ActiveRecord::Base.connection.tables.map do |table|
+      klass = klass_for_table table
+      if !klass
+        STDERR.puts "* #{table}: table w/o class" unless quiet
+      elsif !klass.respond_to?(:table_name) || klass.table_name != table
+        STDERR.puts "Tablename mismatch #{table.inspect} vs #{klass.table_name.inspect}" unless quiet
+      else
+        klass
+      end
+    end.compact
+  end
+  
+  def self.invalid_models(klass, quiet)
+    validate_klass(klass) do |*args|
+      msg, force = *args
+      STDERR.puts(msg) if force || !quiet
+    end
+  end
+  
+  def self.validate_klass(klass)
+    yield "#{klass}: #{sum=klass.count} models"
+
+    invalid = []
+
+    klass.each do |model|
+      next if model.valid?
+      invalid << model
+      
+      yield "\tInvalid model #{model.class}##{model.id}: #{model.errors.full_messages.join(", ")}"
+    end
+
+    yield "\r#{klass}: checked #{klass.count} models, #{invalid.length} invalid", :force
+
+    return invalid if invalid.empty?
+    
+    invalid.group_by(&:class).to_a.
+      sort_by do |klass, ms| klass.name end.
+      each do |klass, ms| 
+        yield "\t** #{klass}: Invalid models: #{ms.collect(&:id).inspect}"
+      end
+    
+    invalid
+  end
+end

data/lib/vex/active_record/validation_error_ext.rb

@@ -0,0 +1,68 @@
+
+# better error reporting: this is useful mainly for development cycles, as
+# it adds an error message only once
+module ActiveRecord::Errors::Unique
+
+  def delete(entry)
+    @errors.delete entry.to_s
+  end
+
+  def add(attribute, message = nil, options = {})
+    add_with_unique_messages(attribute, message, options)
+  end
+
+  def add_with_unique_messages(error_or_attr, message = nil, options = {})
+    if error_or_attr.is_a?(ActiveRecord::Error)
+      error, attribute = error_or_attr, error_or_attr.attribute
+    else
+      attribute = error_or_attr
+      error = ActiveRecord::Error.new(@base, attribute, message, options)
+    end
+    
+    options[:message] = options.delete(:default) if options.has_key?(:default)
+
+    @errors[attribute.to_s] ||= []
+
+    existing = @errors[attribute.to_s].detect do |err|
+      err.message == message
+    end
+    
+    existing || (@errors[attribute.to_s] << error)
+  end
+end
+
+class ActiveRecord::Errors
+  include Unique
+  alias_method_chain :add, :unique_messages
+end
+
+module ActiveRecord::Errors::Unique::Etest
+  ActiveRecord::Base.connection.create_table :error_models do |t|
+    t.integer :value
+  end
+  
+  class ErrorModels < ActiveRecord::Base
+  end
+  
+  def test_single_adds
+    obj = ErrorModels.new
+
+    obj.errors.add "value", "xxx"
+    assert_kind_of(String, obj.errors["value"])
+
+    obj.errors.add "value", "xxx"
+    assert_kind_of(String, obj.errors["value"])
+
+    obj.errors.add "value", "yyyy"
+    assert_equal(%w(xxx yyyy), obj.errors["value"])
+
+    obj.errors.add "value", "yyyy"
+    assert_equal(%w(xxx yyyy), obj.errors["value"])
+
+    obj.errors.add "value", "xxx"
+    assert_equal(%w(xxx yyyy), obj.errors["value"])
+
+    obj.errors.add "value", "zzz"
+    assert_equal(%w(xxx yyyy zzz), obj.errors["value"])
+  end
+end

data/lib/vex/base.rb

@@ -0,0 +1,2 @@
+require "#{File.dirname(__FILE__)}/boot"
+Vex.load_directory "base"

data/lib/vex/base/app.rb

@@ -0,0 +1,75 @@
+module App
+  def self.rails?
+    defined?(RAILS_ROOT)
+  end
+
+  def self.revision
+    @revision ||= begin
+      "r#{File.read("#{root}/REVISION")}"
+    rescue Errno::ENOENT
+      ""
+    end 
+  end
+
+  def self.env
+    if rails?
+      RAILS_ENV
+    elsif defined?(APP_ENV)
+      APP_ENV
+    else
+      "production"
+    end
+  end
+  
+  def self.root
+    if defined?(RAILS_ROOT)
+      RAILS_ROOT
+    elsif defined?(APP_ROOT)
+      APP_ROOT
+    else
+      raise "Cannot determine application root"
+    end
+  end
+
+  def self.logger
+    if rails?
+      RAILS_DEFAULT_LOGGER
+    else
+      require "logger"
+
+      logdir = "#{root}/log"
+      FileUtils.mkdir_p logdir
+      Logger.new "#{logdir}/#{env}.log"
+    end
+  end
+  
+  def self.tmpdir
+    @tmpdir ||= begin
+      tmpdir = if rails?
+        "#{root}/tmp"
+      else
+        ENV["TMPDIR"]
+      end
+
+      tmpdir = tmpdir.gsub(/\/$/, "")
+
+      raise "Cannot determine tmpdir setting" if tmpdir.blank?
+      tmpdir
+    end
+  end
+
+  def self.local_conf
+    @local_conf = nil if App.env == "development"
+    @local_conf ||= LocalConf.new("local.yml")
+  end
+end
+
+module App::Etest
+  def test_app
+    assert_not_nil(App.root)
+  end
+
+  def test_app
+    assert_equal("", App.revision)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/array/at_random.rb

@@ -0,0 +1,17 @@
+module Array::AtRandom
+  def at_random
+    self[Kernel.rand(length)] unless empty?
+  end
+end
+
+Array.send :include, Array::AtRandom
+
+module Array::AtRandom::Etest
+  def test_at_random
+    array = [ 1, 2, 3, 4, 5 ]
+    5.times do
+      assert array.include?(array.at_random)
+    end
+    assert_equal nil, [].at_random
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/array/cross.rb

@@ -0,0 +1,26 @@
+module Array::Cross
+  def cross(other, &block)
+    if !block_given?
+      r = []
+      cross(other) do |mine, others|
+        r << [ mine, others ]
+      end
+      return r 
+    else    
+      each do |obj|
+        other.each do |oo| yield obj, oo end
+      end
+    end
+  end
+end
+
+Array.send :include, Array::Cross
+
+module Array::Cross::Etest
+  def test_cross
+    assert_equal( [[1,1]],                            [1].cross([1])  )
+    assert_equal( [[1,1], [2,1]],                     [1, 2].cross([1])  )
+    assert_equal( [[1,1], [1,3], [2,1], [2,3]],       [1, 2].cross([1, 3])  )
+    assert_equal( [],                                 [1, 2].cross([])  )
+  end
+end if VEX_TEST == "base"