ahoward-helene 0.0.3

data/lib/helene/sdb/base/attributes.rb

@@ -0,0 +1,90 @@
+module Helene
+  module Sdb
+    class Base
+      class Attribute
+        attr_accessor 'base'
+        attr_accessor 'name'
+        attr_accessor 'type'
+        attr_accessor 'nilable'
+        attr_accessor 'default'
+        attr_accessor 'has_default'
+        alias_method 'has_default?', 'has_default'
+
+        def initialize(*args, &block)
+          options = args.extract_options!.to_options!
+
+          @base = args.shift || raise(ArgumentError, 'no base')
+
+          @name = args.shift || raise(ArgumentError, 'no name')
+          @name = @name.to_s
+
+          type = args.empty? ? (options[:type]||:string) : args.shift.to_s.to_sym
+
+          @type = Type.for(type) || raise(ArgumentError, {:type => type}.inspect)
+
+          not_nilable = [:nil, :null, :nilable, :nullable].any?{|k| options[k]==false} 
+          @nilable = !not_nilable
+
+          @default = options[:default]
+          @has_default = options.has_key?(:default)
+
+          code = <<-__
+            def #{ name }()
+              attributes[#{ name.inspect }]
+            end
+            alias_method #{ name.inspect }+'?', #{ name.inspect }
+            def #{ name }=(value)
+              attributes[#{ name.inspect }]=value
+            end
+            if not #{ @nilable }
+              validates_presence_of #{ name.inspect }
+            end
+          __
+
+          @base.module_eval(code, __FILE__, __LINE__)
+        end
+
+        def initialize_record(record)
+          unless record.attributes.has_key?(name)
+            value =
+              if has_default?
+                default.respond_to?(:call) ? record.instance_eval(&default) : default
+              else
+                nil
+              end
+            record.attributes[name] = value
+          end
+
+          if type.sti?
+            record.attributes[name] = record.class.name
+          end
+        end
+      end
+
+      class << Base
+        def attributes_table
+          @attributes_table ||= (Base==self ? SuperHash.new() : SuperHash.new(superclass.attributes_table))
+          #@attributes_table ||= (Base==self ? Array.fields() : superclass.attributes_table.clone)
+        end
+
+        def attributes
+          attributes_table.values
+        end
+
+        def attribute(*args, &block)
+          attribute = Attribute.new(self, *args, &block)
+          attributes_table[attribute.name] = attribute
+        end
+
+        def attribute_for(name)
+          attributes_table[name.to_s]
+        end
+
+        def type_for(name)
+          name = name.to_s
+          attributes_table[name].type if attributes_table.has_key?(name)
+        end
+      end
+    end
+  end
+end

data/lib/helene/sdb/base/connection.rb

@@ -0,0 +1,20 @@
+module Helene
+  module Sdb
+    class Base
+      class << Base
+        def connections(&block)
+          Sdb.connections(&block)
+        end
+
+        def connection
+          Sdb.connection
+        end
+      end
+
+      def connection
+        self.class.connection
+      end
+
+    end
+  end
+end

data/lib/helene/sdb/base/error.rb

@@ -0,0 +1,20 @@
+module Helene
+  module Sdb
+    class Base
+      class Error < Helene::Error; end
+      class RecordNotFound < Error; end
+      class RecordInvalid < Error; end
+      class RecordNotSaved < Error; end
+
+      class << Base
+        def error!(message)
+          raise Error.new(message.to_s)
+        end
+      end
+
+      def error!(message)
+        self.class.error!(message)
+      end
+    end
+  end
+end

data/lib/helene/sdb/base/hooks.rb

@@ -0,0 +1,82 @@
+module Helene
+  module Sdb
+    class Base
+      HOOKS = [
+        :before_initialize,
+        :after_initialize,
+        :before_load,
+        :after_load,
+        :before_create,
+        :after_create,
+        :before_update,
+        :after_update,
+        :before_validation,
+        :after_validation,
+        :before_save,
+        :after_save,
+        :before_destroy,
+        :after_destroy,
+        :before_delete,
+        :after_delete
+      ] unless defined?(HOOKS)
+
+      class << Base
+        unless defined?(HOOK_METHOD_AFTER_ASSOCIATION_WARNING)
+          HOOK_METHOD_AFTER_ASSOCIATION_WARNING = <<-__
+            *IMPORTANT:* In order for inheritance to work for the callback
+            queues, you must specify the callbacks before specifying the
+            associations. Otherwise, you might trigger the loading of a child
+            before the parent has registered the callbacks and they won’t be
+            inherited.
+          __
+        end
+
+        # Some fancy code generation here in order to define the hook class methods...
+        unless defined?(HOOK_METHOD_STR)
+          HOOK_METHOD_STR = <<-__ 
+            def Base.%s(method = nil, &block)
+              unless block
+                (raise Error, 'No hook method specified') unless method
+                block = lambda {send method}
+              end
+              add_hook(%s, &block)
+            end
+          __
+        end
+        
+        def def_hook_method(m) #:nodoc:
+          instance_eval(HOOK_METHOD_STR % [m.to_s, m.inspect])
+        end
+        
+        # Returns the hooks hash for the model class.
+        def hooks #:nodoc:
+          @hooks ||= Hash.new {|h, k| h[k] = []}
+        end
+
+        def hooks= hooks
+          @hooks = hooks
+        end
+        
+        def add_hook(hook, &block) #:nodoc:
+          chain = hooks[hook]
+          chain << block
+          define_method(hook) do 
+            return false if super == false
+            chain.each {|h| break false if instance_eval(&h) == false}
+          end
+        end
+
+        # Returns true if the model class or any of its ancestors have defined
+        # hooks for the given hook key. Notice that this method cannot detect 
+        # hooks defined using overridden methods.
+        #def has_hooks?(key)
+          #has = hooks[key] && !hooks[key].empty?
+          #has || ((self != Base) && superclass.has_hooks?(key))
+        #end
+      end
+
+      HOOKS.each {|h| define_method(h) {}}
+      HOOKS.each {|h| def_hook_method(h)}
+    end
+  end
+end

data/lib/helene/sdb/base/literal.rb

@@ -0,0 +1,52 @@
+module Helene
+  module Sdb
+    class Base
+      class Literal < ::String
+        def Literal.for(*args)
+          new(args.join).freeze
+        end
+        def literal?
+          true
+        end
+        def literal
+          self
+        end
+        def inspect
+          "#{ self.class.name }(#{ string.inspect })"
+        end
+        def string
+          "#{ self }"
+        end
+      end
+
+      class << Base
+        def literal(*args)
+          Literal.for(*args)
+        end
+        def Literal(*args)
+          Literal.for(*args)
+        end
+        def literal?(*args)
+          args.all?{|arg| Literal === arg}
+        end
+        def Literal?(*args)
+          args.all?{|arg| Literal === arg}
+        end
+      end
+
+
+      def literal(*args)
+        Literal.for(*args)
+      end
+      def Literal(*args)
+        Literal.for(*args)
+      end
+      def literal?(*args)
+        args.all?{|arg| Literal === arg}
+      end
+      def Literal?(*args)
+        args.all?{|arg| Literal === arg}
+      end
+    end
+  end
+end

data/lib/helene/sdb/base/logging.rb

@@ -0,0 +1,23 @@
+module Helene
+  module Sdb
+    class Base
+      class << Base
+        def logger
+          Helene.logger
+        end
+
+        def log(*args, &block)
+          Helene.log(*args, &block)
+        end
+      end
+
+      def logger
+        Helene.logger
+      end
+
+      def log(*args, &block)
+        Helene.log(*args, &block)
+      end
+    end
+  end
+end

data/lib/helene/sdb/base/transactions.rb

@@ -0,0 +1,53 @@
+module Helene
+  module Sdb
+    class Base
+      module Transaction
+        attr_writer :id
+        attr_writer :time
+
+        def call(*args, &block)
+          return block.call() if id?
+          @id = generate_id
+          @time = Time.now.utc
+          begin
+            block.call()
+          ensure
+            @id = @time = nil
+          end
+        end
+
+        def id?
+          defined?(@id) and @id
+        end
+
+        def id
+          id? ? @id : generate_id
+        end
+
+        def generate_id
+          UUID.timestamp_create().to_s
+        end
+
+        def time?
+          defined?(@time) and @time
+        end
+
+        def time
+          time? ? @time : Time.now.utc
+        end
+
+        extend self
+      end
+
+      class << Base
+        def transaction(&block)
+          Transaction.call(&block)
+        end
+      end
+
+      def transaction(&block)
+        self.class.transaction.call(&block)
+      end
+    end
+  end
+end

data/lib/helene/sdb/base/type.rb

@@ -0,0 +1,137 @@
+module Helene
+  module Sdb
+    class Base
+      class Type
+        unless defined?(INT_FMT)
+          INT_N_BYTES  = [42].pack('i').size
+          INT_N_BITS   = INT_N_BYTES * 8
+          INT_MAX      = 2 ** (INT_N_BITS - 2) - 1
+          INT_MIN      = -INT_MAX - 1
+          INT_OFF      = INT_MAX / 2
+          INT_MAX_SIZE = INT_MAX.to_s.size
+          INT_MIN_SIZE = INT_MAX.to_s.size
+          INT_SIZE     = [INT_MAX_SIZE, INT_MIN_SIZE].max
+          INT_FMT      = "%0#{ INT_SIZE }d"
+        end
+
+        class << Type
+          def ruby_to_sdb(value)
+            value==nil ? Sentinel.Nil : value
+          end
+
+          def sdb_to_ruby(value)
+            value==Sentinel.Nil ? nil : value
+          end
+
+          def to_condition(value)
+            value==nil ? Sentinel.Nil : value
+          end
+
+          def ruby_to_sdb_for(&block)
+            block ||= lambda{|value| value}
+            lambda{|value| value==nil ? Sentinel.Nil : block.call(value)}
+          end
+
+          def sdb_to_ruby_for(&block)
+            block ||= lambda{|value| value}
+            lambda{|value| value==Sentinel.Nil ? nil : block.call(value)}
+          end
+
+          def to_condition_for(&block)
+            block ||= lambda{|value| value}
+            lambda{|value| value==nil ? Sentinel.Nil : block.call(value)}
+          end
+
+          def array_of_string value
+            [value].flatten.map{|val| val.to_s}
+          end
+
+          def format(&block)
+            define_method(:format, &block)
+          end
+
+          def list
+            @list ||= Array.fields
+          end
+          
+          def for name
+            list[name.to_s.underscore]
+          end
+
+          def listify(*list)
+            [list].join(',').strip.split(%r/\s*,\s*/)
+          end
+
+          def name
+            @name ||= super
+          end
+          attr_writer :name
+
+          def type(name, *args, &block)
+            name = name.to_s.underscore
+            type = new(name, &block)
+            list[type.name] = type
+
+            ["set_of_#{ name.singularize }", "set_of_#{ name.pluralize }"].uniq.each do |set_of_name|
+              set_of_type =
+                new(set_of_name) do
+                  ruby_to_sdb do |values|
+                    values = Array(values).flatten
+                    values.each{|value| type.ruby_to_sdb(value)}
+                  end
+                  sdb_to_ruby do |values|
+                    values = Array(values).flatten
+                    values.each{|value| type.sdb_to_ruby(value)}
+                  end
+                end
+              list[set_of_type.name] = set_of_type
+            end
+
+            type
+          end
+          alias_method 'register_type', 'type'
+        end
+
+      # instance methods
+      #
+        attr_accessor :name
+
+        def initialize name, &block
+          @name = name
+          @ruby_to_sdb = Type.method(:ruby_to_sdb).to_proc
+          @sdb_to_ruby = Type.method(:sdb_to_ruby).to_proc
+          @to_condition = nil
+          instance_eval(&block)
+        end
+
+        def ruby_to_sdb(value=nil, &block)
+          if block
+            @ruby_to_sdb = Type.ruby_to_sdb_for(&block)
+          else
+            @ruby_to_sdb.call(value)
+          end
+        end
+
+        def sdb_to_ruby(value=nil, &block)
+          if block
+            @sdb_to_ruby = Type.sdb_to_ruby_for(&block)
+          else
+            @sdb_to_ruby.call(value)
+          end
+        end
+
+        def to_condition(value=nil, &block)
+          if block
+            @to_condition = Type.to_condition_for(&block)
+          else
+            (@to_condition || @ruby_to_sdb).call(value)
+          end
+        end
+
+        def sti?
+          name == 'sti'
+        end
+      end
+    end
+  end
+end