cockpit 0.1.1 → 0.2.0

data/lib/cockpit/core/global.rb

@@ -0,0 +1,35 @@
+module Cockpit
+  class Settings
+    module Global
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
+      module ClassMethods
+        def [](key)
+          global[key]
+        end
+        
+        def []=(key, value)
+          global[key] = value
+        end
+      end
+    end
+  end
+  
+  def self.Settings(*args)
+    case args.length
+    when 0
+      Cockpit::Settings.global
+    when 1
+      case args.first
+      when Hash
+        
+      else
+        Cockpit::Settings[args.first]
+      end
+    when 2
+      Cockpit::Settings[args.first] = args.last
+    end
+  end
+end

data/lib/cockpit/core/helpers.rb

@@ -0,0 +1,12 @@
+module Cockpit
+  module ViewHelpers
+    unless respond_to?(:c)
+      def c(key)
+        Cockpit::Settings.global[key]
+      end
+    end
+  end
+end
+
+::ActionView::Helpers.send(:include, Cockpit::ViewHelpers) if defined?(::ActionView::Helpers)
+::Sinatra.helpers.send(:helper, Cockpit::ViewHelpers) if defined?(::Sinatra)

data/lib/cockpit/core/include.rb

@@ -1,89 +1,44 @@
 module Cockpit
+  
   def self.included(base)
-    base.send(:include, ObjectInclude)
-    if defined?(::ActiveRecord::Base) && base.ancestors.include?(::ActiveRecord::Base)
-      base.send(:include, ActiveRecordInclude)
-    end
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
   end
   
-  module ActiveRecordInclude
-    def self.included(base)
-      base.class_eval do
-        def self.cockpit(*args, &block)
-          if block_given? || @cockpit.nil?
-            @cockpit = Cockpit::Settings.new(
-              :name => self.name.underscore.gsub(/[^a-z0-9]/, "_").squeeze("_"),
-              :store => :active_record,
-              &block
-            )
-            
-            @cockpit.keys.each do |key|
-              next if key =~ /\./
-              
-              define_method key do
-                send(:cockpit)[key]
-              end
-              
-              define_method "#{key}?" do
-                !send(key).blank?
-              end
-            end
-            
-          else
-            @cockpit
-          end
-        end
-        
-        def cockpit
-          unless @cockpit
-            @cockpit = Cockpit::Settings.new(
-              :name => self.class.cockpit.name,
-              :store => :active_record,
-              :record => self
-            )
+  module ClassMethods
+    def cockpit(options = {}, &block)
+      if block_given?
+        options = {:store => options.to_sym} unless options.is_a?(Hash)
+        @cockpit = Cockpit::Settings.define!(options.merge(:for => self), &block)
+
+        @cockpit.roots.map(&:key).flatten.each do |key|
+          define_method key do
+            send(:cockpit).send(key)
           end
           
-          @cockpit
+          define_method "#{key}?" do
+            send(:cockpit).has_key?(key)
+          end
         end
+      end
+      
+      @cockpit
+    end
+    
+    unless respond_to?(:key)
+      def key(*args)
         
-        def get(key)
-          cockpit[key]
-        end unless respond_to?(:get)
-
-        def set(*args)
-          if args.last.is_a?(Hash)
-            cockpit.set(args.last)
-          else
-            cockpit[args.first] = args.last
-          end
-        end unless respond_to?(:set)
       end
     end
   end
   
-  module ObjectInclude
-    def self.included(base)
-      base.class_eval do
-        def self.cockpit(*args, &block)
-          if block_given?
-            @cockpit = Cockpit::Settings.new(
-              :name => self.name.underscore.gsub(/[^a-z0-9]/, "_").squeeze("_"),
-              :scope => "default",
-              :store => args.first || "memory",
-              &block
-            )
-          else
-            @cockpit
-          end
-        end
-        
-        def cockpit
-          unless @cockpit
-            @cockpit = self.class.cockpit.dup
-          end
-
-          @cockpit
-        end 
+  module InstanceMethods
+    def cockpit(key = nil)
+      @cockpit ||= Cockpit::Settings.new(:record => self)
+      if key
+        @cockpit.definition(key)
+      else
+        @cockpit
       end
     end
   end

data/lib/cockpit/core/scope.rb

@@ -0,0 +1,46 @@
+module Cockpit
+  class Scope
+    attr_reader :key, :settings
+    
+    def initialize(settings, method, *args, &block)
+      @settings = settings
+      process(method, *args, &block)
+    end
+    
+    def value
+      settings[key]
+    end
+    
+    def value=(x)
+      settings[key] = x
+    end
+    
+    def process(method, *args, &block)
+      node = method.to_s
+
+      boolean = !!(node =~ /\?$/)
+      node.gsub!(/\?/, "") if boolean
+      
+      set     = !!(node =~ /=$/)
+      node.gsub!("=", "") if set
+      
+      if key
+        @key       = "#{key}.#{node}"
+      else
+        @key       = node
+      end
+      
+      if boolean == true
+        settings.has_key?(key)
+      elsif set == true
+        self.value = args.pop
+      else
+        self
+      end
+    end
+    
+    def method_missing(method, *args, &block)
+      process(method, *args, &block)
+    end
+  end
+end

data/lib/cockpit/core/settings.rb

@@ -1,86 +1,103 @@
 module Cockpit
   # settings have one direct definition and many child proxy
   class Settings
+    include Global
+    
     class << self
-      attr_accessor :definitions
-      
-      # Cockpit::Settings.define!(:name => "root", :scope => "default")
-      def define!(*args, &block)
-        setting = Cockpit::Settings.new(*args, &block)
-        @root ||= setting
-        setting
+      def specs
+        @specs ||= {}
       end
       
-      def store
-        root.store
+      def global_settings
+        @global_settings ||= {}
       end
       
-      def store_type
-        @store_type ||= :memory
-      end
-      
-      def definitions
-        @definitions ||= []
+      def define!(options = {}, &block)
+        options = {:store => options.to_sym} unless options.is_a?(Hash)
+        options = configure(options)
+        
+        unless options[:class] == NilClass
+          options[:class].send(:include, Cockpit::Store.support(options[:store]))
+        end
+        
+        spec options[:name], options[:class], Cockpit::Settings::Spec.new(options, &block)
+        
+        settings  = Cockpit::Settings.new(options)
+        
+        if options[:class] == NilClass
+          global_setting options[:name], options[:class], settings
+        end
+        
+        settings
       end
       
-      def definitions_for(name)
-        definitions.detect do |i|
-          i.name == name.to_s
+      def configure(options)
+        name                = (options[:name]  || "default").to_s
+        relationship        = options[:class] || options[:for] || options[:class_name] || options[:record]
+        store               = options[:store]
+        
+        # class to include this in
+        clazz = case relationship
+        when Class
+          relationship
+        when Object
+          relationship.class
+        when String, Symbol
+          Object.const_get(relationship.to_s)
+        else
+          NilClass
+        end
+        
+        # store to use in the include
+        unless store
+          if defined?(::ActiveRecord::Base) && clazz.ancestors.include?(::ActiveRecord::Base)
+            store = :active_record
+          else
+            store = :memory
+          end
         end
+        
+        options[:class] = clazz
+        options[:store] = store
+        options[:name]  = name
+        
+        options
       end
       
-      def definitions_for?(name)
-        !definitions_for(name).blank?
+      def spec(name, clazz = NilClass, value = nil)
+        specs[clazz.to_s] ||= {}
+        specs[clazz.to_s][name.to_s] ||= value if value
+        specs[clazz.to_s][name.to_s]
       end
       
-      def root
-        @root ||= Cockpit::Settings.new(:name => "root", :store => store_type, :scope => "default")
+      def global_setting(name, clazz = NilClass, value = nil)
+        global_settings[clazz.to_s] ||= {}
+        global_settings[clazz.to_s][name.to_s] = value if value
+        global_settings[clazz.to_s][name.to_s]
       end
       
-      def [](key)
-        root[key]
-      end
-
-      def []=(key, value)
-        root[key] = value
-      end
-
-      def clear
-        root.clear
+      def global
+        global_setting("default")
       end
       
-      def default(key)
-        root.default(key)
+      def find(name)
+        global_setting(name)
       end
       
-      def inspect
-        "Cockpit::Settings root: #{root.inspect}"
+      def method_missing(method, *args, &block)
+        global.send(method, *args, &block)
       end
     end
     
-    attr_accessor :name, :scope, :store, :record
+    attr_reader :name, :record, :store, :store_type, :record_type
 
-    # Settings.new(:store => :memory, :record => @user, :definitions => Settings.definitions.first)
-    def initialize(*args, &block)
-      options = args.extract_options!
-      options[:name] ||= "root"
-      options[:store] ||= args.first
-      options.each do |k, v|
-        send("#{k}=", v)
-      end
-      raise ArgumentError.new("pass in a :store to Cockpit::Settings") if self.store.nil?
-      
-      args << options
-      
-      if definition = self.class.definitions_for(options[:name])
-        definition.define!(*args, &block)
-      else
-        self.class.definitions << Cockpit::Definitions.new(*args, &block)
-      end
-    end
-    
-    def store=(value)
-      @store = Cockpit::Store.new(name, value, record).adapter
+    def initialize(options = {}, &block)
+      options   = self.class.configure(options)
+      @name     = options[:name]
+      @record   = options[:record]
+      @record_type = options[:class] || @record.class
+      @store_type = options[:store]
+      @store    = Cockpit::Store.use(options)
     end
     
     def merge!(hash)
@@ -88,17 +105,23 @@ module Cockpit
         self[key] = value
       end
     end
-
+    
     def keys
-      definitions.keys
+      spec.keys
     end
-
+    
     def [](key)
       self.store[key.to_s] || default(key.to_s)
     end
     
     def []=(key, value)
-      self.store[key.to_s] = value
+      with_callbacks(key, value) do |value|
+        self.store[key.to_s] = value
+      end
+    end
+    
+    def with_callbacks(key, new_value, &block)
+      definition(key).with_callbacks(record, new_value, &block)
     end
     
     def clear
@@ -106,15 +129,15 @@ module Cockpit
     end
     
     def has_key?(key)
-      !_definition(key).blank?
+      spec.has_key?(key)#!definition(key).blank?
     end
     
     def default(key)
-      _definition(key).value
+      definition(key).value
     end
     
     def definition(key)
-      _definition(key).dup
+      spec.definition(key)
     end
     
     def to_hash
@@ -124,22 +147,38 @@ module Cockpit
       end
     end
     
-    def roots
-      @roots ||= keys.select { |key| key !~ /\./ }
+    def update(hash)
+      hash.each do |key, value|
+        self[key] = value
+      end
     end
     
-    protected
-    def definitions
-      @definitions ||= self.class.definitions_for(self.name)
+    def each(&block)
+      keys.each do |key|
+        case block.arity
+        when 1
+          yield(key)
+        when 2
+          yield(key, self[key])
+        end
+      end
     end
     
-    def _definition(key)
-      definitions[key.to_s]
+    def roots
+      spec.roots
     end
     
+    def spec
+      @spec ||= self.class.spec(self.name, self.record_type)
+    end
+    
+    protected
+    
     def method_missing(method, *args, &block)
-      if has_key?(method)
-        definition(method)
+      if method.to_s =~ /(\w+)\?$/
+        has_key?($1)
+      elsif has_key?(method)
+        Cockpit::Scope.new(self, method, *args, &block)
       else
         super(method, *args, &block)
       end