cockpit 0.1.1 → 0.2.0

data/lib/cockpit/core/spec.rb

@@ -0,0 +1,65 @@
+module Cockpit
+  class Settings
+    # settings have one direct definition and many child definitions
+    class Spec
+      attr_reader :name, :roots # for "User"
+    
+      def initialize(options = {}, &block)
+        @name     = options[:name]
+        @store    = options[:store]
+        @roots    = Cockpit::Settings::Definition.define!(options, &block)
+      end
+      
+      # only returns keys that aren't defining a new scope.
+      # so site { title "Hello"; pages 10 } would just return
+      # ["site.title", "site.pages"], excluding "site"
+      def keys
+        @keys ||= roots.map(&:keys).flatten
+      end
+      
+      # returns all keys, even the ones defining new scope
+      def all_keys
+        @all_keys ||= roots.map(&:all_keys).flatten
+      end
+      
+      def has_key?(key)
+        all_keys.include?(key.to_s)
+      end
+      
+      def each(&block)
+        roots.each { |root| root.each(&block) }
+      end
+      
+      def map(&block)
+        roots.map { |root| root.map(&block) }
+      end
+      alias_method :collect, :map
+      
+      def [](key)
+        definition(key).value rescue nil
+      end
+      
+      def definition(key)
+        key = key.to_s
+        return nil if key.empty?
+        roots.each do |root|
+          value = root.child(key)
+          return value unless value.nil?
+        end
+        raise ArgumentError.new("Settings '#{name}' doesn't have key '#{key}'")
+      end
+      
+      def to_hash
+        keys.inject({}) do |hash, key|
+          hash[key] = self[key]
+          hash
+        end
+      end
+      
+      def to_tree
+        roots.map(&:to_tree)
+      end
+      
+    end
+  end
+end

data/lib/cockpit/core/store.rb

@@ -3,49 +3,45 @@ module Cockpit
     class << self
       attr_accessor :stores
       
+      def find(name)
+        return store(name) if store?(name)
+        
+        base_path =  "#{File.dirname(__FILE__)}/../stores"
+        
+        @stores[name.to_sym] = case name.to_sym
+        when :active_record
+          require "#{base_path}/active_record"
+          "::Cockpit::AR"
+        when :mongo
+          require "#{base_path}/mongo"
+          "::Cockpit::Mongo"
+        else
+          require "#{base_path}/memory"
+          "::Cockpit::Memory"
+        end
+        
+        store(name)
+      end
+      
+      def use(options)
+        eval("::#{find(options[:store])}::Store".gsub(/::[:]+/, "::")).new(options[:record], options[:name])
+      end
+      
+      def support(name)
+        eval("::#{find(name)}::Support".gsub(/::[:]+/, "::"))
+      end
+      
       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]
+      def store(name)
+        stores[name.to_sym]
+      end
+      
+      def store?(name)
+        stores.has_key?(name.to_sym)
       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/stores/active_record.rb

@@ -0,0 +1,128 @@
+begin
+  require "active_record"
+rescue LoadError
+  abort "You need the activerecord gem in order to use the ActiveRecord cockpit store"
+end
+
+module Cockpit
+  module AR
+    module Support
+      def self.included(base)
+        base.class_eval do
+          has_many :settings, :as => :configurable, :class_name => "::Cockpit::AR::Setting", :dependent => :destroy
+          
+          unless respond_to?("get")
+            def get(key)
+              cockpit[key]
+            end
+          end
+          
+          unless respond_to?("set")
+            def set(key, value)
+              cockpit[key] = value
+            end
+          end
+        end
+      end
+    end
+    
+    class Setting < ::ActiveRecord::Base
+      set_table_name 'settings'
+      belongs_to :configurable, :polymorphic => true
+      
+      def cockpit
+        configurable ? configurable.cockpit : Cockpit::Settings.global
+      end
+      
+      def parsed_value
+        JSON.parse(value)['root']
+      end
+    end
+    
+    class Store
+      attr_reader :record, :cache, :context
+      
+      def initialize(record, context = "default")
+        @record = record
+        @context = context
+      end
+      
+      def key?(key)
+        !!self[key]
+      end
+      
+      def has_key?(key)
+        key?(key)
+      end
+      
+      def [](key)
+        setting = find_setting(key)
+        setting ? setting.parsed_value : nil
+      end
+    
+      def []=(key, value)
+        record.save! if record && record.new_record?
+        
+        setting = find_setting(key)
+        attributes = {:value => {'root' => value}.to_json}#.merge(configurable_attributes)
+        
+        if setting
+          setting.update_attributes!(attributes)
+        else
+          setting = Setting.new(attributes)
+          setting.key = key
+          record.settings << setting if record
+          setting.save!
+          cache << setting
+        end
+      end
+      
+      def delete(key)
+        setting = find_setting(key)
+        if setting
+          setting.destroy
+          setting.parsed_value
+          record.reload if record
+        end
+      end
+      
+      def clear
+        record.settings.destroy_all
+      end
+      
+      def update_setting(setting)
+        cache.map! do |item|
+          item.id == setting.id ? setting : item
+        end if cache
+      end
+      
+      def cache
+        if record
+          @cache ||= record.settings.all
+        else
+          @cache ||= Setting.all(:conditions => configurable_attributes)
+        end
+        
+        @cache
+      end
+      
+      private
+      def find_setting(key)
+        cache.detect { |i| i.key == key }
+      end
+      
+      def configurable_attributes
+        conditions = {}
+        if record
+          conditions[:configurable_type] = [record.class.name, record.class.base_class.name]
+          conditions[:configurable_id] = record.id
+        else
+          conditions[:configurable_type] = nil
+          conditions[:configurable_id] = nil
+        end
+        conditions[:context] = context
+        conditions
+      end
+    end
+  end
+end

data/lib/cockpit/stores/file_system.rb

@@ -0,0 +1,11 @@
+module Cockpit
+  module FileSystem
+    class Support
+      
+    end
+    
+    class Store
+      
+    end
+  end
+end

data/lib/cockpit/stores/memory.rb

@@ -0,0 +1,16 @@
+module Cockpit
+  module Memory
+    module Support
+      
+    end
+    
+    class Store < Hash
+      attr_reader :name, :context
+      
+      def initialize(name, context = "default")
+        @name = name
+        @context = context
+      end
+    end
+  end
+end

data/lib/cockpit/stores/mongo.rb

@@ -0,0 +1,29 @@
+begin
+  require "mongoid"
+rescue LoadError
+  abort "You need the mongoid gem in order to use the ActiveRecord cockpit store"
+end
+
+module Cockpit
+  module Mongo
+    class Support
+      def included(base)
+        base.class_eval do
+          embeds_many :settings, :as => :configurable
+        end
+      end
+    end
+    
+    class Setting
+      include Mongoid::Document
+      field :key
+      field :value
+      field :context
+      embedded_in :configurable, :inverse_of => :setting
+    end
+    
+    class Store
+      
+    end
+  end
+end

data/lib/cockpit/stores/redis.rb

@@ -0,0 +1,11 @@
+module Cockpit
+  module Redis
+    class Support
+      
+    end
+    
+    class Store
+      
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cockpit
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Lance Pollard
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-13 00:00:00 -05:00
+date: 2010-09-18 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: moneta
+  name: defined-by
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -42,24 +42,21 @@ extra_rdoc_files: []
 
 files: 
 - README.markdown
-- Rakefile
-- MIT-LICENSE
+- MIT-LICENSE.markdown
 - lib/cockpit/core/definition.rb
-- lib/cockpit/core/definitions.rb
+- lib/cockpit/core/global.rb
+- lib/cockpit/core/helpers.rb
 - lib/cockpit/core/include.rb
+- lib/cockpit/core/scope.rb
 - lib/cockpit/core/settings.rb
+- lib/cockpit/core/spec.rb
 - lib/cockpit/core/store.rb
-- lib/cockpit/many/include.rb
-- lib/cockpit/many/settings.rb
-- lib/cockpit/moneta/active_record.rb
-- lib/cockpit/moneta/simple_active_record.rb
+- lib/cockpit/stores/active_record.rb
+- lib/cockpit/stores/file_system.rb
+- lib/cockpit/stores/memory.rb
+- lib/cockpit/stores/mongo.rb
+- lib/cockpit/stores/redis.rb
 - lib/cockpit.rb
-- test/lib/database.rb
-- test/lib/user.rb
-- test/test_active_record.rb
-- test/test_helper.rb
-- test/test_mongo.rb
-- test/test_stores.rb
 has_rdoc: true
 homepage: http://github.com/viatropos/cockpit
 licenses: []

data/Rakefile

@@ -1,79 +0,0 @@
-require 'rake'
-require "rake/rdoctask"
-require 'rake/gempackagetask'
-
-spec = Gem::Specification.new do |s|
-  s.name              = "cockpit"
-  s.authors           = ["Lance Pollard"]
-  s.version           = "0.1.1"
-  s.summary           = "Super DRY Configuration Management for Ruby, Rails, and Sinatra Apps.  With Pluggable NoSQL/SQL backends using Moneta"
-  s.homepage          = "http://github.com/viatropos/cockpit"
-  s.email             = "lancejpollard@gmail.com"
-  s.description       = "Super DRY Configuration for Ruby, Rails, and Sinatra Apps.  With Pluggable NoSQL/SQL backends using Moneta"
-  s.has_rdoc          = false
-  s.rubyforge_project = "cockpit"
-  s.platform          = Gem::Platform::RUBY
-  s.files             = %w(README.markdown Rakefile MIT-LICENSE) + Dir["{lib,test,app}/**/*"] - Dir["test/tmp"]
-  s.require_path      = "lib"
-  s.add_dependency("moneta")
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec    = spec
-  pkg.package_dir = "pkg"
-end
-
-desc 'run unit tests'
-task :test do
-  Dir["test/**/*"].each do |file|
-    next unless File.basename(file) =~ /test_/
-    next unless File.extname(file) == ".rb"
-    system "ruby #{file}"
-  end
-end
-
-desc "Create .gemspec file (useful for github)"
-task :gemspec do
-  File.open("pkg/#{spec.name}.gemspec", "w") do |f|
-    f.puts spec.to_ruby
-  end
-end
-
-desc "Build the gem into the current directory"
-task :gem => :gemspec do
-  `gem build pkg/#{spec.name}.gemspec`
-end
-
-desc "Publish gem to rubygems"
-task :publish => [:package] do
-  %x[gem push pkg/#{spec.name}-#{spec.version}.gem]
-end
-
-desc "Print a list of the files to be put into the gem"
-task :manifest do
-  File.open("Manifest", "w") do |f|
-    spec.files.each do |file|
-      f.puts file
-    end
-  end
-end
-
-desc "Install the gem locally"
-task :install => [:package] do
-  File.mkdir("pkg") unless File.exists?("pkg")
-  command = "gem install pkg/#{spec.name}-#{spec.version} --no-ri --no-rdoc"
-  command = "sudo #{command}" if ENV["SUDO"] == true
-  sh %{#{command}}
-end
-
-desc "Generate the rdoc"
-Rake::RDocTask.new do |rdoc|
-  files = ["README.markdown", "lib/**/*.rb"]
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README.markdown"
-  rdoc.title = spec.summary
-end
-
-task :yank do
-  `gem yank #{spec.name} -v #{spec.version}`
-end