spice 0.8.0 → 1.0.0.pre

data/lib/spice/cookbook_version.rb

@@ -0,0 +1,43 @@
+require 'spice/persistence'
+
+module Spice
+  class CookbookVersion
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "cookbooks"
+
+    attribute :name, String
+    attribute :version, String
+    attribute :definitions, Array, :default => []
+    attribute :attributes, Array, :default => []
+    attribute :files, Array, :default => []
+    attribute :providers, Array, :default => []
+    attribute :metadata, Hash, :default => {}
+    attribute :libraries, Array, :default => []
+    attribute :templates, Array, :default => []
+    attribute :resources, Array, :default => []
+    attribute :attributes, Array, :default => []
+    attribute :json_class, String, :default => "Chef::CookbookVersion"
+    attribute :cookbook_name, String
+    attribute :version, String
+    attribute :recipes, Array, :default => []
+    attribute :root_files, Array, :default => []
+    attribute :chef_type, String, :default => "cookbook_version"
+    
+    validates_presence_of :name
+    
+    def do_post
+      connection.put("/cookbooks/#{cookbook_name}/#{version}", attributes)
+    end
+    
+    def do_put
+      connection.put("/cookbooks/#{cookbook_name}/#{version}", attributes)
+    end
+    
+    def do_delete
+      connection.delete("/cookbooks/#{cookbook_name}/#{version}")
+    end
+  end
+end

data/lib/spice/data_bag.rb

@@ -1,132 +1,28 @@
+require 'spice/persistence'
+
 module Spice
-  class DataBag < Spice::Chef
-    # Get a list of all data bags in the following syntax
-    #     Spice::DataBag.all
-    #    
-    # @param [Hash] options the options hash. Currently does nothing
-    def self.all(options={})
-      connection.get("/data")
-    end
-    
-    # An alternative format for showing the contents of a data bag
-    # @example Retrieve the id and uri of items in a data bag called "users"
-    #   Spice::DataBag["users"] # => {"adam":"http://localhost:4000/data/users/adam"}
-    def self.[](name)
-      connection.get("/data/#{name}")
-    end
+  class DataBag
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "data"
     
-    # Show the contents of a data bag
-    # @example Retrieve the id and uri of items in a data bag called "users"
-    #   Spice::DataBag.show(:name => "users") # => {"adam":"http://localhost:4000/data/users/adam"}
-    # 
-    # @param [Hash] options The options hash
-    # @option options [String] :name The name of your data bag
-    def self.show(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.get("/data/#{name}")
-    end
-    
-    # Create a a new data bag
-    # 
-    # @example 
-    #   Spice::DataBag.create(:name => "users")
-    #
-    # @param [Hash] options the options hash from which to create a data bag
-    # @option options [String] :name The name of your data bag    
+    attribute :name, String
+    attribute :items, Array, :default => []
     
-    def self.create(options={})
-      connection.post("/data", options)
-    end
-
-    # Delete a data bag
-    # 
-    # @example 
-    #   Spice::DataBag.delete(:name => "users")
-    #
-    # @param [Hash] options the options hash from which to delete a data bag
-    # @option options [String] :name The name of your data bag    
+    validates_presence_of :name
 
-    def self.delete(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.delete("/data/#{name}", options)
+    def self.all
+      connection.data_bags
     end
     
-    # Shows a data bag item
-    # 
-    # @example 
-    #   Spice::DataBag.show_item(:name => "users", :id => "adam")
-    #
-    # @param [Hash] options the options hash from which to create a data bag
-    # @option options [String] :name The name of your data bag    
-    # @option options [String] :id The id of the data bag item
-    
-    def self.show_item(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      raise ArgumentError, "Option :id must be present" unless options[:id]
-      name = options.delete(:name)
-      id = options.delete(:id)
-      connection.get("/data/#{name}/#{id}", options)
-    end
-    
-    # Creates a data bag item
-    # 
-    # @example 
-    #   Spice::DataBag.create_item(:name => "users", :id => "adam", :title => "Supreme Awesomer")
-    #
-    # @param [Hash] options the options hash from which to create a data bag
-    # @option options [String] :name The name of your data bag    
-    # @option options [String] :id The id of the data bag item
-    # 
-    # Any additional keys in the options hash will be used as attributes 
-    # to be stored in the data bag item
-    
-    def self.create_item(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      raise ArgumentError, "Option :id must be present" unless options[:id]
-      name = options.delete(:name)
-      connection.post("/data/#{name}", options)   
-      
+    def self.get(name)
+      connection.data_bag(name)
     end
     
-    # Update a data bag item
-    # 
-    # @example 
-    #   Spice::DataBag.update_item(:name => "users", :id => "adam", :title => "Supreme Awesomer")
-    #
-    # @param [Hash] options the options hash from which to update a data bag
-    # @option options [String] :name The name of your data bag    
-    # @option options [String] :id The id of the data bag item
-    # 
-    # Any additional keys in the options hash will be used as attributes 
-    # to be stored in the data bag item
-    
-    def self.update_item(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      raise ArgumentError, "Option :id must be present" unless options[:id]  
-      name = options.delete(:name)
-      id = options.delete(:id) 
-      connection.put("/data/#{name}/#{id}", options)   
-    end
-    
-    # Delete a data bag item
-    # 
-    # @example 
-    #   Spice::DataBag.delete_item(:name => "users", :id => "adam")
-    #
-    # @param [Hash] options the options hash from which to delete a data bag
-    # @option options [String] :name The name of your data bag    
-    # @option options [String] :id The id of the data bag item
-    #
-    
-    def self.delete_item(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      raise ArgumentError, "Option :id must be present" unless options[:id]
-      name = options.delete(:name)
-      id = options.delete(:id) 
-      connection.delete("/data/#{name}/#{id}", options)   
-         
+    def do_post
+      response = connection.post("/data", attributes)
     end
   end
 end

data/lib/spice/data_bag_item.rb

@@ -0,0 +1,35 @@
+module Spice
+  class DataBagItem
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "data"
+    
+    attribute :_id, String
+    attribute :data, Hash, :default => {}    
+    attribute :name, String
+    
+    validates_presence_of :_id, :name, :data
+    
+    def self.get(name, id)
+      connection.data_bag_item(name, id)
+    end
+    
+    def do_post
+      attrs = data.dup
+      attrs['id'] = attributes['_id']
+      connection.post("/data/#{name}", attrs)
+    end
+    
+    def do_put
+      attrs = data.dup
+      attrs['id'] = attributes['_id']
+      connection.put("/data/#{name}/#{_id}", attrs)
+    end
+    
+    def do_delete
+      connection.delete("/data/#{name}/#{_id}")
+    end
+  end
+end

data/lib/spice/environment.rb

@@ -1,85 +1,21 @@
-module Spice
-  class Environment < Spice::Chef
-    # Get a list of all data bags in the following syntax
-    #     Spice::Environment.all
-    #    
-    # @param [Hash] options the options hash. Currently does nothing
-    def self.all(options={})
-      connection.get("/environments")
-    end
-    
-    # An alternative format for showing the contents of a data bag
-    # @example Retrieve the id and uri of items in a data bag called "users"
-    #   Spice::Environment["users"] # => {"adam":"http://localhost:4000/data/users/adam"}
-    def self.[](name)
-      connection.get("/environments/#{name}")
-    end
-    
-    # Show the contents of a data bag
-    # @example Retrieve the id and uri of items in a data bag called "users"
-    #   Spice::Environment.show(:name => "users") # => {"adam":"http://localhost:4000/data/users/adam"}
-    # 
-    # @param [Hash] options The options hash
-    # @option options [String] :name The name of your data bag
-    def self.show(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.get("/environments/#{name}")
-    end
-    
-    # Create a a new data bag
-    # 
-    # @example 
-    #   Spice::Environment.create(:name => "users")
-    #
-    # @param [Hash] options the options hash from which to create a data bag
-    # @option options [String] :name The name of your data bag    
-    
-    def self.create(options={})
-      options[:chef_type] ||= "environment"
-      options[:json_class] ||= "Chef::Environment"
-      options[:attributes] ||= {}
-      options[:description] ||= ""
-      options[:cookbook_versions] ||= {}
-      connection.post("/environments", options)
-    end
-
-    # Delete a data bag
-    # 
-    # @example 
-    #   Spice::Environment.delete(:name => "users")
-    #
-    # @param [Hash] options the options hash from which to delete a data bag
-    # @option options [String] :name The name of your data bag    
+require 'spice/persistence'
 
-    def self.delete(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.delete("/environments/#{name}", options)
-    end
-    
-    # Shows a data bag item
-    # 
-    # @example 
-    #   Spice::Environment.show_item(:name => "users", :id => "adam")
-    #
-    # @param [Hash] options the options hash from which to create a data bag
-    # @option options [String] :name The name of your data bag    
-    # @option options [String] :id The id of the data bag item
+module Spice
+  class Environment
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "environments"
     
-    def self.show_cookbook(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      raise ArgumentError, "Option :cookbook must be present" unless options[:cookbook]
-      name = options.delete(:name)
-      cookbook = options.delete(:cookbook)
-      connection.get("/environments/#{name}/cookbooks/#{cookbook}", options)
-    end
+    attribute :name, String
+    attribute :description, String
+    attribute :attrs, Hash, :default => {}
+    attribute :json_class, String, :default => "Chef::Environment"
+    attribute :chef_type, String, :default => "environment"
+    attribute :cookbook_versions, Hash, :default => {}
     
-    def self.list_cookbooks(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.get("/environments/#{name}/cookbooks", options)
-    end
+    validates_presence_of :name, :description
 
   end
 end

data/lib/spice/error.rb

@@ -0,0 +1,30 @@
+module Spice
+  class Error < StandardError
+    attr_reader :http_headers
+    
+    def initialize(message, http_headers)
+      @http_headers = Hash[http_headers]
+      super(message)
+    end
+    
+  end
+  
+  class BadRequest < Error
+  end
+  
+  class Unauthorized < Error
+  end
+  
+  class Forbidden < Error
+  end
+  
+  class NotFound < Error
+  end
+  
+  class NotAcceptable < Error
+  end
+  
+  class Conflict < Error
+  end
+  
+end

data/lib/spice/node.rb

@@ -1,40 +1,23 @@
+require 'spice/persistence'
+
 module Spice
-  class Node < Spice::Chef
-    def self.all(options={})
-      connection.get("/nodes")
-    end
+  class Node
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "nodes"
     
-    def self.[](name)
-      connection.get("/nodes/#{name}")
-    end
-    
-    def self.show(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.get("/nodes/#{name}")
-    end
-    
-    def self.create(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      options[:chef_type] ||= "node"
-      options[:json_class] ||= "Chef::Node"
-      options[:attributes] ||= {}
-      options[:overrides] ||= {}
-      options[:defaults] ||={}
-      options[:run_list] ||= []
-      connection.post("/nodes", options)
-    end
-    
-    def self.update(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.put("/nodes/#{name}", options)
-    end
-    
-    def self.delete(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.delete("/nodes/#{name}", options)
-    end
+    attribute :name, String
+    attribute :chef_type, String, :default => "node"
+    attribute :json_class, String, :default => "Chef::Node"
+    attribute :normal, Hash, :default => {}
+    attribute :override, Hash, :default => {}
+    attribute :default, Hash, :default => {}
+    attribute :automatic, Hash, :default => {}
+    attribute :run_list, Array, :default => []
+        
+    validates_presence_of :name
+
   end
 end

data/lib/spice/persistence.rb

@@ -0,0 +1,42 @@
+module Spice
+  module Persistence
+    def self.included(base)
+      base.after_create :do_post
+      base.after_update :do_put
+      base.after_destroy :do_delete
+    end
+
+    def endpoint(ep=nil)
+      @endpoint = ep if !ep.nil?
+      @endpoint
+    end
+
+    def all(options={})
+      connection.send(endpoint, options)
+    end
+
+    def get(options)
+      connection.send(endpoint, options).first
+    end
+
+    def connection
+      Spice.connection
+    end
+
+    def do_post
+      response = connection.post("/#{self.class.endpoint}", attributes)
+      update_attributes(response.body)
+      response = connection.get("/#{self.class.endpoint}/#{name}")
+      update_attributes(response.body)
+    end
+
+    def do_put
+      connection.put("/#{self.class.endpoint}/#{name}", attributes)
+    end
+
+    def do_delete
+      connection.delete("/#{self.class.endpoint}/#{name}")
+    end
+
+  end
+end