cockpit 0.0.1.7 → 0.1.1

data/lib/cockpit/helper.rb

@@ -1,44 +0,0 @@
-module Cockpit::Helper
-  
-  # always returns either an array or a string
-  def c(*args)
-    options = args.extract_options!
-    result = args.collect {|i| Settings.get(i).value }
-    result = result.pop if result.length == 1
-    result.blank? ? nil : result.to_s
-  end
-  
-  def setting_tag(tag)
-    
-  end
-  
-  def settings_tag(key, &block)
-    Settings(key).each_setting do |key, attributes, value|
-      
-    end
-  end
-  
-  def setting_value(value)
-    result = case value
-      when Proc
-        value.call
-      when Cockpit::TreeHash
-        value
-      else
-        value
-      end
-  end
-  
-  def setting_options(attributes)
-    return {} unless (attributes.is_a?(Hash) && attributes[:options])
-    options = case attributes[:options]
-      when Proc
-        attributes[:options].call
-      else
-        attributes[:options]
-      end
-  end
-  
-end
-
-ActionView::Base.send(:include, Cockpit::Helper) if defined?(ActionView)

data/lib/cockpit/store.rb

@@ -1,103 +0,0 @@
-module Cockpit
-  module Store
-    class Base
-      attr_accessor :configurable
-      
-      def initialize(*args)
-        options = args.extract_options!
-        options.each do |k, v|
-          self.send("#{k.to_s}=", v) if self.respond_to?("#{k.to_s}=")
-        end
-        @configuration = args.first
-      end
-      
-      def configuration
-        @configuration
-      end
-      
-      def tree=(value)
-        @tree = value if value.is_a?(TreeHash)
-        @tree
-      end
-      
-      def tree
-        @tree ||= TreeHash.new
-      end
-      
-      def clear(options = {})
-        tree.each do |k, v|
-          tree.delete(k) unless (options[:except] && options[:except].include?(k.to_sym))
-        end
-      end
-      
-      def get(path)
-        tree.get(path)
-      end
-      alias_method :[], :get
-      
-      def get!(path)
-        result = get(path)
-        raise "'#{path.to_s}' was not in Config" if result.blank?
-        result
-      end
-      
-      def set(value)
-        return unless value.is_a?(Hash)
-        value.each { |k,v| set_one(k, v) }
-      end
-      
-      def set_one(key, value)
-        tree.set(key, value)
-      end
-      
-      def set!(value)
-        result = set(value)
-        raise "'#{path.to_s}' was not set in Config" if result.blank?
-        result
-      end
-      
-      def []=(key, value)
-        set_one(key => value)
-      end
-    end
-    
-    class Memory < Base
-      
-    end
-    
-    class Database < Base
-      
-      def clear(options = {})
-        configuration.setting_class.all.collect(&:destroy) if options[:hard] == true
-        super(options)
-      end
-      
-      def find_or_create(key)
-        result = configuration.setting_class.find(key.to_s) rescue nil
-        result ||= configuration.setting_class.create(:key => key.to_s)
-      end
-      
-      def set_one_with_database(key, value)
-        setting = find_or_create(key)
-        cast_as = (setting.cast_as || Cockpit.get_type(value)).to_s
-        attributes = {:value => value, :cast_as => cast_as}
-        attributes[:configurable] = self.configurable if self.configurable
-        setting.update_attributes(attributes)
-        set_one_without_database(key, Cockpit.type_cast(value, cast_as))
-      end
-      alias_method_chain :set_one, :database
-      
-      def get(key)
-        result = super(key)
-        if result.blank? && setting = find_or_create(key)
-          set(key => setting.value)
-          result = super(key)
-        else
-          
-        end
-        result
-      end
-      
-    end
-  end
-end

data/lib/cockpit/tree_hash.rb

@@ -1,116 +0,0 @@
-# http://www.daniel-azuma.com/blog/view/z3bqa0t01uugg1/implementing_dsl_blocks
-module Cockpit  
-  class TreeHash < Hash
-    
-    def initialize
-      block = Proc.new {|h,k| h[k] = TreeHash.new(&block)}
-      super &block
-    end
-    
-    def value_type
-      has_key?(:type) ? self[:type] : :string
-    end
-    
-    def each_setting(&block)
-      dup.each do |k, v|
-        atrib = Hash.new
-        if v.has_key?(:value)
-          value = clone(v[:value])
-          atrib = clone(v)
-        else
-          v.each do |k, sub_v|
-            atrib[k] = clone(v[k]) unless sub_v.is_a?(TreeHash)
-          end
-          value = clone(v)
-        end
-        yield(k.to_s, atrib, value) if block_given?
-      end
-    end
-    
-    def dup
-      result = super
-      result.each do |k,v|
-        result[k] = v.dup if v.is_a?(TreeHash)
-      end
-      result
-    end
-    
-    def children
-      hash = {}
-      each do |k, v|
-        hash[k] = v if v.is_a?(Hash)
-      end
-      hash
-    end
-    
-    def get(key)
-      traverse(key)
-    end
-    
-    def get_attribute(key, attribute)
-      get(key)[attribute.to_sym]
-    end
-
-    def set(key, value)
-      traverse(key, value)
-    end
-    
-    def set_attribute(key, value)
-      traverse(key, value, false)
-    end
-    
-    def set_attributes(hash)
-      hash.each { |k, v| set_attribute(k, v) }
-      self
-    end
-    
-    def to_hash
-      hash = {}
-      self.each do |k, v|
-        hash[k] = v.is_a?(TreeHash) ? v.to_hash : v
-      end
-      hash
-    end
-    
-    protected
-      def traverse(path, value = nil, as_node = true)
-        path = path.to_s.split('.')
-        child = path.pop.to_sym
-        parent = path.inject(self) { |h,k| h[k.to_sym] }
-        unless value.nil?
-          if as_node
-            if parent[child].has_key?(:type)
-              parent[child][:value] = Cockpit.type_cast(value, parent[child][:type])
-            else
-              parent[child][:value] = value
-              parent[child][:type]  = Cockpit.get_type(value)
-            end
-          else
-            parent[child] = value
-          end
-        end
-        parent[child]
-      end
-      
-      def method_missing(meth, *args, &block)
-        options = args.extract_options!
-        meth    = meth.to_s.gsub("=", "").to_sym
-        if args.empty?
-          if self.has_key?(meth)
-            found = self[meth]
-          else
-            found = get(meth).set_attributes(options)
-          end
-          found = found.instance_eval(&block) if block_given?
-          found
-        else
-          get(meth).set_attributes({:type => Cockpit.get_type(args.first)}.merge(options).merge(:value => args.first))
-        end
-      end
-      
-    private
-      def clone(object)
-        (object.respond_to?(:dup) ? object.dup : object) rescue object
-      end
-  end
-end

data/rails/init.rb

@@ -1 +0,0 @@
-require 'cockpit'

data/test/test_settings.rb

@@ -1,228 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class SettingsTest < ActiveSupport::TestCase
-  
-  context "Settings" do
-    
-    setup do
-      Settings.store = :memory
-      Settings.set(:lance => "first", :dane => 2)
-    end
-    
-    should "have have values" do
-      desired_result = {
-        :lance => {
-          :type => :string,
-          :value => "first"
-        },
-        :dane => {
-          :type => :integer,
-          :value => 2
-        }
-      }
-      assert_equal(desired_result, Settings.tree)
-    end
-    
-    context "get" do
-      
-      setup do
-        Settings.clear
-        Settings.set(:lance => "first", :dane => 2)
-      end
-      
-      should "be able to get values" do
-        assert_equal "first", Settings.get(:lance).value
-        assert_equal :string, Settings.get(:lance).value_type
-        assert_equal :integer, Settings.get(:dane).value_type
-      end
-      
-      should "be able ot get values by using string" do
-        assert_equal "first", Settings.get("lance").value
-      end
-      
-      should "be able to get values using all syntax" do
-        assert_equal "first", Settings.get("lance").value
-        assert_equal "first", Settings("lance").value
-        assert_equal "first", Settings["lance"].value
-        assert_equal "first", Settings.lance.value
-      end
-      
-      should "return empty TreeHash if value doesn't exist" do
-        assert_equal({}, Settings.get("nope"))
-        assert_equal false, Settings.get("nope").nil?
-        assert Settings.get("nope").empty?
-        assert Settings.get("nope").blank?
-        assert_equal({}, Settings["asset.thumb.random"].value)
-      end
-      
-      should "raise an error if we use exclamation on 'get!'" do
-        assert_raise(RuntimeError) { Settings.get!("nope") }
-      end
-    end
-    
-    context "set" do
-      
-      setup do
-        Settings.clear
-      end
-      
-      should "be able to set new values" do
-        Settings.set(:name => "value")
-        assert_equal "value", Settings[:name].value
-      end
-      
-      should "be able to set using []=" do
-        Settings[:name] = "value"
-        assert_equal "value", Settings[:name].value
-      end
-      
-      should "not be able to set a value if it's a string" do
-        assert_equal nil, Settings.set("set value")
-      end
-      
-      should "be able to set a value using parentheses syntax" do
-        Settings("path.to.hash" => "me")
-        assert_equal "me", Settings("path.to.hash").value
-      end
-      
-    end
-    
-    context "nested values" do
-      
-      should "be able to set nested value by string key" do
-        Settings["a.nested.string"] = "value"
-        assert_equal "value", Settings["a.nested.string"].value
-        assert_kind_of Cockpit::TreeHash, Settings["a.nested"]
-      end
-      
-      should "be able to change string to further nested hash" do
-        Settings["a.nested.string"] = "value"
-        assert_equal "value", Settings["a.nested.string"].value
-        Settings["a.nested.string.with.further.depth"] = "value"
-        assert_equal "value", Settings["a.nested.string.with.further.depth"].value
-        Settings["a.nested.string"] = "value"
-        assert_equal "value", Settings["a.nested.string"].value
-      end
-      
-    end
-    
-    context "with dsl" do
-      
-      setup do
-        Settings.clear
-        Settings do
-          asset :title => "Asset (and related) Settings" do
-            thumb do
-              width 100, :tip => "Thumb's width"
-              height 100, :tip => "Thumb's height"
-            end
-          end
-        end
-      end
-      
-      should "property should be a hash of values" do
-        desired_result = {
-          :type => :integer,
-          :value => 100,
-          :tip => "Thumb's width"
-        }
-        assert_equal(desired_result, Settings["asset.thumb.width"])
-      end
-      
-      should "be able to call 'value' on object" do
-        assert_equal 100, Settings["asset.thumb.width.value"]
-        assert_equal 100, Settings["asset.thumb.width"].value
-      end
-      
-      should "be able to call 'tip' if it has tooltip" do
-        assert_equal "Thumb's width", Settings["asset.thumb.width"].tip
-      end
-      
-      should "be able to call 'tip' through chain" do
-        assert_equal "Thumb's width", Settings.asset.thumb.width.tip
-      end
-      
-      context "should be able to take a lambda as a value" do
-        
-        setup do
-          Settings.clear
-          @languages = %w(English Italian Spanish)
-          Settings do
-            site :title => "Default Site Settings" do
-              languages :value => lambda { %w(English Italian Spanish) }
-            end
-          end
-        end
-        
-        should "have a proc as a value" do
-          assert_kind_of Proc, Settings["site.languages.value"]
-        end
-        
-        should "be able to call the proc" do
-          assert @languages, Settings["site.languages.value"].call
-        end
-                
-      end
-      
-      context "should be able to take a Proc.new as a value" do
-        setup do
-          Settings.clear
-          @timezones = %w(pacific central eastern)
-          Settings do
-            site :title => "Default Site Settings" do
-              timezones :value => Proc.new { %w(pacific central eastern) }
-            end
-          end
-        end
-        
-        should "have a proc as a value" do
-          assert_kind_of Proc, Settings["site.timezones.value"]
-        end
-        
-        should "be able to call the proc" do
-          assert @timezones, Settings["site.timezones.value"].call
-        end
-      end
-      
-      context "should be able to take a large dsl and make something of it!" do
-        
-        setup do
-          Settings.clear
-          load_settings
-        end
-        
-        should "find the nested teaser" do
-          assert_equal 2, Settings["site.teasers.right"].value
-        end
-        
-      end
-      
-    end
-    
-    context "setting categories" do
-      
-      setup do
-        Settings.clear
-        load_settings
-      end
-      
-      should "be able to get settings by category" do
-        [:site, :asset].each do |type|
-          assert Settings[type].keys
-        end
-      end
-
-      should "traverse categories" do
-        Settings(:site).each_setting do |key, attributes, value|
-          assert attributes
-          #puts "Key: #{key.to_s}, Attributes: #{attributes.inspect}, Value: #{value.inspect}"
-        end
-      end
-      
-    end
-    
-    teardown { Settings.clear }
-    
-  end
-  
-end

data/test/test_settings_in_database.rb

@@ -1,153 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class SettingsTest < ActiveSupport::TestCase
-  
-  context "Database Store" do
-    
-    setup do
-      Settings.clear
-      Settings.store = :db
-    end
-    
-    should "have a db as a store" do
-      assert_kind_of Cockpit::Store::Database, Settings.store
-    end
-    
-    context "save to the database" do
-      
-      setup do
-        Settings["lantial"] = "to database"
-        Settings["pollard"] = "another"
-      end
-      
-      should "have saved lance into the database" do
-        assert_equal "to database", Setting.find_by_key("lantial").value
-      end
-      
-      should "be able to change a database record through tree" do
-        assert_equal "another", Setting.find_by_key("pollard").value
-        Settings["pollard"] = "first change"
-        assert_equal "first change", Setting.find_by_key("pollard").value
-      end
-      
-      should "NOT be able to change a database record independently of the tree" do
-        setting = Setting.find_by_key("pollard")
-        assert_equal "another", setting.value
-        setting.value = "changed!"
-        setting.save
-        
-        assert_equal "changed!", Setting.find_by_key("pollard").value
-        assert_equal "changed!", Settings["pollard"].value
-      end
-      
-      context "get value" do
-        
-        setup do
-          Settings.store = :db
-          Settings.clear(:hard => true)
-        end
-        
-        should "be able to get a previously created setting from the db" do
-          assert_equal Cockpit::TreeHash.new, Settings.tree
-          Setting.create(:key => "lantial", :value => "custom value")
-          assert_equal "custom value", Settings["lantial"].value
-          assert_equal({:lantial => {:type => :string, :value => "custom value"}}, Settings.tree)
-        end
-        
-        should "be able to save objects using other syntax" do
-          key = "im.a.nested.key"
-          value = "wow"
-          assert_equal nil, Setting.find_by_key(key)
-          Settings.im.a.nested.key = value
-          assert_equal value, Settings(key).value
-          # PENDING!
-          # assert_equal value, Setting.find_by_key(key)
-          Settings("im.nesting.myself" => "here")
-          assert_equal "here", Setting.find_by_key("im.nesting.myself").value
-          Settings["me.too.please"] = "let me in"
-          assert_equal "let me in", Setting.find_by_key("me.too.please").value
-          Settings.set("finally.me" => "too")
-          assert_equal "too", Setting.find_by_key("finally.me").value
-        end
-        
-      end
-      
-      context "should not save large tree to database" do
-        
-        setup do
-          Settings.clear
-          load_settings
-        end
-        
-        should "find nested objects in database" do
-          assert_equal nil, Setting.find_by_key("site.title")
-        end
-        
-      end
-      
-      context "should find setting" do
-        
-        setup do
-          Settings.store = :db
-          Settings("lantial" => "saved")
-        end
-        
-        should "find the thing" do
-          setting = Setting.find("lantial")
-          assert setting
-        end
-        
-        teardown do
-          Settings.store = :memory
-        end
-        
-      end
-      
-    end
-    
-    should "be able to switch the store without modifying the tree" do
-      # pending
-    end
-    
-    context "type casting" do
-      
-      setup do
-        @datetime = DateTime.now
-        @time     = Time.now
-        Settings.store = :db
-        Setting.detonate
-        Settings["a.string"] = "string"
-        Settings["a.boolean"] = true
-        Settings["a.false_boolean"] = false
-        Settings["a.integer"] = 10
-        Settings["a.float"] = 10.11
-        Settings["a.datetime"] = @datetime
-        Settings["a.time"] = @time
-      end
-      
-      should "parse types" do
-        assert_equal "string",        Setting.find("a.string").value
-        assert_equal true,            Setting.find("a.boolean").value
-        assert_equal false,           Setting.find("a.false_boolean").value
-        assert_equal 10,              Setting.find("a.integer").value
-        assert_equal 10.11,           Setting.find("a.float").value
-        assert_equal @time.to_s,      Setting.find("a.time").value.to_s
-      end
-      
-      should "parse datetime" do
-        # close but not quite
-        # assert_equal @datetime, Setting.find("a.datetime").value
-        # pending
-      end
-      
-      teardown do
-        Setting.detonate
-      end
-      
-    end
-    
-    teardown { Settings.clear }
-    
-  end
-  
-end