bj 0.0.1

data/lib/bj/stdext.rb

@@ -0,0 +1,80 @@
+class Hash
+  begin
+    method "to_options"
+  rescue
+    def to_options
+      inject(Hash.new){|h, kv| h.update kv.first.to_s.to_sym => kv.last}
+    end
+    def to_options!
+      replace to_options
+    end
+  end
+
+  begin
+    method "to_string_options"
+  rescue
+    def to_string_options
+      inject(Hash.new){|h, kv| h.update kv.first.to_s => kv.last}
+    end
+    def to_string_options!
+      replace to_string_options
+    end
+  end
+
+  begin
+    method "reverse_merge"
+  rescue
+    def reverse_merge other
+      other.merge self
+    end
+    def reverse_merge! other
+      replace reverse_merge(other)
+    end
+  end
+end
+
+class Object
+  begin
+    method "returning"
+  rescue
+    def returning value, &block
+      block.call value
+      value
+    end
+  end
+end
+
+class Object
+  def singleton_class &block
+    @singleton_class ||=
+      class << self
+        self
+      end
+    block ? @singleton_class.module_eval(&block) : @singleton_class
+  end
+end
+
+class Module 
+  Instance_Methods = instance_method "instance_methods" unless defined? Instance_Methods
+  def instance_methods &block
+    block ? module_eval(&block) : Instance_Methods.bind(self).call
+  end
+  def module_methods &block
+    block ? singleton_class(&block) : singleton_methods
+  end
+  alias_method "class_methods", "module_methods"
+end
+
+class String
+  begin
+    method 'underscore'
+  rescue
+    def underscore
+      gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/bj/table.rb

@@ -0,0 +1,388 @@
+class Bj
+#
+# table base class
+#
+  class Table < ActiveRecord::Base
+    module ClassMethods
+      attribute("list"){ Array.new }
+      attribute("migration"){}
+
+      def generate_migration
+        before = Dir.glob "./db/migrate/*"
+        Util.spawn "./script/generate migration BjMigration"
+        after = Dir.glob "./db/migrate/*"
+        candidates = after - before
+        case candidates.size
+          when 0
+            false
+          when 1
+            generated = candidates.first
+            open(generated, "w"){|fd| fd.puts migration_code}
+            generated
+          else
+            raise "ambiguous migration <#{ candidates.inspect }>"
+        end
+      end
+
+      def migration_code
+        <<-code
+          class BjMigration < ActiveRecord::Migration
+            def self.up
+              Bj::Table.each{|table| table.up}
+            end
+            def self.down
+              Bj::Table.reverse_each{|table| table.down}
+            end
+          end
+        code
+      end
+
+      def up
+        migration_class.up
+      end
+
+      def down
+        migration_class.down
+      end
+
+      def migration_class
+        table = self
+        @migration_class ||=
+          Class.new(ActiveRecord::Migration) do
+            sc =
+              class << self
+                self
+              end
+            sc.module_eval{ attribute :table => table }
+            sc.module_eval &table.migration
+          end
+      end
+
+      def content_column_names
+        @content_column_names = content_columns.map{|column| column.name}
+      end
+
+      def create_hash_for options
+        options.to_options!
+        hash = {}
+        content_column_names.each do |key|
+          key = key.to_s.to_sym
+          hash[key] = options[key]
+        end
+        hash
+      end
+
+      def each *a, &b
+        list.each *a, &b
+      end
+
+      def reverse_each *a, &b
+        list.reverse.each *a, &b
+      end
+    end
+    send :extend, ClassMethods
+
+    module InstanceMethods
+      def to_hash
+        oh = OrderedHash.new
+        self.class.content_column_names.each{|c| oh[c] = self[c]}
+        oh
+      end
+    end
+    send :include, InstanceMethods
+
+    module RecursivelyInherited
+      def inherited other
+        super
+      ensure
+        (Table.list << other).uniq!
+        basename = other.name.split(%r/::/).last.underscore
+        Table.singleton_class{ attribute basename => other }
+        other.send :extend, RecursivelyInherited
+      end
+    end
+    send :extend, RecursivelyInherited
+
+#
+# table classes
+#
+    class Job < Table
+      set_table_name "bj_job"
+      set_primary_key "#{ table_name }_id"
+
+      migration { 
+        define_method :up do
+          create_table table.table_name, :primary_key => table.primary_key, :force => true do |t|
+            t.column "command"      , :text
+
+            t.column "state"        , :text
+            t.column "priority"     , :integer
+            t.column "tag"          , :text
+
+            t.column "submitter"    , :text
+            t.column "runner"       , :text
+            t.column "pid"          , :integer
+
+            t.column "submitted_at" , :datetime
+            t.column "started_at"   , :datetime
+            t.column "finished_at"  , :datetime
+
+            t.column "env"          , :text
+            t.column "stdin"        , :text
+            t.column "stdout"       , :text
+            t.column "stderr"       , :text
+            t.column "exit_status"  , :integer
+          end
+        end
+
+        define_method :down do
+          drop_table table.table_name 
+        end
+      }
+
+      module ClassMethods
+        def submit jobs, options = {}, &block
+          jobs = Joblist.for jobs, options
+          returned = []
+          transaction do
+            jobs.each do |job|
+              job = create_hash_for(job.reverse_merge(submit_defaults))
+              job = create! job 
+              returned << (block ? block.call(job) : job)
+            end
+          end
+          returned
+        end
+
+        def submit_defaults
+          {
+            :state => "pending",
+            :priority => 0,
+            :tag => "",
+            :submitter => Bj.hostname,
+            :submitted_at => Time.now, 
+          }
+        end
+      end
+      send :extend, ClassMethods
+
+      module InstanceMethods
+        def finished
+          reload
+          exit_status
+        end
+        alias_method "finished?", "finished"
+      end
+      send :include, InstanceMethods
+    end
+
+    class JobArchive < Job
+      set_table_name "bj_job_archive"
+      set_primary_key "#{ table_name }_id"
+
+      migration {
+        define_method(:up) do
+          create_table table.table_name, :primary_key => table.primary_key, :force => true do |t|
+            t.column "command"      , :text
+
+            t.column "state"        , :text
+            t.column "priority"     , :integer
+            t.column "tag"          , :text
+
+            t.column "submitter"    , :text
+            t.column "runner"       , :text
+            t.column "pid"          , :integer
+
+            t.column "submitted_at" , :datetime
+            t.column "started_at"   , :datetime
+            t.column "finished_at"  , :datetime
+            t.column "archived_at"  , :datetime
+
+            t.column "env"          , :text
+            t.column "stdin"        , :text
+            t.column "stdout"       , :text
+            t.column "stderr"       , :text
+            t.column "exit_status"  , :integer
+          end
+        end
+
+        define_method(:down) do
+          drop_table table.table_name
+        end
+      }
+    end
+
+  # TODO - initialize with a set of global defaults and fallback to those on perhaps '* * key'
+    class Config < Table
+      set_table_name "bj_config"
+      set_primary_key "#{ table_name }_id"
+
+      migration {
+        define_method(:up) do
+          create_table table.table_name, :primary_key => table.primary_key, :force => true do |t|
+            t.column "hostname"      , :text
+            t.column "key"           , :text
+            t.column "value"         , :text
+            t.column "cast"          , :text
+          end
+
+          add_index table.table_name, %w[ hostname key ], :unique => true
+        end
+
+        define_method(:down) do
+          remove_index table.table_name, :column => %w[ hostname key ] 
+          drop_table table.table_name
+        end
+      }
+
+      module ClassMethods
+        def [] key
+          get key
+        end
+
+        def get key, options = {}
+          transaction do
+            options.to_options!
+            hostname = options[:hostname] || Bj.hostname
+            record = find :first, :conditions => conditions(:key => key, :hostname => hostname) 
+            record ? record.value : default_for(key) 
+          end
+        end
+
+        def conditions options = {}
+          options.to_options!
+          options.reverse_merge!(
+            :hostname => Bj.hostname
+          )
+          options
+        end
+
+        def default_for key
+          record = find :first, :conditions => conditions(:key => key, :hostname => '*')
+          record ? record.value : nil 
+        end
+
+        def []= key, value
+          set key, value
+        end
+
+        def set key, value, options = {}
+          transaction do
+            options.to_options!
+            hostname = options[:hostname] || Bj.hostname
+            record = find :first, :conditions => conditions(:key => key, :hostname => hostname) 
+            cast = options[:cast] || cast_for(value)
+            key = key.to_s
+            value = value.to_s
+            if record
+              record["value"] = value
+              record["cast"] = cast
+              record.save!
+            else
+              create! :hostname => hostname, :key => key, :value => value, :cast => cast
+            end
+            value
+          end
+        end
+
+        def delete key
+          transaction do
+            record = find :first, :conditions => conditions(:key => key) 
+            if record
+              record.destroy
+              record
+            else
+              nil
+            end
+          end
+        end
+
+        def has_key? key
+          record = find :first, :conditions => conditions(:key => key)
+          record ? record : false
+        end
+        alias_method "has_key", "has_key?"
+
+        def keys
+          find(:all, :conditions => conditions).map(&:key)
+        end
+
+        def values
+          find(:all, :conditions => conditions).map(&:value)
+        end
+
+        def for options = {}
+          oh = OrderedHash.new
+          find(:all, :conditions => conditions(options)).each do |record|
+            oh[record.key] = record.value
+          end
+          oh
+        end
+
+        def cast_for value
+          case value
+            when TrueClass, FalseClass
+              'to_bool'
+            when NilClass
+              'to_nil'
+            when Fixnum, Bignum
+              'to_i'
+            when Float
+              'to_f'
+            when Time
+              'to_time'
+            when Symbol
+              'to_sym'
+            else
+              case value.to_s
+                when %r/^\d+$/
+                  'to_i'
+                when %r/^\d+\.\d+$/
+                  'to_f'
+                when %r/^nil$|^$/
+                  'to_nil'
+                when %r/^true|false$/
+                  'to_bool'
+                else
+                  'to_s'
+              end
+          end
+        end
+
+        def casts
+          @casts ||= {
+            'to_bool' => lambda do |value|
+              value.to_s =~ %r/^true$/i ? true : false
+            end,
+            'to_i' => lambda do |value|
+              Integer value.to_s.gsub(%r/^(-)?0*/,'\1')
+            end,
+            'to_f' => lambda do |value|
+              Float value.to_s.gsub(%r/^0*/,'')
+            end,
+            'to_time' => lambda do |value|
+              Time.parse(value.to_s)
+            end,
+            'to_sym' => lambda do |value|
+              value.to_s.to_sym
+            end,
+            'to_nil' => lambda do |value|
+              value.to_s =~ %r/^nil$|^$/i ? nil : value.to_s 
+            end,
+            'to_s' => lambda do |value|
+              value.to_s
+            end,
+          }
+        end
+      end
+      send :extend, ClassMethods
+
+      module InstanceMethods
+        def value 
+          self.class.casts[cast][self["value"]]
+        end
+      end
+      send :include, InstanceMethods
+    end
+  end
+end