ahoward-helene 0.0.3

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

@@ -0,0 +1,123 @@
+module Helene
+  module Sdb
+    class Base
+      class Type
+        type(:string){
+          ruby_to_sdb do |value|
+            value.to_s
+          end
+
+          sdb_to_ruby do |value|
+            Array(value).first.to_s
+          end
+        }
+
+        type(:symbol){
+          ruby_to_sdb do |value|
+            value.to_s.to_sym.to_s
+          end
+
+          sdb_to_ruby do |value|
+            Array(value).first.to_s.to_sym
+          end
+        }
+
+        type(:timestamp){
+          ruby_to_sdb do |value|
+            Time.parse(value.to_s).utc.iso8601(2)
+          end
+
+          sdb_to_ruby do |value|
+            Time.parse(Array(value).first.to_s).localtime
+          end
+        }
+
+        type(:boolean){
+          ruby_to_sdb do |value|
+            (!!value).to_s
+          end
+
+          sdb_to_ruby do |value|
+            Array(value).first.to_s =~ %r/^\s*t/i ? true : false
+          end
+        }
+
+        type(:number){
+          ruby_to_sdb do |value|
+            number = Integer(value.to_s)
+            raise ArgumentError, "(#{ name } = #{ number.inspect }) < 0" if number < 0
+            INT_FMT % number
+          end
+
+          sdb_to_ruby do |value|
+            Integer(Array(value).first.to_s.sub(%r/^[0-]+/,''))
+          end
+        }
+
+        type(:integer){
+          ruby_to_sdb do |value|
+            number = Integer(value.to_s)
+            offset = number + Type::INT_OFF
+            if(offset < 0 || offset.class != Fixnum)
+              raise(
+                ArgumentError,
+                "(#{ name } = #{ number.inspect } (offset=#{ offset })) too small"
+              )
+            end
+            INT_FMT % offset
+          end
+
+          sdb_to_ruby do |array|
+            offset = Integer([array].flatten.first.to_s.sub(%r/^[0-]+/,''))
+            number = offset - Type::INT_OFF
+          end
+        }
+
+        type(:sti){
+          ruby_to_sdb do |value|
+            value.to_s
+          end
+
+          sdb_to_ruby do |value|
+            Array(value).first.to_s
+          end
+        }
+
+        type(:url){
+          ruby_to_sdb do |value|
+            value.to_s.sub(%r{\A(?!\w+:)(?=\S)}, "http://")
+          end
+
+          sdb_to_ruby do |value|
+            Array(value).first.to_s
+          end
+        }
+
+        type(:text){
+          ruby_to_sdb do |value|
+            chunks = value.to_s.scan(%r/.{1,1019}/) # 1024 - '1024:'.size
+            i = -1
+            fmt = '%04d:'
+            chunks.map!{|chunk| [(fmt % (i += 1)), chunk].join}
+            raise ArgumentError, 'that is just too big yo!' if chunks.size >= 256
+            chunks
+          end
+
+          sdb_to_ruby do |value|
+            chunks =
+              Array(value).flatten.map do |chunk|
+                index, text = chunk.split(%r/:/, 2)
+                [Float(index).to_i, text]
+              end
+            chunks.replace chunks.sort_by{|index, text| index}
+            chunks.map!{|index, text| text}.join
+          end
+
+          to_condition do |value|
+            value.to_s
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+module Helene
+  module Sdb
+    class Base
+      module Validations
+        class Error < StandardError
+          attr :object
+
+          def initialize(object, *args, &block)
+            @object = object
+            args.unshift object.errors.message if args.empty?
+            super(*args, &block)
+          end
+
+          def errors
+            object.errors
+          end
+        end
+
+        def self.included(c)
+          super
+          c.extend ClassMethods
+        end
+        
+        def errors
+          if(not defined?(@errors) or @errors.nil?)
+            @errors ||= Errors.new(self)
+          end
+          @errors
+        end
+
+        def validate
+          errors.clear
+          self.class.validate(self)
+        end
+
+        def validate!
+          errors.clear
+          self.class.validate!(self)
+        end
+
+        def valid?
+          validate
+          errors.empty?
+        end
+
+        def errors?
+          not valid?
+        end
+
+        class Errors < ::Hash
+          attr_accessor :object
+
+          class << Errors
+          end
+
+          def initialize object = nil
+            @object = object
+            block = lambda{|h,k| h[k] = []}
+            super(&block)
+          end
+
+          def Errors._load(string)
+            new.update(Marshal.load(string))
+          end
+
+          def _dump(*a)
+            Marshal.dump({}.update(to_hash))
+          end
+          
+          def count
+            size
+          end
+          
+          def on(att)
+            self[att]
+          end
+          
+          def add(att, msg)
+            self[att] << msg
+          end
+          
+          def full_messages
+            inject([]) do |m, kv| att, errors = *kv
+              errors.each {|e| m << "#{att} #{e}"}
+              m
+            end
+          end
+
+          def message
+            full_messages.join(' | ')
+          end
+        end
+        
+        class Validation
+          def initialize(on = :save, &validation)
+            @on         = (on || :save).to_sym
+            @validation = validation || lambda { |o, att, v|  }
+          end
+          
+          attr_reader :on
+          
+          def call(o, att, v)
+            save_type = o.new_record? ? :create : :update
+            @validation[o, att, v] if [:save, save_type].include?(on)
+          end
+          alias_method :[], :call
+        end
+        
+        module ClassMethods
+          def validations
+            @validations ||= Hash.new {|h, k| h[k] = []}
+          end
+
+          def has_validations?
+            !validations.empty?
+          end
+
+          def validate(o)
+            if superclass.respond_to?(:validate) && !@skip_superclass_validations
+              superclass.validate(o)
+            end
+            validations.each do |att, procs|
+              v = o.send(att)
+              procs.each {|p| p[o, att, v]}
+            end
+            o
+          end
+
+          def validate!(o)
+            validate(o)
+            raise Error.new(o, o.errors.message) unless o.errors.empty?
+            o
+          end
+          
+          def skip_superclass_validations
+            @skip_superclass_validations = true
+          end
+          
+          def validates_each(*atts, &block)
+            options = atts.extract_options!.to_options!
+            atts.each {|a| validations[a] << Validation.new(options[:on], &block)}
+          end
+
+          def validates(a, options = Hash.new, &block)
+            curried = Validation.new(options[:on]) {|record, attr, value| block.call(record, value)}
+            validations[a] << curried
+          end
+
+          def validates_acceptance_of(*atts)
+            opts = {
+              :message => 'is not accepted',
+              :allow_nil => true,
+              :accept => '1'
+            }.merge!(atts.extract_options!)
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+              o.errors[a] << opts[:message] unless v == opts[:accept]
+            end
+          end
+
+          def validates_confirmation_of(*atts)
+            opts = {
+              :message => 'is not confirmed',
+            }.merge!(atts.extract_options!)
+            
+            atts.each { |a| attr_accessor :"#{a}_confirmation" }
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+              c = o.send(:"#{a}_confirmation")
+              o.errors[a] << opts[:message] unless v == c
+            end
+          end
+
+          def validates_format_of(*atts)
+            opts = {
+              :message => 'is invalid',
+            }.merge!(atts.extract_options!)
+            
+            unless opts[:with].is_a?(Regexp)
+              raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
+            end
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+              o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
+            end
+          end
+
+          def validates_length_of(*atts)
+            opts = {
+              :too_long     => 'is too long',
+              :too_short    => 'is too short',
+              :wrong_length => 'is the wrong length'
+            }.merge!(atts.extract_options!)
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+              if m = opts[:maximum]
+                o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
+              end
+              if m = opts[:minimum]
+                o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
+              end
+              if i = opts[:is]
+                o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
+              end
+              if w = opts[:within]
+                o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+              end
+            end
+          end
+
+          NUMBER_RE = /^\d*\.{0,1}\d+$/ unless defined?(NUMBER_RE)
+          INTEGER_RE = /\A[+-]?\d+\Z/ unless defined?(INTEGER_RE)
+
+          def validates_numericality_of(*atts)
+            opts = {
+              :message => 'is not a number',
+            }.merge!(atts.extract_options!)
+            
+            re = opts[:only_integer] ? INTEGER_RE : NUMBER_RE
+            number = lambda do |value|
+              Float(value) rescue Integer(value) rescue false
+            end
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+              #o.errors[a] << opts[:message] unless v.to_s =~ re
+              o.errors[a] << opts[:message] unless number[v]
+            end
+          end
+
+          def validates_presence_of(*atts)
+            opts = {
+              :message => 'is not present',
+            }.merge!(atts.extract_options!)
+            
+            args = atts + [{:on => opts[:on]}]
+            validates_each(*args) do |o, a, v|
+              o.errors[a] << opts[:message] unless v && !v.blank?
+            end
+          end
+        end
+      end
+
+      include Validations
+    end
+  end
+end

data/lib/helene/sdb/cast.rb

@@ -0,0 +1,114 @@
+module Helene
+  module Sdb
+    module Cast
+      def self.export m
+        module_function m
+        public m
+      end
+
+      List = []
+
+      def self.cast m, &b
+        define_method m, &b
+        export m
+        List << m.to_s
+      end
+
+      cast :boolean do |obj|
+        obj = [obj].flatten.first.to_s
+        case obj
+          when %r/^(true|t|1)$/ 
+            true
+          when %r/^(false|f|0)$/ 
+            false
+          else
+            !!obj
+        end
+      end
+
+      cast :integer do |obj|
+        obj = [obj].flatten.first.to_s
+        Integer(obj)
+      end
+
+      cast :float do |obj|
+        obj = [obj].flatten.first.to_s
+        Float(obj)
+      end
+
+      cast :number do |obj|
+        obj = [obj].flatten.first.to_s
+        Float(obj) rescue Integer(obj)
+      end
+
+      cast :string do |obj|
+        obj = [obj].flatten.first.to_s
+        String(obj)
+      end
+
+      cast :symbol do |obj|
+        obj = [obj].flatten.first.to_s
+        String(obj).to_sym
+      end
+
+      cast :uri do |obj|
+        require 'uri'
+        obj = [obj].flatten.first.to_s
+        ::URI.parse(obj)
+      end
+
+      cast :time do |obj|
+        require 'time'
+        obj = [obj].flatten.first.to_s
+        ::Time.parse(obj)
+      end
+
+      cast :date do |obj|
+        obj = [obj].flatten.first.to_s
+        require 'date'
+        ::Date.parse(obj)
+      end
+
+      cast :list do |*objs|
+        [*objs].flatten.join(',').split(/,/)
+      end
+
+# add list_of_xxx methods
+      List.dup.each do |type|
+        next if type.to_s =~ %r/list/ 
+        m = "list_of_#{ type }"
+        define_method m do |*objs|
+          list(*objs).map{|obj| send type, obj}
+        end
+        export m 
+        List << m
+      end
+
+# add list_of_xxx_from_file
+      List.dup.each do |type|
+        next if type.to_s =~ %r/list/ 
+        m = "list_of_#{ type }"
+        define_method m do |*objs|
+          list(*objs).map{|obj| send type, obj}
+        end
+        export m 
+        List << m
+      end
+
+      def Cast.for(sym)
+        prefix = sym.to_s.downcase.to_sym
+        candidates = List.select{|m| m =~ %r/^#{ prefix }/i}
+        m = candidates.shift
+        raise ArgumentError, "unsupported cast: #{ sym.inspect } (#{ List.join ',' })" unless
+          m
+        raise ArgumentError, "ambiguous cast: #{ sym.inspect } (#{ List.join ',' })" unless
+          candidates.empty? or m.to_s == sym.to_s
+        this = self
+        lambda{|obj| method(m).call obj}
+      end
+      def self.[] sym
+        Cast.for(sym)
+      end
+    end
+  end
+end