rapid-core 0.1 → 0.2.1

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

@@ -2,59 +2,225 @@ module Rapid
   module Setting
     module Namespace
       
-      class Instance < Setting::InstanceHash
+      class Instance
         
         include ActiveModel::Validations
         validate :validate_nested_settings
         validate :validate_no_assignment_exceptions
         
-        attr_reader :_root
+        def initialize namespace, parent, value = {}
+          @namespace = namespace
+          @parent = parent
+          @assignment_exceptions = {}
+          @delegate = HashWithIndifferentAccess.new
+          
+          _load value
+          _load_scalar_defaults
+        end
+        
+        def empty?
+          @is_empty
+        end
+        
+        def on?
+          @is_on
+        end
+        alias :on :on?
+        
+        def on= bool
+          _load bool
+          bool
+        end
+        
+        def on!
+          @is_on = true
+        end
         
-        def initialize root, klass, hash = {}
-          @_root = root
+        def set? full_name
+          names = full_name.split('.')
+          name = names.pop
           
-          if hash.key? :empty
-            @default_empty = hash.delete :empty
-            @hardcoded_empty = @default_empty
-          elsif klass.default_empty != nil
-            @default_empty = klass.default_empty
+          namespace = self
+          names.each do |n|
+            namespace = namespace[n] if namespace.is_a?(Namespace::Instance)
+          end
+          
+          value = namespace[name] if namespace.is_a?(Namespace::Instance)
+          
+          if value.is_a?(Namespace::Instance)
+            value.on?
           else
-            @default_empty = true
+            value != nil && value != false
           end
+        end
+        
+        def [] full_name
+          namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
           
-          super klass, hash
+          if namespace_name.nil?
+            setting = @namespace[full_name]
+            if setting
+              @delegate[full_name]
+            elsif respond_to?(full_name)
+              send full_name
+            end
+          else
+            setting = @namespace[namespace_name]
+            namespace = @delegate[namespace_name] if setting
+            namespace[child_name] if namespace
+          end
+        end
+        
+        def []= key, value
+          namespace_name, child_name = Rapid::Settings.extract_nested_namespace(key)
+
+          if namespace_name.nil?
+            _set_base key, value
+          else
+            _set_child namespace_name, child_name, value
+          end
+
+        rescue UnknownSettingError => e
+          @assignment_exceptions[key] = e
+          nil
+        rescue InvalidSettingError => e
+          @assignment_exceptions[key] = e
+          nil
         end
         
-        def root
-          @_root
+        def namespaces
+          values = @delegate.values.delete_if {|v| not v.is_a? Namespace::Instance }
+          values
         end
         
-        def empty?
-          return @hardcoded_empty if defined? @hardcoded_empty
+        def scalars
+          values = @delegate.values.delete_if {|v| v.is_a? Namespace::Instance }
+          values
+        end
+        
+        def to_hash
+          hash = {}
           
           @delegate.each do |key, value|
-            if value.is_a? Instance
-              return false if not value.empty?
+            if value.is_a? Namespace::Instance
+              child = value.to_hash
+              hash[key] = child unless child.empty?
             else
-              return false if value != nil
+              hash[key] = value
             end
           end
           
-          @default_empty
+          hash
         end
         
-        def [] full_name
-          namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+        def to_dot_hash
+          Rapid::Settings.to_dot_hash to_hash
+        end
+        
+        protected
+        
+        def _parent
+          @parent
+        end
+        alias :parent :_parent
+        
+        def _root
+          if @parent.is_a? Namespace::Instance
+            @parent.send :_root
+          else
+            @parent
+          end
+        end
+        alias :root :_root
+        
+        def _load value
+          if value == nil || value == false
+            @is_empty = true
+            @is_on = false
+            value = {}
+            
+          elsif value == true || value.is_a?(Hash)
+            value = {} if value == true
+            
+            @is_on = true
+            @is_empty = value.empty?
+            
+          else
+            raise Rapid::InvalidSettingError.new(@namespace, value)
+          end
           
-          if namespace_name.nil?
-            super
+          _load_namespaces value
+        end
+        
+        def _load_namespaces values
+          @namespace.namespaces.each do |namespace|
+            value = values[namespace.name]
+            instance = @delegate[namespace.name]
+            
+            if instance.nil?
+              klass = namespace.instance_class || Namespace::Instance
+              instance = klass.new namespace, self, value
+              @delegate[namespace.name] = instance
+            else
+              instance.send :_load, value
+            end
+            
+            instance.on = namespace.default_value if value.nil?
+            
+            @delegate[namespace.name] = instance
+          end
+          
+          values.each do |key, value|
+            self[key] = value unless value.is_a?(Namespace::Instance)
+          end
+        end
+        
+        def _load_scalar_defaults
+          @namespace.scalars.each do |scalar|
+            value = @delegate[scalar.name]
+            if value.nil? && scalar.default_value != nil
+              @delegate[scalar.name] = scalar.default_value
+            end
+          end
+        end
+        
+        def _set_base key, value
+          setting = @namespace[key]
+          
+          if setting.is_a? Namespace::Base
+            namespace = @delegate[key]
+            namespace.send :_load, value
+            
+          elsif setting != nil
+            value = setting.load value
+            on! if value != nil && value != false
+            @delegate[key] = value
+            
           else
-            namespace = @delegate[namespace_name]
-            namespace[child_name] if namespace
+            writer = "#{key}="
+            if respond_to?(writer)
+              send writer, value
+            else
+              raise Rapid::UnknownSettingError.new("#{@namespace.full_name}.#{key}")
+            end
           end
         end
         
-        protected
+        def _set_child namespace_name, rest_name, value
+          setting = @namespace[namespace_name]
+          
+          if setting.is_a? Namespace::Base
+            namespace = @delegate[namespace_name]
+            namespace[rest_name] = value
+            
+          elsif setting.is_a? Setting::Base
+            raise Rapid::InvalidSettingError.new(setting, value)
+            
+          else
+            raise Rapid::UnknownSettingError.new("#{@namespace.full_name}.#{namespace_name}")
+          end
+          
+        end
         
         def validate_nested_settings
           namespaces.each do |namespace|
@@ -62,7 +228,8 @@ module Rapid
             
             namespace.errors.each do |attribute, errors|
               errors.each do |error|
-                self.errors.add "#{namespace.klass.name}.#{attribute}", error
+                name = "#{namespace.class.setting_name}.#{attribute}"
+                self.errors.add name, error
               end
             end
           end
@@ -71,7 +238,7 @@ module Rapid
         end
         
         def validate_no_assignment_exceptions
-          assignment_exceptions.each do |attribute, error|
+          @assignment_exceptions.each do |attribute, error|
             self.errors.add attribute, error.validation_message
           end
           

data/lib/rapid/setting/string_setting.rb

@@ -4,7 +4,13 @@ module Rapid
     class StringSetting < Base
       
       def load value
-        value.nil? ? nil : value.to_s
+        if value == nil || value == false
+          nil
+        elsif value.is_a?(Array) || value.is_a?(Hash)
+          raise Rapid::InvalidSettingError.new(self, value)
+        else
+          value.to_s
+        end
       end
       
     end

data/lib/rapid/settings.rb

@@ -1,8 +1,6 @@
+require 'rapid/setting/module'
 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'
@@ -16,61 +14,6 @@ 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
@@ -80,24 +23,67 @@ module Rapid
       
       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)
+      @settings ||= Setting::Namespace::Instance.new(self.class.settings, self)
+    end
+    
+    def settings= settings
+      self.settings.send :_load, settings
     end
     
     def get_binding
       binding
     end
     
+    def [] full_name
+      namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+      
+      if namespace_name.nil?
+        setting = self.class.settings[full_name]
+        if setting
+          settings[full_name]
+        elsif respond_to?(full_name)
+          send full_name
+        else
+          nil
+        end
+      else
+        settings[full_name]
+      end
+    end
+    
+    def []= full_name, value
+      namespace_name, child_name = Rapid::Settings.extract_nested_namespace(full_name)
+      
+      if namespace_name
+        settings[full_name] = value
+        
+      elsif namespace_name.nil?
+        setting = self.class.settings[full_name]
+        if setting
+          settings[full_name] = value
+        else
+          writer = "#{full_name}="
+          if respond_to?(writer)
+            send writer, value
+          else
+            settings[full_name] = value
+          end
+        end
+      end
+    end
+    
+    def load hash
+      hash.each do |key, value|
+        self[key] = value
+      end
+    end
+    
     protected
     
     def validate_settings
@@ -113,7 +99,7 @@ module Rapid
     module ClassMethods
       
       def settings
-        @settings ||= Setting::ClassHash.new
+        @settings ||= Setting::Namespace::Base.new(nil)
       end
       
       protected

data/lib/rapid/skeleton/base.rb

@@ -5,6 +5,8 @@ module Rapid
       
       include ActiveModel::Validations
       
+      include Skeleton::Helpers::IfSetting
+      include Skeleton::Helpers::Files
       include Skeleton::Helpers::Directory
       include Skeleton::Helpers::Gem
       include Skeleton::Helpers::Migration
@@ -13,7 +15,7 @@ module Rapid
       include Skeleton::Helpers::Template
       include Skeleton::Helpers::View
       
-      attr_reader :name, :settings, :project_path, :templates_path
+      attr_reader :name, :check, :settings, :project_path, :templates_path
       
       delegate :get_binding, :to => :settings
       delegate :load_yaml,   :to => :settings
@@ -22,7 +24,6 @@ module Rapid
       delegate :to_hash,     :to => :settings
       delegate :to_dot_hash, :to => :settings
       delegate :[],          :to => :settings
-      delegate :[]=,         :to => :settings
       delegate :set?,        :to => :settings
       
       validate :validate_settings
@@ -32,14 +33,16 @@ module Rapid
         @project_path = options[:project_path] || File.expand_path('.')
         @templates_path = options[:templates_path] || discover_templates_path(options[:file])
         @name = options[:name] || implied_name
+        
+        @check = options[:check] || Rapid::Check.current || Rapid::Check.new("", options)
       end
       
       def settings= hash
-        settings.load_hash hash
+        settings.load hash
       end
       
-      def push!
-        if push
+      def push! settings = nil
+        if push(settings)
           true
         else
           raise Rapid::InvalidSkeletonError.new(errors.full_messages.join(', '))
@@ -48,7 +51,9 @@ module Rapid
         true
       end
       
-      def push
+      def push settings = nil
+        self.settings = settings if settings
+        
         @pushing = true
         is_valid = valid?
         section(name) { bones } if is_valid
@@ -67,9 +72,34 @@ module Rapid
       
       def pull
         @pulling = true
-        !Rapid::Check.encounters_error? { section(name) { bones } }
+        @pulled_settings = []
+        !@check.encounters_error? { section(name) { bones } }
       ensure
         @pulling = false
+        @pulled_settings = nil
+      end
+      
+      def []= key, value
+        # if this is the first time this setting has been set
+        if @pulled_settings.nil? || !@pulled_settings.include?(key)
+          @pulled_settings.push key if @pulled_settings
+          
+          @check.log_value :info, key, value
+          @settings[key] = value
+          
+        else
+          old_value = @settings[key]
+          old_value = old_value.on? if old_value.is_a?(Setting::Namespace::Instance)
+          @settings[key] = value
+          new_value = @settings[key]
+          new_value = new_value.on? if new_value.is_a?(Setting::Namespace::Instance)
+          
+          if old_value == new_value
+            @check.log_value :info, key, value
+          else
+            @check.log_value :warning, key, value
+          end
+        end
       end
       
       protected
@@ -79,11 +109,7 @@ module Rapid
       end
       
       def section name, options = {}, &block
-        if Rapid::Check.current
-          Rapid::Check.current.with_section name do
-            run_section name, options, &block
-          end
-        else
+        @check.with_section name do
           run_section name, options, &block
         end
       end
@@ -124,12 +150,7 @@ module Rapid
       end
       
       def log type, file, message_or_exception
-        if Rapid::Check.current
-          Rapid::Check.current.send type, file, message_or_exception
-        else
-          raise "Rapid::Check.current is not set"
-        end
-        
+        @check.send type, file, message_or_exception
       end
       
       def validate_settings