cockpit 0.0.1.7 → 0.1.1

data/lib/cockpit/core/settings.rb

@@ -0,0 +1,148 @@
+module Cockpit
+  # settings have one direct definition and many child proxy
+  class Settings
+    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
+      end
+      
+      def store
+        root.store
+      end
+      
+      def store_type
+        @store_type ||= :memory
+      end
+      
+      def definitions
+        @definitions ||= []
+      end
+      
+      def definitions_for(name)
+        definitions.detect do |i|
+          i.name == name.to_s
+        end
+      end
+      
+      def definitions_for?(name)
+        !definitions_for(name).blank?
+      end
+      
+      def root
+        @root ||= Cockpit::Settings.new(:name => "root", :store => store_type, :scope => "default")
+      end
+      
+      def [](key)
+        root[key]
+      end
+
+      def []=(key, value)
+        root[key] = value
+      end
+
+      def clear
+        root.clear
+      end
+      
+      def default(key)
+        root.default(key)
+      end
+      
+      def inspect
+        "Cockpit::Settings root: #{root.inspect}"
+      end
+    end
+    
+    attr_accessor :name, :scope, :store, :record
+
+    # 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
+    end
+    
+    def merge!(hash)
+      hash.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def keys
+      definitions.keys
+    end
+
+    def [](key)
+      self.store[key.to_s] || default(key.to_s)
+    end
+    
+    def []=(key, value)
+      self.store[key.to_s] = value
+    end
+    
+    def clear
+      self.store.clear
+    end
+    
+    def has_key?(key)
+      !_definition(key).blank?
+    end
+    
+    def default(key)
+      _definition(key).value
+    end
+    
+    def definition(key)
+      _definition(key).dup
+    end
+    
+    def to_hash
+      keys.inject({}) do |hash, key|
+        hash[key] = self[key]
+        hash
+      end
+    end
+    
+    def roots
+      @roots ||= keys.select { |key| key !~ /\./ }
+    end
+    
+    protected
+    def definitions
+      @definitions ||= self.class.definitions_for(self.name)
+    end
+    
+    def _definition(key)
+      definitions[key.to_s]
+    end
+    
+    def method_missing(method, *args, &block)
+      if has_key?(method)
+        definition(method)
+      else
+        super(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/cockpit/core/store.rb

@@ -0,0 +1,51 @@
+module Cockpit
+  class Store
+    class << self
+      attr_accessor :stores
+      
+      def stores
+        @stores ||= {}
+      end
+      
+      def adapter(store)
+        stores[store.name.to_s] ||= {}
+#        unless stores[store.name.to_s].has_key?(store.value.to_s)
+          require 'moneta'
+          stores[store.name.to_s][store.value.to_s] = case store.value.to_s
+            when "mongo", "mongodb"
+              require 'moneta/adapters/mongodb'
+              Moneta::Adapters::MongoDB.new(:collection => store.name)
+            when "active_record"
+              require File.dirname(__FILE__) + '/../moneta/active_record'
+              Moneta::Adapters::ActiveRecord.new(:record => store.scope)
+            when "file"
+              require 'moneta/adapters/basic_file'
+              Moneta::Adapters::BasicFile.new(:path => "./.cockpit")
+            when "redis"
+              require 'moneta/adapters/redis'
+              Moneta::Adapters::Redis.new
+            when "memory"
+              require 'moneta/adapters/memory'
+              Moneta::Adapters::Memory.new
+            when "yaml"
+              require 'moneta/adapters/yaml'
+              Moneta::Adapters::YAML.new
+            end
+#        end
+        stores[store.name.to_s][store.value.to_s]
+      end
+    end
+    
+    attr_reader :name, :value, :scope
+    
+    def initialize(name, value, scope = nil)
+      @name = name
+      @value = value
+      @scope = scope
+    end
+    
+    def adapter
+      self.class.adapter(self)
+    end
+  end
+end

data/lib/cockpit/many/include.rb

@@ -0,0 +1,18 @@
+module Cockpit
+  module Include
+    module ActiveRecord
+      def self.included(base)
+        base.extend ClassMethods
+        base.send(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+        
+      end
+      
+      module InstanceMethods
+        
+      end
+    end
+  end
+end

data/lib/cockpit/many/settings.rb

@@ -0,0 +1,21 @@
+module Cockpit
+  module Many
+    class Settings
+      class << self
+        def define(&block)
+          DefinedBy::DSL(&block).each do |key, value, dsl_block|
+            
+          end
+        end
+      end
+    end
+    
+    class Setting
+      attr_reader :definition
+      
+      def method_name
+        
+      end
+    end
+  end
+end

data/lib/cockpit/moneta/active_record.rb

@@ -0,0 +1,120 @@
+begin
+  require "active_record"
+rescue LoadError
+  puts "You need the activerecord gem in order to use the ActiveRecord moneta store"
+  exit
+end
+
+class Object
+  unless respond_to?(:symbolize_keys)
+    def symbolize_keys
+      
+    end
+  end
+end
+
+module Moneta
+  module Adapters
+    class ActiveRecord
+      class Store < ::ActiveRecord::Base
+        set_primary_key 'key'
+        set_table_name 'settings'
+        belongs_to :configurable, :polymorphic => true
+
+        def parsed_value
+          JSON.parse(value)['root']
+        end
+      end
+      
+      def initialize(options = {})
+        @options = options
+        @configurable = options[:record]
+        @cache = []
+        #Store.establish_connection(@options[:connection] || raise("Must specify :connection"))
+        Store.set_table_name(@options[:table] || 'settings')
+      end
+      
+      module Implementation
+        def key?(key)
+          !!self[key]
+        end
+        
+        def has_key?(key)
+          key?(key)
+        end
+
+        def [](key)
+          record = find_record(key)
+          record ? record.parsed_value : nil
+        end
+        
+        def []=(key, value)
+          record = find_record(key)
+          attributes = {:value => {'root' => value}.to_json}.merge(configurable_attributes)
+          if record
+            record.update_attributes!(attributes)
+          else
+            store = Store.new(attributes)
+            store.key = key
+            store.save!
+            @cache << store
+          end
+        end
+        
+        def fetch(key, value = nil)
+          value ||= block_given? ? yield(key) : default # TODO: Shouldn't yield if key is present?
+          self[key] || value
+        end
+
+        def delete(key)
+          record = find_record(key)
+          if record
+            @cache.delete(record)
+            record.destroy
+            record.parsed_value
+          end
+        end
+        
+        def store(key, value, options = {})
+          self[key] = value
+        end
+
+        def clear
+          #Store.delete_all
+        end
+        
+        private
+        def find_record(key)
+          if record = @cache.detect { |i| i.key == key }
+            record
+          else
+            @cache = Store.all(:conditions => configurable_attributes)
+            Store.find_by_key(key, :conditions => configurable_attributes) rescue nil
+          end
+        end
+        
+        def configurable_attributes
+          conditions = {}
+          if @configurable
+            conditions[:configurable_type] = @configurable.class.name
+            conditions[:configurable_id] = @configurable.id
+          else
+            conditions[:configurable_type] = nil
+            conditions[:configurable_id] = nil
+          end
+          conditions
+        end
+        
+      end
+      
+      # Unimplemented
+      module Expiration
+        def update_key(key, options)
+        end
+      end
+
+      include Implementation
+      include Expiration
+    end
+  end
+end

data/lib/cockpit/moneta/simple_active_record.rb

@@ -0,0 +1,93 @@
+begin
+  require "active_record"
+rescue LoadError
+  puts "You need the activerecord gem in order to use the ActiveRecord moneta store"
+  exit
+end
+
+class Object
+  unless respond_to?(:symbolize_keys)
+    def symbolize_keys
+      
+    end
+  end
+end
+
+module Moneta
+  module Adapters
+    class SimpleActiveRecord
+      class Store < ::ActiveRecord::Base
+        set_primary_key 'key'
+        set_table_name 'settings'
+
+        def parsed_value
+          JSON.parse(value)['root']
+        end
+      end
+      
+      def initialize(options = {})
+        @options = options
+        #Store.establish_connection(@options[:connection] || raise("Must specify :connection"))
+        Store.set_table_name(@options[:table] || 'settings')
+      end
+      
+      module Implementation
+        def key?(key)
+          !!self[key]
+        end
+
+        def has_key?(key)
+          key?(key)
+        end
+
+        def [](key)
+          record = Store.find_by_key(key)
+          record ? record.parsed_value : nil
+        end
+      
+        def []=(key, value)
+          record = Store.find_by_key(key)
+          if record
+            record.update_attributes!(:value => {'root' => value}.to_json)
+          else
+            store = Store.new
+            store.key = key
+            store.value = {'root' => value}.to_json
+            store.save!
+          end
+        end
+
+        def fetch(key, value = nil)
+          value ||= block_given? ? yield(key) : default # TODO: Shouldn't yield if key is present?
+          self[key] || value
+        end
+
+        def delete(key)
+          record = Store.find_by_key(key)
+          if record
+            record.destroy
+            record.parsed_value
+          end
+        end
+        
+        def store(key, value, options = {})
+          self[key] = value
+        end
+
+        def clear
+          Store.delete_all
+        end
+
+      end
+
+      # Unimplemented
+      module Expiration
+        def update_key(key, options)
+        end
+      end
+
+      include Implementation
+      include Expiration
+    end
+  end
+end

data/lib/cockpit.rb

@@ -1,22 +1,16 @@
 require 'rubygems'
-require 'active_support'
-require 'active_record'
 
 this = File.expand_path(File.dirname(__FILE__))
-Dir["#{this}/cockpit/*"].each { |c| require c }
-
-class Settings
-  include Cockpit::Configuration
-end
+Dir["#{this}/cockpit/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/cockpit/core/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/cockpit/adapters/*"].each { |c| require c unless File.directory?(c) }
 
 ActiveRecord::Base.send(:include, Cockpit) if defined?(ActiveRecord::Base)
 
 def Settings(*args, &block)
-  Settings.define!(*args, &block)
+  Cockpit::Settings.define!(*args, &block)
 end
 
 def Cockpit(*args, &block)
   Settings(*args, &block)
 end
-
-require File.expand_path("#{this}/../app/models/setting.rb")

data/test/lib/database.rb

@@ -11,10 +11,9 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table :settings, :force => true do |t|
     t.string :key
     t.string :value
-    t.string :cast_as
+    t.string :context
     t.string :configurable_type
     t.integer :configurable_id
-    t.string :context
   end
   
   create_table :users, :force => true do |t|

data/test/lib/user.rb

@@ -1,8 +1,10 @@
 class User < ActiveRecord::Base
-  acts_as_configurable :settings do
-    name "Lance", :title => "First Name", :options => ["Lance", "Viatropos"]
+  include Cockpit
+  
+  cockpit "mongo" do
+    appelation "Lance", :title => "First Name", :options => ["Lance", "Viatropos"]
     favorite do
-      color "red"
+      colors %w(red green blue)
     end
   end
 end

data/test/test_active_record.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ActiveRecordTest < ActiveSupport::TestCase
+  
+  context "ActiveRecord" do
+    
+    setup do
+      Cockpit :active_record do
+        site do
+          title "My Site"
+          time_zone lambda { "Hawaii" }
+          feed do
+            per_page 10
+            formats %w(rss atom)
+          end
+        end
+      end
+    end
+    
+    should "retrieve default values" do
+      assert_equal "My Site", Cockpit::Settings.default("site.title")
+    end
+
+    should "define values at runtime" do
+      Cockpit::Settings["site.title"] = "New Site"
+      assert_equal "New Site", Cockpit::Settings["site.title"]
+    end
+
+    should "use moneta" do
+      assert Cockpit::Settings.store
+      Cockpit::Settings["site.title"] = "Another Site"
+      assert_equal "Another Site", Cockpit::Settings.store["site.title"]
+    #  puts Moneta::Adapters::ActiveRecord::Store.all.inspect
+    end
+    
+    context "instance" do
+      setup do
+        @settings = Cockpit::Settings.new(:store => :active_record, :name => "site-cache", :scope => "default") do
+          site "a site"
+        end
+      end
+      
+      should "have an instance of setting" do
+        assert @settings
+        assert_equal "a site", @settings["site"]
+        class User < ::ActiveRecord::Base
+          cockpit :active_record do
+            author "Lance"
+            title do
+              last_name "Pollard"
+            end
+          end
+        end
+        assert_equal "Lance", User.cockpit["author"]
+        assert_equal "Pollard", User.cockpit["title.last_name"]
+        
+        user = User.new
+        assert_equal "Lance", user.cockpit["author"]
+        assert_equal "Pollard", user.cockpit["title.last_name"]
+      end
+      
+      should "be able to assiociate Proc and hash" do
+        require 'tzinfo'
+        @settings = Cockpit :active_record do
+          site do
+            time_zones "MST", :options => Proc.new { TZInfo::Timezone.all.map(&:name) }
+          end
+        end
+        
+        assert_equal TZInfo::Timezone.all.map(&:name), @settings.definition("site.time_zones")[:options].call
+      end
+    end
+    
+    teardown do
+      Cockpit::Settings.clear
+    end
+    
+  end
+  
+end

data/test/test_helper.rb

@@ -10,11 +10,13 @@ require 'shoulda'
 require 'shoulda/active_record'
 
 require File.dirname(__FILE__) + '/lib/database'
-
 require File.expand_path(File.join(File.dirname(__FILE__), '/../lib/cockpit'))
-
 require File.dirname(__FILE__) + '/lib/user'
 
+class Object
+  include Cockpit
+end
+
 ActiveRecord::Base.class_eval do
   def self.detonate
     all.map(&:destroy)
@@ -24,7 +26,7 @@ end
 ActiveSupport::TestCase.class_eval do
   
   def load_settings
-    Settings do
+    Cockpit do
       asset :title => "Asset (and related) Settings" do
         thumb do
           width 100, :tip => "Thumb's width"
@@ -81,10 +83,6 @@ ActiveSupport::TestCase.class_eval do
         twitter "http://twitter.com/viatropos"
         email "lancejpollard@gmail.com"
       end
-      s3 do
-        key "my_key"
-        secret "my_secret"
-      end
     end
   end
 end

data/test/test_mongo.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class MongoDBTest < ActiveSupport::TestCase
+  
+  context "MongoDB" do
+    
+    setup do
+      Cockpit "mongo" do
+        site do
+          title "My Site"
+          time_zone lambda { "Hawaii" }
+          feed do
+            per_page 10
+            formats %w(rss atom)
+          end
+        end
+      end
+    end
+    
+    should "retrieve default values" do
+      assert_equal "My Site", Cockpit::Settings.default("site.title")
+    end
+    
+    should "define default values at runtime" do
+      Cockpit::Settings["site.title"] = "New Site"
+      assert_equal "New Site", Cockpit::Settings.default("site.title")
+      assert_equal "New Site", Cockpit::Settings["site.title"]
+    end
+    
+    should "use moneta" do
+      assert Cockpit::Settings.store
+      Cockpit::Settings["site.title"] = "Another Site"
+      assert_equal "Another Site", Cockpit::Settings.store["default.site.title"]
+    end
+    
+    context "instance" do
+      setup do
+        @settings = Cockpit::Settings.new(:name => "site-cache", :scope => "default") do
+          site "a site"
+        end
+      end
+      
+      should "have an instance of setting" do
+        assert @settings
+        assert_equal "a site", @settings["site"]
+        class User
+          cockpit do
+            author "Lance"
+            title do
+              last_name "Pollard"
+            end
+          end
+        end
+        assert_equal "Lance", User.cockpit["author"]
+        assert_equal "Pollard", User.cockpit["title.last_name"]
+        
+        user = User.new
+        assert_equal "Lance", user.cockpit["author"]
+        assert_equal "Pollard", user.cockpit["title.last_name"]
+        
+        settings = load_settings
+      end
+      
+      should "be able to assiociate Proc and hash" do
+        require 'tzinfo'
+        @settings = Cockpit "mongo" do
+          site do
+            time_zones "MST", :options => Proc.new { TZInfo::Timezone.all.map(&:name) }
+          end
+        end
+        
+        assert_equal TZInfo::Timezone.all.map(&:name), @settings.definition("site.time_zones")[:options].call
+      end
+    end
+    
+    teardown do
+      Cockpit::Settings.clear
+    end
+    
+  end
+  
+end