rapid-core 0.1

data/lib/rapid/setting/instance_hash.rb

@@ -0,0 +1,132 @@
+module Rapid
+  module Setting
+    
+    class InstanceHash
+      
+      attr_reader :delegate, :klass, :assignment_exceptions
+      
+      delegate :empty?, :to => :delegate
+      delegate :each,   :to => :delegate
+      delegate :keys,   :to => :delegate
+      delegate :values, :to => :delegate
+      delegate :to_hash, :to => :delegate
+      
+      def initialize klass, hash = {}
+        @klass = klass
+        
+        @delegate = HashWithIndifferentAccess.new hash
+        @assignment_exceptions = HashWithIndifferentAccess.new
+        load_defaults
+        load_namespaces
+      end
+      
+      def [] key
+        @delegate[key]
+      end
+      
+      def []= full_name, value
+        namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+        
+        if namespace_name
+          load_nested_value namespace_name, child_name, value
+          value
+        else
+          new_value = load_base_value full_name, value
+          @delegate[full_name] = new_value
+        end
+      end
+      
+      def namespaces
+        values = self.values.delete_if {|v| not v.is_a? Namespace::Instance }
+        values
+      end
+      
+      def to_hash
+        hash = {}
+        @delegate.each do |key, value|
+          if value.is_a? Namespace::Instance
+            hash[key] = value.to_hash
+          else
+            hash[key] = value
+          end
+        end
+        hash
+      end
+      
+      protected
+      
+      def load_nested_value namespace_name, child_name, value
+        class_setting = @klass[namespace_name]
+        if class_setting.nil?
+          raise Rapid::UnknownSettingError.new(namespace_name)
+          
+        elsif !class_setting.is_a?(Namespace::Base)
+          raise Rapid::InvalidSettingError.new(class_setting, value)
+        end
+        
+        namespace = @delegate[namespace_name]
+        namespace[child_name] = value
+        return child_name, value
+        
+      rescue UnknownSettingError => e
+        @assignment_exceptions[namespace_name] = e
+        nil
+      rescue InvalidSettingError => e
+        @assignment_exceptions[namespace_name] = e
+        nil
+      end
+      
+      def load_base_value name, value
+        class_setting = @klass[name]
+        if class_setting.nil?
+          raise Rapid::UnknownSettingError.new(name)
+        end
+        
+        if class_setting.is_a? Namespace::Base
+          value[:empty] = false if value.is_a? Hash
+          result = load_namespace class_setting, value
+        else
+          result = class_setting.load value
+        end
+        
+        @assignment_exceptions.delete name
+        result
+        
+      rescue UnknownSettingError => e
+        @assignment_exceptions[name] = e
+        nil
+      rescue InvalidSettingError => e
+        @assignment_exceptions[name] = e
+        nil
+      end
+      
+      def load_defaults
+        @klass.scalars.each do |scalar|
+          unless @delegate.has_key? scalar.name
+            @delegate[scalar.name] = scalar.default_value unless scalar.default_value.nil?
+          end
+        end
+      end
+      
+      def load_namespaces
+        return unless @klass.respond_to? :namespaces
+        
+        @klass.namespaces.each do |namespace|
+          value = @delegate[namespace.name] || {}
+          instance = load_namespace namespace, value
+          @delegate[namespace.name] = instance
+        end
+      end
+      
+      def load_namespace namespace, value
+        value = {:empty => true}  if value == nil || value == false
+        value = {:empty => false} if value == true
+        value[:owner] = _root if value.is_a?(Hash) && respond_to?(:_root)
+        namespace.load value
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rapid/setting/instance_root.rb

@@ -0,0 +1,107 @@
+module Rapid
+  module Setting
+    
+    class InstanceRoot < InstanceHash
+      
+      include ActiveModel::Validations
+      validate :validate_no_assignment_exceptions
+      validate :validate_nested_settings
+      
+      attr_reader :_root
+      
+      def initialize klass, owner = nil, hash = {}
+        @_root = owner
+        super klass, hash
+      end
+      
+      def get_binding
+        binding
+      end
+      
+      def [] full_name
+        namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+        
+        if namespace_name.nil?
+          super
+        else
+          namespace = @delegate[namespace_name]
+          namespace[child_name] if namespace
+        end
+      end
+      
+      def set? full_name
+        value = self[full_name]
+        
+        if Setting::Namespace::Instance === value
+          !value.empty?
+        else
+          value != nil && value != false
+        end
+      end
+      
+      def load_yaml yaml_content
+        hash = parse_yaml yaml_content
+        
+        # yaml was empty
+        return true if hash == false
+        
+        load_hash hash
+      end
+      
+      def load_hash hash
+        hash.each do |name, value|
+          self[name] = value
+        end
+        
+        true
+      end
+      
+      def to_yaml
+        dot_hash = to_dot_hash
+        
+        if dot_hash.empty?
+          ""
+        else
+          Settings.clean_yaml dot_hash.to_yaml
+        end
+      end
+      
+      def to_dot_hash
+        Rapid::Settings.to_dot_hash to_hash
+      end
+      
+      protected
+      
+      def parse_yaml yaml_content
+        YAML.load yaml_content
+      rescue ArgumentError => e
+        raise Rapid::InvalidYamlError.new(e.message)
+      end
+      
+      def validate_no_assignment_exceptions
+        assignment_exceptions.each do |attribute, error|
+          self.errors.add attribute, error.validation_message
+        end
+        
+        true
+      end
+      
+      def validate_nested_settings
+        namespaces.each do |namespace|
+          next if namespace.valid?
+          
+          namespace.errors.each do |attribute, errors|
+            errors.each do |error| 
+              self.errors.add "#{namespace.klass.name}.#{attribute}", error
+            end
+          end
+        end
+        
+        true
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rapid/setting/integer_setting.rb

@@ -0,0 +1,24 @@
+module Rapid
+  module Setting
+    
+    class IntegerSetting < Base
+      
+      def load value
+        if value.is_a?(String) && !(value =~ /[0-9]+/)
+          raise InvalidSettingError.new(self, value)
+          
+        elsif value.is_a?(Float)
+          raise InvalidSettingError.new(self, value)
+          
+        elsif value.nil?
+          nil
+          
+        else
+          value.to_i
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/setting/namespace/base.rb

@@ -0,0 +1,113 @@
+module Rapid
+  module Setting
+    module Namespace
+      
+      class Base < Setting::Base
+        
+        attr_accessor :delegate, :instance_class, :default_empty
+        
+        delegate :[], :to => :delegate
+        delegate :[]=, :to => :delegate
+        
+        def initialize name, options = {}
+          super
+          @delegate = HashWithIndifferentAccess.new {}
+          @klass = options[:class]
+          @instance_class = define_instance_class if @klass
+          @default_empty = !options[:default] if options.key? :default
+        end
+        
+        def namespaces
+          values = delegate.values
+          values.delete_if {|c| !c.is_a?(Namespace::Base) }
+          values
+        end
+        
+        def scalars
+          values = delegate.values
+          values.delete_if {|c| c.is_a?(Namespace::Base) }
+          values
+        end
+        
+        def load value
+          owner = value.delete :owner if value.is_a? Hash
+          
+          if value != nil && !value.respond_to?(:to_hash)
+            raise InvalidSettingError.new(self, value)
+          end
+          
+          hash = value.to_hash if value
+          
+          if @instance_class
+            @instance_class.new owner, self, hash
+          else
+            Namespace::Instance.new owner, self, hash
+          end
+        end
+        
+        def define_setting setting
+          define_helper_methods_for setting
+          setting.namespace[setting.name] = setting
+          setting
+        end
+        
+        protected
+        
+        def instance_class_name
+          full_name.to_s.gsub('.', '/').camelize.gsub("::", "")
+        end
+        
+        def define_instance_class
+          instance_class = eval %(
+          module #{@klass.name}::Settings
+            class #{instance_class_name} < Namespace::Instance
+              @setting_name = #{name.to_s.inspect}
+              @full_setting_name = #{full_name.to_s.inspect}
+              
+              class << self ; attr_reader :setting_name, :full_setting_name ; end
+              
+              self
+            end
+          end
+          )
+          
+          instance_class
+        end
+        
+        def define_helper_methods_for setting
+          name = setting.name
+          getter = setting.get_helper_name
+          setter = setting.set_helper_name
+          
+          @instance_class.class_eval do
+            define_method getter do
+              self[name]
+            end
+            
+            define_method setter do |value|
+              self[name] = value
+            end
+            
+            if setting.is_a? BooleanSetting
+              define_method "#{getter}?" do
+                self[name] == true
+              end
+            elsif setting.is_a? Namespace::Base
+              define_method "#{getter}?" do
+                self[name] != nil && !self[name].empty?
+              end
+            else
+              define_method "#{getter}?" do
+                self[name] != nil
+              end
+            end
+          end
+          
+          true
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/setting/namespace/instance.rb

@@ -0,0 +1,84 @@
+module Rapid
+  module Setting
+    module Namespace
+      
+      class Instance < Setting::InstanceHash
+        
+        include ActiveModel::Validations
+        validate :validate_nested_settings
+        validate :validate_no_assignment_exceptions
+        
+        attr_reader :_root
+        
+        def initialize root, klass, hash = {}
+          @_root = root
+          
+          if hash.key? :empty
+            @default_empty = hash.delete :empty
+            @hardcoded_empty = @default_empty
+          elsif klass.default_empty != nil
+            @default_empty = klass.default_empty
+          else
+            @default_empty = true
+          end
+          
+          super klass, hash
+        end
+        
+        def root
+          @_root
+        end
+        
+        def empty?
+          return @hardcoded_empty if defined? @hardcoded_empty
+          
+          @delegate.each do |key, value|
+            if value.is_a? Instance
+              return false if not value.empty?
+            else
+              return false if value != nil
+            end
+          end
+          
+          @default_empty
+        end
+        
+        def [] full_name
+          namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+          
+          if namespace_name.nil?
+            super
+          else
+            namespace = @delegate[namespace_name]
+            namespace[child_name] if namespace
+          end
+        end
+        
+        protected
+        
+        def validate_nested_settings
+          namespaces.each do |namespace|
+            next if namespace.valid?
+            
+            namespace.errors.each do |attribute, errors|
+              errors.each do |error|
+                self.errors.add "#{namespace.klass.name}.#{attribute}", error
+              end
+            end
+          end
+          
+          true
+        end
+        
+        def validate_no_assignment_exceptions
+          assignment_exceptions.each do |attribute, error|
+            self.errors.add attribute, error.validation_message
+          end
+          
+          true
+        end
+        
+      end
+    end
+  end
+end

data/lib/rapid/setting/nested_validations.rb

@@ -0,0 +1,86 @@
+module Rapid
+  module Setting
+    
+    module NestedValidations
+      
+      def self.included base
+        base.extend ClassMethods
+        
+        base.class_eval do
+          class << self
+            alias_method_chain :validates_exclusion_of, :nesting
+            alias_method_chain :validates_format_of, :nesting
+            alias_method_chain :validates_inclusion_of, :nesting
+            alias_method_chain :validates_length_of, :nesting
+            alias_method_chain :validates_presence_of, :nesting
+            alias_method_chain :validates_size_of, :nesting
+          end
+        end
+        
+      end
+      
+      protected
+      
+      module ClassMethods
+        
+        def validates_exclusion_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_exclusion_of, args, options
+        end
+        
+        def validates_format_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_format_of, args, options
+        end
+        
+        def validates_inclusion_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_inclusion_of, args, options
+        end
+        
+        def validates_length_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_length_of, args, options
+        end
+        
+        def validates_presence_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_presence_of, args, options
+        end
+        
+        def validates_size_of_with_nesting *args
+          options = args.extract_options!
+          nested_validations :validates_size_of, args, options
+        end
+        
+        def nested_validations validation, attributes, options = {}
+          attributes.each do |attribute|
+            nested_validation validation, attribute, options
+          end
+        end
+        
+        def nested_validation validation, attribute, options = {}
+          names = attribute.to_s.split('.')
+          name = names.pop
+          
+          if names.empty?
+            send "#{validation}_without_nesting", attribute, options
+            return
+          end
+          
+          namespace = setting.find_namespace *names
+          klass = namespace.instance_class if namespace
+          
+          if klass.nil?
+            raise UnknownSettingError.new(attribute)
+          end
+          
+          klass.send validation, name, options
+        end
+        
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/setting/string_setting.rb

@@ -0,0 +1,13 @@
+module Rapid
+  module Setting
+    
+    class StringSetting < Base
+      
+      def load value
+        value.nil? ? nil : value.to_s
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/settings.rb

@@ -0,0 +1,129 @@
+require 'rapid/setting/nested_validations'
+require 'rapid/setting/definer'
+require 'rapid/setting/class_hash'
+require 'rapid/setting/instance_hash'
+require 'rapid/setting/instance_root'
+
+require 'rapid/setting/base'
+require 'rapid/setting/namespace/base'
+require 'rapid/setting/namespace/instance'
+require 'rapid/setting/boolean_setting'
+require 'rapid/setting/string_setting'
+require 'rapid/setting/integer_setting'
+
+require 'rapid/setting/comments'
+
+module Rapid
+  module Settings
+    
+    class << self
+      
+      def reserved_names
+        # ActiveModel::Validations
+        @reserved_words ||= %w(_validate_callbacks _validators errors read_attribute_for_validation 
+          run_callbacks valid validates_acceptance_of validates_confirmation_of validates_exclusion_of 
+          validates_format_of validates_inclusion_of validates_length_of validates_numericality_of 
+          validates_presence_of validates_size_of validates_with validation_context) +
+        
+        # internal
+        %w(_root empty namespaces scalars validate_nested_settings validate_no_assignment_exceptions
+           load_yaml load_hash to_yaml to_dot_hash to_hash parse_yaml get_binding)
+      end
+      
+      def reserved_name? name
+        reserved_names.include? name.to_s
+      end
+      
+      def extract_nested_namespace full_name
+        return nil, nil if full_name.nil?
+        
+        full_name = full_name.to_s
+        if full_name.to_s =~ /^([^\.]+)\.(.+)$/
+          return $1, $2
+        else
+          return nil, full_name
+        end
+      end
+      
+      def clean_yaml yaml
+        yaml.gsub! /^--- \n/, ""
+        yaml.gsub! /\n$/, ""
+        yaml
+      end
+      
+      def to_dot_hash nested_hash
+        dot_hash = {}
+        flatten = proc { |key, value|
+          
+          if value.is_a?(Hash)
+            value.each do |k2, v2|
+              flatten[key + [k2], v2]
+            end
+          else
+            namespace = key.join('.')
+            dot_hash[namespace] = value
+          end
+        }
+        
+        flatten[[], nested_hash]
+        dot_hash
+      end
+      
+    end
+    
+    def self.included base
+      base.send :include, ActiveModel::Validations
+      base.send :include, Rapid::Setting::NestedValidations
+      base.send :include, Rapid::Setting::Comments
+      
+      base.extend ClassMethods
+      
+      base.validate :validate_settings
+      
+      base.delegate :load_yaml,   :to => :settings
+      base.delegate :load_hash,   :to => :settings
+      base.delegate :to_yaml,     :to => :settings
+      base.delegate :to_hash,     :to => :settings
+      base.delegate :to_dot_hash, :to => :settings
+      base.delegate :[],          :to => :settings
+      base.delegate :[]=,         :to => :settings
+      base.delegate :set?,        :to => :settings
+    end
+    
+    def settings
+      @settings ||= Setting::InstanceRoot.new(self.class.settings, self)
+    end
+    
+    def get_binding
+      binding
+    end
+    
+    protected
+    
+    def validate_settings
+      unless settings.valid?
+        settings.errors.each do |attribute, errors|
+          errors.each {|error| self.errors.add attribute, error }
+        end
+      end
+      
+      true
+    end
+    
+    module ClassMethods
+      
+      def settings
+        @settings ||= Setting::ClassHash.new
+      end
+      
+      protected
+      
+      def setting
+        @setting ||= Setting::Definer.new(self)
+      end
+      
+    end
+    
+  end
+  
+end