cistern 0.0.3 → 0.1.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.rspec

data/Gemfile

@@ -2,3 +2,16 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in cistern.gemspec
 gemspec
+
+group :test do
+  gem "rspec", "~> 2.0"
+  gem "guard-rspec"
+  gem "rake"
+  gem 'rb-fsevent', '~> 0.9.1'
+end
+
+group :formatters do
+  gem 'formatador'
+  gem 'awesome_print'
+end
+

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -1,5 +1,7 @@
 # Cistern
 
+[![Build Status](https://secure.travis-ci.org/lanej/cistern.png)](http://travis-ci.org/lanej/cistern)
+
 TODO: Write a gem description
 
 ## Installation
@@ -20,10 +22,14 @@ Or install it yourself as:
 
 TODO: Write usage instructions here
 
+## Releasing
+
+    $ gem bump -trv (major|minor|patch)
+
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+. Create new Pull Request

data/Rakefile

@@ -1,2 +1,5 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:default)

data/cistern.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["me@joshualane.com"]
   gem.description   = %q{API client framework extracted from Fog}
   gem.summary       = %q{API client framework}
-  gem.homepage      = ""
+  gem.homepage      = "http://joshualane.com/cistern"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -14,6 +14,4 @@ Gem::Specification.new do |gem|
   gem.name          = "cistern"
   gem.require_paths = ["lib"]
   gem.version       = Cistern::VERSION
-
-  gem.add_dependency "formatador"
 end

data/lib/cistern/attributes.rb

@@ -1,203 +1,173 @@
-module Cistern
-  module Attributes
-    module ClassMethods
-
-      def _load(marshalled)
-        new(Marshal.load(marshalled))
-      end
-
-      def aliases
-        @aliases ||= {}
-      end
-
-      def attributes
-        @attributes ||= []
-      end
+module Cistern::Attributes
+  def self.parsers
+    @parsers ||= {
+      :string  => lambda{|v,opts| v.to_s},
+      :time    => lambda{|v,opts| v.is_a?(Time) ? v : v && Time.parse(v.to_s)},
+      :integer => lambda{|v,opts| v && v.to_i},
+      :float   => lambda{|v,opts| v && v.to_f},
+      :array   => lambda{|v,opts| [*v]},
+      :boolean => Proc.new do |v, opts|
+        {
+          true    => true,
+          "true"  => true,
+          "1"     => true,
+          1       => true,
+          false   => false,
+          "false" => false,
+          "0"     => false,
+          0       => false,
+        }[v]
+      end,
+    }
+  end
 
-      def attribute(name, options = {})
-        class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}
-            attributes[:#{name}]
-          end
-          EOS
-        case options[:type]
-        when :boolean
-          class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}=(new_#{name})
-            attributes[:#{name}] = case new_#{name}
-            when true,'true'
-              true
-            when false,'false'
-              false
-            end
-          end
-          EOS
-        when :float
-          class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}=(new_#{name})
-            attributes[:#{name}] = new_#{name} && new_#{name}.to_f
-          end
-          EOS
-        when :integer
-          class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}=(new_#{name})
-            attributes[:#{name}] = new_#{name} && new_#{name}.to_i
-          end
-          EOS
-        when :string
-          class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}=(new_#{name})
-            attributes[:#{name}] = new_#{name} && new_#{name}.to_s
-          end
-          EOS
-        when :time
-          class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}=(new_#{name})
-              attributes[:#{name}] = if new_#{name}.nil? || new_#{name} == "" || new_#{name}.is_a?(Time)
-                new_#{name}
-              else
-                Time.parse(new_#{name})
-              end
-            end
-          EOS
-        when :array
-          class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}=(new_#{name})
-              attributes[:#{name}] = [*new_#{name}]
-            end
-          EOS
-        else
-          if squash = options[:squash]
-            class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}=(new_data)
-              if new_data.is_a?(::Hash)
-                if new_data.has_key?(:'#{squash}')
-                  attributes[:#{name}] = new_data[:'#{squash}']
-                elsif new_data.has_key?("#{squash}")
-                  attributes[:#{name}] = new_data["#{squash}"]
-                else
-                  attributes[:#{name}] = [ new_data ]
-                end
-              else
-                attributes[:#{name}] = new_data
-              end
-            end
-            EOS
+  def self.transforms
+    @transforms ||= {
+      :squash  => Proc.new do |k, v, options|
+        squash = options[:squash]
+        if v.is_a?(::Hash)
+          if v.key?(squash.to_s.to_sym)
+            v[squash.to_s.to_sym]
+          elsif v.has_key?(squash.to_s)
+            v[squash.to_s]
           else
-            class_eval <<-EOS, __FILE__, __LINE__
-              def #{name}=(new_#{name})
-                attributes[:#{name}] = new_#{name}
-              end
-            EOS
+            v
           end
+        else v
         end
-        @attributes ||= []
-        @attributes |= [name]
-        for new_alias in [*options[:aliases]]
-          aliases[new_alias] = name
-        end
-      end
+      end,
+      :none => lambda{|k, v, opts| v},
+    }
+  end
 
-      def identity(name, options = {})
-        @identity = name
-        self.attribute(name, options)
-      end
+  def self.default_parser
+    @default_parser ||= lambda{|v, opts| v}
+  end
 
-      def ignore_attributes(*args)
-        @ignored_attributes = args
-      end
+  module ClassMethods
+    def _load(marshalled)
+      new(Marshal.load(marshalled))
+    end
 
-      def ignored_attributes
-        @ignored_attributes ||= []
-      end
+    def aliases
+      @aliases ||= {}
+    end
 
+    def attributes
+      @attributes ||= []
     end
 
-    module InstanceMethods
+    def attribute(name, options = {})
+      parser = Cistern::Attributes.parsers[options[:type]] ||
+        options[:parser] ||
+        Cistern::Attributes.default_parser
+      transform = Cistern::Attributes.transforms[options[:squash] ? :squash : :none] ||
+        Cistern::Attributes.default_transform
 
-      def _dump(level)
-        Marshal.dump(attributes)
+      self.send(:define_method, name) do
+        attributes[name.to_s.to_sym]
       end
 
-      def attributes
-        @attributes ||= {}
+      self.send(:define_method, "#{name}=") do |value|
+        transformed = transform.call(name, value, options)
+        attributes[name.to_s.to_sym]= parser.call(transformed, options)
       end
 
-      def dup
-        copy = super
-        copy.dup_attributes!
-        copy
-      end
+      @attributes ||= []
+      @attributes |= [name]
 
-      def identity
-        send(self.class.instance_variable_get('@identity'))
+      for new_alias in [*options[:aliases]]
+        aliases[new_alias] = name
       end
+    end
 
-      def identity=(new_identity)
-        send("#{self.class.instance_variable_get('@identity')}=", new_identity)
-      end
+    def identity(name, options = {})
+      @identity = name
+      self.attribute(name, options)
+    end
 
-      def merge_attributes(new_attributes = {})
-        for key, value in new_attributes
-          unless self.class.ignored_attributes.include?(key)
-            if aliased_key = self.class.aliases[key]
-              send("#{aliased_key}=", value)
-            elsif self.respond_to?("#{key}=",true)
-              send("#{key}=", value)
-            else
-              attributes[key] = value
-            end
-          end
-        end
-        self
-      end
+    def ignore_attributes(*args)
+      @ignored_attributes = args
+    end
 
-      def new_record?
-        !identity
-      end
+    def ignored_attributes
+      @ignored_attributes ||= []
+    end
+  end
 
-      # check that the attributes specified in args exist and is not nil
-      def requires(*args)
-        missing = missing_attributes(args)
-        if missing.length == 1
-          raise(ArgumentError, "#{missing.first} is required for this operation")
-        elsif missing.any?
-          raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
-        end
-      end
+  module InstanceMethods
+    def _dump(level)
+      Marshal.dump(attributes)
+    end
 
-      def requires_one(*args)
-        missing = missing_attributes(args)
-        if missing.length == args.length
-          raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
-        end
-      end
+    def attributes
+      @attributes ||= {}
+    end
 
-      protected
+    def attributes=(attributes)
+      @attributes = attributes
+    end
+
+    def dup
+      copy = super
+      copy.attributes= copy.attributes.dup
+      copy
+    end
 
-      def missing_attributes(args)
-        missing = []
-        for arg in [:connection] | args
-          unless send("#{arg}") || attributes.has_key?(arg)
-            missing << arg
+    def identity
+      send(self.class.instance_variable_get('@identity'))
+    end
+
+    def identity=(new_identity)
+      send("#{self.class.instance_variable_get('@identity')}=", new_identity)
+    end
+
+    def merge_attributes(new_attributes = {})
+      for key, value in new_attributes
+        unless self.class.ignored_attributes.include?(key)
+          if aliased_key = self.class.aliases[key]
+            send("#{aliased_key}=", value)
+          elsif self.respond_to?("#{key}=", true)
+            send("#{key}=", value)
+          else
+            attributes[key] = value
           end
         end
-        missing
       end
+      self
+    end
 
-      def dup_attributes!
-        @attributes = @attributes.dup
+    def new_record?
+      !identity
+    end
+
+    # check that the attributes specified in args exist and is not nil
+    def requires(*args)
+      missing = missing_attributes(args)
+      if missing.length == 1
+        raise(ArgumentError, "#{missing.first} is required for this operation")
+      elsif missing.any?
+        raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+      end
+    end
+
+    def requires_one(*args)
+      missing = missing_attributes(args)
+      if missing.length == args.length
+        raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
       end
+    end
 
-      private
+    protected
 
-      def remap_attributes(attributes, mapping)
-        for key, value in mapping
-          if attributes.key?(key)
-            attributes[value] = attributes.delete(key)
-          end
+    def missing_attributes(args)
+      missing = []
+      for arg in [:connection] | args
+        unless send("#{arg}") || attributes.has_key?(arg)
+          missing << arg
         end
       end
+      missing
     end
   end
 end

data/lib/cistern/collection.rb

@@ -2,29 +2,23 @@ class Cistern::Collection < Array
   extend Cistern::Attributes::ClassMethods
   include Cistern::Attributes::InstanceMethods
 
-  Array.public_instance_methods(false).each do |method|
-    unless [:reject, :select, :slice].include?(method.to_sym)
-      class_eval <<-EOS, __FILE__, __LINE__
-        def #{method}(*args)
-          unless @loaded
-            lazy_load
-          end
-          super
-        end
-      EOS
+  %w[reject select slice].each do |method|
+    define_method(method) do |*args, &block|
+      unless @loaded
+        lazy_load
+      end
+      data = super(*args, &block)
+      self.clone.clear.concat(data)
     end
   end
 
-  %w[reject select slice].each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args)
-        unless @loaded
-          lazy_load
-        end
-        data = super
-        self.clone.clear.concat(data)
+  %w[first last].each do |method|
+    define_method(method) do
+      unless @loaded
+        lazy_load
       end
-    EOS
+      super()
+    end
   end
 
   def self.model(new_model=nil)
@@ -80,40 +74,12 @@ class Cistern::Collection < Array
     self
   end
 
-  def inspect
-    Thread.current[:formatador] ||= Formatador.new
-    data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
-    Thread.current[:formatador].indent do
-      unless self.class.attributes.empty?
-        data << "#{Thread.current[:formatador].indentation}"
-        data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
-        data << "\n"
-      end
-      data << "#{Thread.current[:formatador].indentation}["
-      unless self.empty?
-        data << "\n"
-        Thread.current[:formatador].indent do
-          data << self.map {|member| member.inspect}.join(",\n")
-          data << "\n"
-        end
-        data << Thread.current[:formatador].indentation
-      end
-      data << "]\n"
-    end
-    data << "#{Thread.current[:formatador].indentation}>"
-    data
-  end
-
   def reload
     clear
     lazy_load
     self
   end
 
-  def table(attributes = nil)
-    Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
-  end
-
   private
 
   def lazy_load

data/lib/cistern/formatter.rb

@@ -0,0 +1,5 @@
+module Cistern::Formatter
+  autoload :AwesomePrint, 'cistern/formatters/awesome_print'
+  autoload :Default, 'cistern/formatters/default'
+  autoload :Formatador, 'cistern/formatters/formatador'
+end

data/lib/cistern/formatters/awesome_print.rb

@@ -0,0 +1,31 @@
+require 'awesome_print'
+
+module Cistern::Formatter::AwesomePrint
+  def self.call(model)
+    model.ai
+  end
+end
+
+module AwesomePrint::Cistern
+  def self.included(base)
+    base.send :alias_method, :cast_without_cistern, :cast
+    base.send :alias_method, :cast, :cast_with_cistern
+  end
+
+  def cast_with_cistern(object, type)
+    cast = cast_without_cistern(object, type)
+    if object.is_a?(Cistern::Model)
+      cast = :cistern_model
+    end
+    cast
+  end
+
+  # Format Cistern::Model
+  #------------------------------------------------------------------------------
+  def awesome_cistern_model(object)
+    data = object.attributes.keys.inject({}){|r,k| r.merge(k => object.send(k))}
+    "#{object} " << awesome_hash(data)
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::Cistern)

data/lib/cistern/formatters/default.rb

@@ -0,0 +1,5 @@
+module Cistern::Formatter::Default
+  def self.call(obj)
+    "#<%s:0x%x attributes={%s}>" % [obj.class, obj.object_id.abs*2, obj.attributes.map{|k,v| "#{k}:#{v.inspect}"}.join(",")]
+  end
+end

data/lib/cistern/formatters/formatador.rb

@@ -0,0 +1,44 @@
+require 'formatador'
+
+module Cistern::Formatter::Formatador
+  def self.call(model)
+    Thread.current[:formatador] ||= Formatador.new
+    data = "#{Thread.current[:formatador].indentation}<#{model.class.name}"
+    Thread.current[:formatador].indent do
+      unless model.class.attributes.empty?
+        data << "\n#{Thread.current[:formatador].indentation}"
+        data << model.class.attributes.map {|attribute| "#{attribute}=#{model.send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+      end
+    end
+    data << "\n#{Thread.current[:formatador].indentation}>"
+    data
+  end
+
+  def inspect
+    Thread.current[:formatador] ||= Formatador.new
+    data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
+    Thread.current[:formatador].indent do
+      unless self.class.attributes.empty?
+        data << "#{Thread.current[:formatador].indentation}"
+        data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+        data << "\n"
+      end
+      data << "#{Thread.current[:formatador].indentation}["
+      unless self.empty?
+        data << "\n"
+        Thread.current[:formatador].indent do
+          data << self.map {|member| member.inspect}.join(",\n")
+          data << "\n"
+        end
+        data << Thread.current[:formatador].indentation
+      end
+      data << "]\n"
+    end
+    data << "#{Thread.current[:formatador].indentation}>"
+    data
+  end
+
+  def table(attributes = nil)
+    Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
+  end
+end

data/lib/cistern/model.rb

@@ -4,23 +4,21 @@ class Cistern::Model
 
   attr_accessor :collection, :connection
 
-  def initialize(attributes={})
-    merge_attributes(attributes)
+  def self.formatter
+    @formatter ||= Cistern::Formatter::Default
+  end
+
+  def self.formatter=(formatter)
+    @formatter = formatter
   end
 
   def inspect
-    Thread.current[:formatador] ||= Formatador.new
-    data = "#{Thread.current[:formatador].indentation}<#{self.class.name}"
-    Thread.current[:formatador].indent do
-      unless self.class.attributes.empty?
-        data << "\n#{Thread.current[:formatador].indentation}"
-        data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
-      end
-    end
-    data << "\n#{Thread.current[:formatador].indentation}>"
-    data
+    self.class.formatter.call(self)
   end
 
+  def initialize(attributes={})
+    merge_attributes(attributes)
+  end
 
   def save
     raise NotImplementedError

data/lib/cistern/version.rb

@@ -1,3 +1,3 @@
 module Cistern
-  VERSION = "0.0.3"
+  VERSION = "0.1.2"
 end

data/lib/cistern.rb

@@ -1,5 +1,5 @@
 require 'cistern/version'
-require 'formatador'
+require 'time'
 
 module Cistern
   Error = Class.new(StandardError)
@@ -12,6 +12,9 @@ module Cistern
   require 'cistern/model'
   require 'cistern/service'
 
+  autoload :Formatter, 'cistern/formatter'
+
+
   def self.timeout=(timeout)
     @timeout= timeout
   end

data/spec/collection_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "Cistern::Collection" do
+  class SampleCollectionModel < Cistern::Model
+    identity :id
+    attribute :name
+  end
+  class SampleCollection < Cistern::Collection
+    model SampleCollectionModel
+
+    def all
+      self.load([{id: 1}, {id: 3, name: "tom"}, {id: 2}])
+    end
+  end
+
+  it "should give first" do
+    SampleCollection.new.first.should == SampleCollectionModel.new(id: 1)
+  end
+
+  it "should give last" do
+    SampleCollection.new.last.should == SampleCollectionModel.new(id: 2)
+  end
+
+  it "should reject" do
+    SampleCollection.new.reject{|m| m.id == 2}.should == [SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3)]
+  end
+
+  it "should select" do
+    SampleCollection.new.select{|m| m.id == 2}.should == [SampleCollectionModel.new(id: 2)]
+  end
+
+  it "should slice" do
+    SampleCollection.new.slice(0,2).should == [SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3, name: "tom")]
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe "Cistern::Model" do
+
+  it "should duplicate a model" do
+    class DupSpec < Cistern::Model
+      identity :id
+      attribute :name
+      attribute :properties
+    end
+
+    model = DupSpec.new(id: 1, name: "string", properties: {value: "something", else: "what"})
+    duplicate = model.dup
+
+    duplicate.should == model
+    duplicate.should_not eql model
+
+    model.name= "anotherstring"
+    duplicate.name.should == "string"
+  end
+
+  context "attribute parsing" do
+    class TypeSpec < Cistern::Model
+      identity :id
+      attribute :name, type: :string
+      attribute :created_at, type: :time
+      attribute :flag, type: :boolean
+      attribute :list, type: :array
+      attribute :number, type: :integer
+      attribute :floater, type: :float
+      attribute :butternut, type: :integer, aliases: "squash", squash: "id"
+      attribute :custom, parser: lambda{|v, opts| "X!#{v}"}
+    end
+
+    it "should parse string" do
+      TypeSpec.new(name: 1).name.should == "1"
+    end
+
+    it "should parse time" do
+      time = Time.now
+      created_at = TypeSpec.new(created_at: time.to_s).created_at
+      created_at.should be_a(Time)
+      created_at.to_i.should == time.to_i
+    end
+
+    it "should parse boolean" do
+      TypeSpec.new(flag: "false").flag.should be_false
+      TypeSpec.new(flag: "true").flag.should be_true
+      TypeSpec.new(flag: false).flag.should be_false
+      TypeSpec.new(flag: true).flag.should be_true
+      TypeSpec.new(flag: "0").flag.should be_false
+      TypeSpec.new(flag: "1").flag.should be_true
+      TypeSpec.new(flag: 0).flag.should be_false
+      TypeSpec.new(flag: 1).flag.should be_true
+    end
+
+    it "should parse an array" do
+      TypeSpec.new(list: []).list.should == []
+      TypeSpec.new(list: "item").list.should == ["item"]
+    end
+
+    it "should parse a float" do
+      TypeSpec.new(floater: "0.01").floater.should == 0.01
+      TypeSpec.new(floater: 0.01).floater.should == 0.01
+    end
+
+    it "should use custom parser" do
+      TypeSpec.new(custom: "15").custom.should == "X!15"
+    end
+
+    it "should squash and cast" do
+      TypeSpec.new({"squash" => {"id" => "12"}}).butternut.should == 12
+    end
+  end
+
+  context "inspection engine" do
+    class InspectorSpec < Cistern::Model
+      identity :id
+      attribute :name
+    end
+
+    after(:all) do
+      InspectorSpec.formatter= Cistern::Formatter::Default
+    end
+
+    it "should default to default formatter" do
+      InspectorSpec.formatter.should == Cistern::Formatter::Default
+    end
+
+    it "should use default" do
+      InspectorSpec.new(id: 1, name: "name").inspect.should match /#<InspectorSpec:0x[0-9a-f]+ attributes={id:1,name:\"name\"}/
+    end
+
+    it "should use awesome_print" do
+      defined?(AwesomePrint).should be_false # don't require if not used
+      InspectorSpec.formatter= Cistern::Formatter::AwesomePrint
+
+      InspectorSpec.new(id: 1, name: "name").inspect.match /(?x-mi:\#<InspectorSpec:0x[0-9a-f]+>\ {\n\ \ \ \ \ \ :id\x1B\[0;37m\ =>\ \x1B\[0m\x1B\[1;34m1\x1B\[0m,\n\ \ \ \ :name\x1B\[0;37m\ =>\ \x1B\[0m\x1B\[0;33m"name"\x1B\[0m\n})/
+    end
+
+    it "should use formatador" do
+      defined?(Formatador).should be_false # don't require if not used
+      InspectorSpec.formatter= Cistern::Formatter::Formatador
+
+      InspectorSpec.new(id: 1, name: "name").inspect.should == "  <InspectorSpec\n    id=1,\n    name=\"name\"\n  >"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../../lib/cistern', __FILE__)
+
+Bundler.require(:test)
+
+RSpec.configure do
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: formatador
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2012-11-30 00:00:00.000000000 Z
+dependencies: []
 description: API client framework extracted from Fog
 email:
 - me@joshualane.com
@@ -36,6 +20,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
@@ -43,13 +28,20 @@ files:
 - lib/cistern.rb
 - lib/cistern/attributes.rb
 - lib/cistern/collection.rb
+- lib/cistern/formatter.rb
+- lib/cistern/formatters/awesome_print.rb
+- lib/cistern/formatters/default.rb
+- lib/cistern/formatters/formatador.rb
 - lib/cistern/hash.rb
 - lib/cistern/mock.rb
 - lib/cistern/model.rb
 - lib/cistern/service.rb
 - lib/cistern/version.rb
 - lib/cistern/wait_for.rb
-homepage: ''
+- spec/collection_spec.rb
+- spec/model_spec.rb
+- spec/spec_helper.rb
+homepage: http://joshualane.com/cistern
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -73,4 +65,7 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: API client framework
-test_files: []
+test_files:
+- spec/collection_spec.rb
+- spec/model_spec.rb
+- spec/spec_helper.rb