rapid-core 0.1 → 0.2.1

data/lib/rapid/error.rb

@@ -42,6 +42,7 @@ module Rapid
   class InvalidTemplateError < TemplateError ; end
   class NotMatchingTemplateError < TemplateError ; end
   class TemplateNotFoundError < TemplateError ; end
+  class ProjectFileNotFoundError < TemplateError ; end
   class UnknownMethodTemplateError < TemplateError ; end
   
   class NotMatchingTemplateError < TemplateError

data/lib/rapid/module.rb

@@ -2,7 +2,7 @@ module Rapid
   
   class << self
     
-    attr_accessor :view_path
+    attr_accessor :view_path, :middleware
     
     # from rspec
     
@@ -13,6 +13,7 @@ module Rapid
     def red(text); colorize(text, "\e[31m"); end
     def green(text); colorize(text, "\e[32m"); end
     def yellow(text); colorize(text, "\e[33m"); end
+    def gray(text); colorize(text, "\e[90m"); end
     
     def color_puts type, message
       case type
@@ -25,11 +26,19 @@ module Rapid
       when :error
         puts red(message)
         
+      when :info
+        puts gray(message)
+        
       else
         raise "Invalid type: #{type.inspect}"
       end
     end
     
+    def use_middleware middleware
+      @middleware ||= []
+      @middleware.push middleware
+    end
+    
   end
   
 end

data/lib/rapid/railtie.rb

@@ -11,6 +11,12 @@ module Rapid
       
       ActionController::Base.append_view_path Rapid.view_path
       ActionMailer::Base.append_view_path Rapid.view_path
+      
+      Rails.application.middleware.use Rapid::Web::Navigator
+      
+      Rapid.middleware.each do |middleware|
+        Rails.application.middleware.use middleware
+      end
     end
     
   end

data/lib/rapid/setting/base.rb

@@ -6,26 +6,49 @@ module Rapid
       attr_reader :namespace, :full_name, :name, :default_value
       
       def initialize name, options = {}
-        @name = name.to_sym
+        @name = name.to_sym if name
         @namespace = options[:namespace]
         @default_value = options[:default]
-        @full_name = @namespace ? "#{@namespace.full_name}.#{name}" : name.to_s
+        
+        if @namespace
+          @full_name = "#{@namespace.full_name}.#{name}"
+        elsif @name
+          @full_name = name.to_s
+        end
         
         if Rapid::Settings.reserved_name? @name
           raise ArgumentError.new("#{@name} is a reserved setting name")
         end
+        
+        if @namespace
+          @namespace.send :add_child, self
+        end
       end
       
       def load value
         raise "Subclass should override this method"
       end
       
-      def get_helper_name
-        name
-      end
-      
-      def set_helper_name
-        "#{name}="
+      def define_helpers klass
+        name = self.name
+        getter = name
+        setter = "#{name}="
+        
+        klass.class_eval do
+          define_method getter do
+            self[name]
+          end
+          
+          define_method "#{getter}?" do
+            self[name] != nil
+          end
+          
+          define_method setter do |value|
+            self[name] = value
+          end
+        end
+        
+        true
       end
       
     end

data/lib/rapid/setting/boolean_setting.rb

@@ -4,13 +4,32 @@ module Rapid
     class BooleanSetting < Base
       
       def load value
-        if [0, "0", false, "false"].include?(value)
+        if value == nil || value == ""
+          nil
+        elsif [0, "0", false, "false"].include?(value)
           false
         elsif [1, "1", true, "true"].include?(value)
           true
+        else
+          raise Rapid::InvalidSettingError.new(self, value)
         end
       end
       
+      def define_helpers klass
+        super
+        
+        name = self.name
+        getter = self.name
+        
+        klass.class_eval do
+          define_method "#{getter}?" do
+            self[name] == true
+          end
+        end
+        
+        true
+      end
+      
     end
     
   end

data/lib/rapid/setting/definer.rb

@@ -51,7 +51,7 @@ module Rapid
         names.each_with_index do |name, index|
           if index == 0
             namespace = @klass.settings[name]
-          else
+          elsif namespace
             namespace = namespace[name]
           end
         end
@@ -65,11 +65,13 @@ module Rapid
       protected
       
       def find_or_create_namespace *names
-        namespace = nil
+        namespace = @klass.settings
         
         names.each_with_index do |name, index|
           if index == 0
             new_namespace = @klass.settings[name]
+          elsif !namespace.is_a?(Setting::Namespace::Base)
+            raise Rapid::SettingError.new("#{names.join(@delimiter).inspect} is not a namespace")
           else
             new_namespace = namespace[name]
           end
@@ -90,60 +92,22 @@ module Rapid
         setting_name = names.pop.to_sym
         
         namespace = find_or_create_namespace *names
+        
+        if namespace != nil && !namespace.is_a?(Setting::Namespace::Base)
+          raise Rapid::SettingError.new("#{names.join(@delimiter).inspect} is not a namespace")
+        end
+        
         return namespace, setting_name
       end
       
       def define_setting setting
-        if setting.namespace.nil?
-          define_base_setting setting
-        else
-          setting.namespace.define_setting setting
+        if setting.namespace.nil? || setting.namespace.name.blank?
+          setting.define_helpers @klass
         end
         
         setting
       end
       
-      def define_base_setting setting
-        define_methods setting
-        push_setting setting
-      end
-      
-      def define_methods setting
-        name = setting.name
-        getter = setting.get_helper_name
-        setter = setting.set_helper_name
-        
-        @klass.class_eval do
-          define_method getter do
-            settings[name]
-          end
-          
-          define_method setter do |value|
-            settings[name] = value
-          end
-          
-          if setting.is_a? BooleanSetting
-            define_method "#{getter}?" do
-              settings[name] == true
-            end
-          elsif setting.is_a? Namespace::Base
-            define_method "#{getter}?" do
-              settings[name] != nil && !settings[name].empty?
-            end
-          else
-            define_method "#{getter}?" do
-              settings[name] != nil
-            end
-          end
-        end
-        
-        true
-      end
-      
-      def push_setting setting
-        @klass.settings[setting.name] = setting
-      end
-      
     end
     
   end

data/lib/rapid/setting/integer_setting.rb

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

data/lib/rapid/setting/module.rb

@@ -0,0 +1,56 @@
+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 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
+    
+  end
+  
+end

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

@@ -4,64 +4,71 @@ module Rapid
       
       class Base < Setting::Base
         
-        attr_accessor :delegate, :instance_class, :default_empty
-        
-        delegate :[], :to => :delegate
-        delegate :[]=, :to => :delegate
+        attr_accessor :instance_class
         
         def initialize name, options = {}
-          super
+          super name, options
           @delegate = HashWithIndifferentAccess.new {}
-          @klass = options[:class]
-          @instance_class = define_instance_class if @klass
-          @default_empty = !options[:default] if options.key? :default
+          
+          # class option isn't provided for the root namespace
+          klass = options[:class]
+          @instance_class = define_instance_class klass if klass
         end
         
         def namespaces
-          values = delegate.values
+          values = @delegate.values
           values.delete_if {|c| !c.is_a?(Namespace::Base) }
           values
         end
         
         def scalars
-          values = delegate.values
+          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
+        def [] key
+          namespace_name, child_name = Rapid::Settings.extract_nested_namespace(key)
           
-          if @instance_class
-            @instance_class.new owner, self, hash
+          if namespace_name
+            namespace = @delegate[namespace_name]
+            namespace[child_name] if namespace
           else
-            Namespace::Instance.new owner, self, hash
+            @delegate[key]
           end
         end
         
-        def define_setting setting
-          define_helper_methods_for setting
-          setting.namespace[setting.name] = setting
-          setting
+        def define_helpers klass
+          super
+          name = self.name
+          getter = self.name
+          
+          klass.class_eval do
+            define_method "#{getter}?" do
+              val = self[name]
+              val != nil && val.on?
+            end
+          end
+          
+          true
         end
         
         protected
         
+        def add_child setting
+          setting.define_helpers @instance_class if @instance_class
+          @delegate[setting.name] = setting
+        end
+        
         def instance_class_name
           full_name.to_s.gsub('.', '/').camelize.gsub("::", "")
         end
         
-        def define_instance_class
+        def define_instance_class klass
           instance_class = eval %(
-          module #{@klass.name}::Settings
+          module #{klass.name}::Settings
             class #{instance_class_name} < Namespace::Instance
-              @setting_name = #{name.to_s.inspect}
+              @setting_name = #{name.inspect}
               @full_setting_name = #{full_name.to_s.inspect}
               
               class << self ; attr_reader :setting_name, :full_setting_name ; end
@@ -74,38 +81,6 @@ module Rapid
           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