winnie 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ragnarson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,11 @@
+= winnie
+
+Winnie command line client.
+
+= Meta
+
+Created and maintained by Ragnarson team, inspired by heroku gem.
+
+== Copyright
+
+Copyright (c) 2010 Ragnarson. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "winnie"
+    gem.summary = %Q{Winnie command line tool}
+    gem.description = %Q{Command line tool which allows interacting with winnie's API}
+    gem.email = "winnie-devs@ragnarson.com"
+    gem.homepage = "http://winniecloud.net"
+    gem.authors = ["winnie"]
+    gem.add_dependency "json"
+    gem.add_dependency "rest-client"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "fakefs"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "winnie #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/winnie

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '../lib/winnie/winnie')
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Winnie::Command.run(command, args)

data/lib/winnie/client.rb

@@ -0,0 +1,86 @@
+module Winnie
+  class Client
+    def initialize(api_key)
+      @api_key = api_key
+    end
+    
+    def host
+      ENV['WINNIE_HOST'] || 'admin.winniecloud.net'
+    end
+    
+    def winnie_url
+      "http://#{host}"
+    end
+    
+    def account
+      get('/account')
+    end
+    
+    def apps
+      get('/apps')
+    end
+    
+    def command(command, code_name)
+      post("/apps/#{code_name}/command", :body => command)
+    end
+
+    def post(path, params = {})
+      request(path, :post, params)
+    end
+    
+    def get(path)
+      request(path, :get)
+    end
+
+    def request(path, method, params = {})
+      headers = {:accept => 'application/json'}.merge(Client.winnie_headers)
+      params.merge!(:api_key => @api_key)
+      
+      RestClient::Request.execute(
+        :method   => method,
+        :url      => "#{winnie_url}#{path}",
+        :headers  => headers,
+        :payload  => params
+      ) { |response, request| process_response(response) }
+    end
+    
+    class UnauthorizedException < Exception; end
+    class ResourceNotFoundException < Exception; end
+    class CommandFailedException < Exception; end
+      
+    def self.version
+      version_file = File.join(File.dirname(__FILE__), '..', '..', 'VERSION')
+      @@version ||= File.read(version_file).strip
+    end
+    
+    private
+    
+    def self.winnie_headers
+      {'User-Agent'     => "winnie-gem-#{version}",
+       'X-Ruby-Version' => RUBY_VERSION}
+    end
+    
+    def process_response(response)
+      # TODO: this fragment could look better
+      if [404, 500, 401].include?(response.code)
+
+        exception = case response.code
+          when 404; ResourceNotFoundException
+          when 500; CommandFailedException
+          when 401; raise UnauthorizedException.new
+        end
+        
+        error = JSON.parse(response.body)['error']        
+        raise exception.new(error)
+      end
+      
+      response.return!
+
+      if response.code == 302 and response.args[:url] =~ /user_session/
+        raise UnauthorizedException.new 
+      end
+
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/winnie/command.rb

@@ -0,0 +1,38 @@
+module Winnie
+  class Command
+    extend Helpers
+    
+    def self.run(name, *args)
+      begin
+        class_name, command_name = name.split(':')
+        command_name ||= 'run'
+        
+        begin
+          command_class = eval("Winnie::Commands::#{class_name.capitalize}")
+        rescue NameError
+          command_class = Winnie::Commands::App
+          command_name = class_name
+        end
+        
+        command = command_class.new(args)
+        
+        if command.respond_to?(command_name)
+          command.send(command_name)
+        else
+          raise UnknownCommandException.new
+        end
+        
+      rescue UnknownCommandException
+        error 'Unknown command'
+      rescue Winnie::Client::UnauthorizedException
+        error "Your API key is not correct\nUse 'winnie auth' command to re-enter your winnie API key"
+      rescue Winnie::Commands::ApplicationNotSpecyfiedException
+        error "Application not specified\nUse --app <code name> to specify the application"
+      rescue Winnie::Client::ResourceNotFoundException, Winnie::Client::CommandFailedException => e
+        error e.message
+      end
+    end
+
+    class UnknownCommandException < Exception; end
+  end
+end

data/lib/winnie/commands/app.rb

@@ -0,0 +1,28 @@
+module Winnie
+  module Commands
+    class App < Base
+      def run
+        list
+      end
+      
+      def command
+        response = winnie.command(args.first, code_name)
+        display response['result']
+      end
+      
+      def list
+        apps = winnie.apps
+
+        unless apps.empty?
+          display_columns "Name", "Code name"
+          line
+          apps.each do |app|
+            display_columns app['app']['name'], app['app']['code_name']
+          end
+        else
+          display "You don't have any apps yet"
+        end
+      end
+    end
+  end
+end

data/lib/winnie/commands/auth.rb

@@ -0,0 +1,49 @@
+require 'fileutils'
+
+module Winnie
+  module Commands
+    class Auth < Base
+      attr_accessor :api_key
+
+      def initialize(*args)
+        super(args)
+        load_api_key if api_key_exists?
+      end
+      
+      def run
+        confirm('Do you want to change your API key?') if api_key_exists?
+        ask_for_api_key
+        save_api_key
+        validate_api_key
+      end
+      
+      def ask_for_api_key
+        display "Type your Winnie API key"
+        display "Key: ", false
+        self.api_key = ask
+      end
+      
+      def save_api_key
+        FileUtils.mkdir_p(config_path)
+        File.open(api_key_path, 'w') { |file| file << api_key }
+      end
+      
+      def load_api_key
+        self.api_key = File.read(api_key_path)
+      end
+
+      def validate_api_key
+        winnie.account  # If it's not correct, Winnie::Client::UnauthorizedException will be raised
+        display 'Your winnie API key is OK!'
+      end
+            
+      def api_key_exists?
+        File.exists?(api_key_path)
+      end
+      
+      def api_key_path
+        File.join(config_path, 'api_key')
+      end
+    end
+  end
+end

data/lib/winnie/commands/base.rb

@@ -0,0 +1,39 @@
+module Winnie
+  module Commands
+    class Base
+      attr_reader :winnie, :args
+      
+      include Winnie::Helpers
+      
+      def initialize(*args)
+        @args = args.flatten
+        extract_options(@args)
+      end
+      
+      def extract_options(args)
+        return if args.empty?
+        
+        OptionParser.new do |opts|
+          opts.on("-a", "--app [CODE_NAME]", :text, "Run for given application") do |a|
+            @code_name = a
+          end
+        end.parse!(@args)
+      end
+      
+      def code_name
+        raise ApplicationNotSpecyfiedException.new unless @code_name
+        @code_name
+      end
+      
+      def winnie
+        auth = Winnie::Commands::Auth.new
+        @winnie ||= Winnie::Client.new(auth.api_key)
+      end
+      
+      def config_path
+        File.expand_path('~/.winnie')
+      end
+    end
+    class ApplicationNotSpecyfiedException < Exception; end
+  end
+end

data/lib/winnie/commands/help.rb

@@ -0,0 +1,12 @@
+module Winnie
+  module Commands
+    class Help < Base
+      def run
+        display_columns 'auth', 'Configure your winnie username and password'
+        display_columns 'command', 'Run single ruby command'
+        display_columns 'list', 'List your applications'
+        display_columns 'help', 'Show this information'
+      end
+    end
+  end
+end

data/lib/winnie/helpers.rb

@@ -0,0 +1,36 @@
+module Winnie
+  module Helpers
+    def display(message, new_line = true)
+      STDOUT << message
+      STDOUT << "\n" if new_line
+    end
+    
+    def display_columns(*columns)
+      columns.each { |field| display(field.to_s.ljust(20), false) }
+      display ''
+    end
+    
+    def line
+      display '-' * 45
+    end
+    
+    def error(message)
+      STDERR << message << "\n"
+      exit 1
+    end
+        
+    def ask
+      gets.strip
+    end
+    
+    def confirm(message)
+      loop do
+        STDERR << message << " (Y/N): "
+        case ask.upcase
+          when 'Y'; break
+          when 'N'; exit 0
+        end
+      end
+    end
+  end
+end

data/lib/winnie/winnie.rb

@@ -0,0 +1,11 @@
+# TODO: loop here, and load all commands
+module Winnie; end
+require 'rubygems'
+require 'rest_client'
+require 'json'
+require 'optparse'
+require 'winnie/helpers'
+require 'winnie/client'
+require 'winnie/command'
+require 'winnie/commands/base'
+Dir["#{File.dirname(__FILE__)}/commands/*"].each { |c| require c }

data/spec/client_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Winnie::Client do
+  before do
+    Winnie::Client.stub(:winnie_headers).and_return({})
+    @client = Winnie::Client.new('secret_one')
+    RestClient::Request.stub!(:execute)
+  end
+  
+  describe "request" do
+    it "should make a request to give URL" do
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters('/account', :get)
+      )
+      @client.request('/account', :get)
+    end
+    
+    it "should include provided parameters in the request" do
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters('/account', :post, 
+          :payload => {:api_key => 'secret_one', :name => 'test'}
+        )
+      )
+      @client.request('/account', :post, :name => 'test')
+    end
+    
+    it "should include api_key in the request parameters" do
+      @client = Winnie::Client.new('AABBCC')
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters('/account', :get, 
+          :payload => {:api_key => 'AABBCC'}
+        )
+      )
+      @client.request('/account', :get)
+    end
+    
+    it "should accept json responses only" do
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters('/account', :get, 
+          :headers => {:accept => 'application/json'}
+        )
+      )
+      @client.request('/account', :get)
+    end
+    
+    it "should pass response to process_response method" do
+      response = mock(RestClient::Response)
+      request = mock(RestClient::Request)
+      @client.should_receive(:process_response).with(response)
+      RestClient::Request.should_receive(:execute).with(request_parameters('/account', :get)).and_yield(response, request)
+      
+      @client.request('/account', :get)
+    end
+    
+    
+    def request_parameters(path, method, params = {})
+      {:payload => {:api_key => 'secret_one'}, 
+       :method  => method, 
+       :headers => {:accept => 'application/json'}, 
+       :url     => "http://admin.winniecloud.net#{path}"
+       }.merge(params)
+    end
+  end
+  
+  describe "process_response" do
+    before do
+      @response = mock(RestClient::Response, :code => 200, :body => '{}', :return! => nil)
+      @request = mock(RestClient::Request)
+      RestClient::Request.stub(:execute).and_yield(@response, @request)
+    end
+    
+    it "should not follow redirections" do
+      @response.should_receive(:return!)
+      @client.get('/account')
+    end
+    
+    it "should raise UnauthorizedException when response has 401 code" do
+      @response.stub(:code).and_return(401)
+      lambda {
+        @client.get('/account')
+      }.should raise_error(Winnie::Client::UnauthorizedException)
+    end
+    
+    it "should raise UnauthorizedException when it gets redirected to login page" do
+      @response.stub(:args).and_return({:url => 'user_session'})
+      @response.stub(:code).and_return(302)
+      
+      lambda {
+        @client.get('/account')
+      }.should raise_error(Winnie::Client::UnauthorizedException)
+    end
+    
+    it "should raise ResourceNotFoundException when response has 404 code" do
+      @response.stub(:code).and_return(404)
+      @response.stub(:body).and_return({'error' => 'App not found'}.to_json)
+
+      lambda {
+        @client.post('/apps/flower/command', :body => 'puts User.count')
+      }.should raise_error(Winnie::Client::ResourceNotFoundException, 'App not found')
+    end
+    
+    it "should raise CommandFailedException when response has 500 code" do
+      @response.stub(:code).and_return(500)
+      @response.stub(:body).and_return({'error' => 'random error happened'}.to_json)
+      
+      lambda {
+        @client.post('/apps/flower/command', :body => 'puts User.count')
+      }.should raise_error(Winnie::Client::CommandFailedException, 'random error happened')
+    end
+  end
+  
+  it "should make GET request to given path" do
+    @client.should_receive(:request).with('/account', :get)
+    @client.get('/account')
+  end
+  
+  it "should make POST request to given path with parameters" do
+    @client.should_receive(:request).with('/account', :post, :name => 'pink-one')
+    @client.post('/account', :name => 'pink-one')
+  end
+  
+  describe "API methods" do
+    it "should get the list of user applications" do
+      @client.should_receive(:get).with('/apps')
+      @client.apps
+    end
+    
+    it "should get account info" do
+      @client.should_receive(:get).with('/account')
+      @client.account
+    end
+    
+    it "should send command to winnie" do
+      @client.should_receive(:post).with('/apps/flower-16/command', :body => 'User[:bob].destroy')
+      @client.command('User[:bob].destroy', 'flower-16')
+    end
+  end
+  
+  it "should return winnie-app URL" do
+    @client.winnie_url.should == "http://#{@client.host}"
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Winnie::Command do
+  describe "run" do
+    before do
+      @command = mock(Winnie::Commands::Help.new, :run => '')
+      @command.stub!(:respond_to?).and_return(true)
+      Winnie::Commands::Help.stub!(:new).and_return(@command)
+    end
+    
+    it "should create command class object" do
+      Winnie::Command.should_receive(:eval).with('Winnie::Commands::Help').and_return(Winnie::Commands::Help)
+      Winnie::Command.run('help')
+    end
+
+    describe "when command class exists" do
+      describe "and command name is provided" do
+        it "should parse command name and invoke it" do
+          @command.should_receive(:connection).and_return(true)
+          Winnie::Command.run('help:connection')
+        end
+      end
+      
+      describe "and command name is not provided" do
+        it "should invoke run method" do
+          @command.should_receive(:run).and_return(true)
+          Winnie::Command.run('help').should be_true
+        end
+      end
+    end
+    
+    describe "when command class doesn't exist" do
+      before do
+        @app = mock('Winnie::Commands::App', :list => [])
+        Winnie::Commands::App.stub(:new).and_return(@app)
+      end
+      
+      it "should use App command class as default" do
+        Winnie::Commands::App.should_receive(:new).and_return(@app)
+        Winnie::Command.run('list')
+      end
+      
+      it "should use command class name as command name" do
+        @app.should_receive(:list)
+        Winnie::Command.run('list')
+      end      
+    end
+    
+    it "should notify user when resource doesn't exist" do
+      app = mock(Winnie::Commands::App)
+      app.should_receive(:command).and_raise(Winnie::Client::ResourceNotFoundException.new('App not found'))
+      Winnie::Commands::App.stub(:new).and_return(app)
+      
+      Winnie::Command.should_receive(:error).with('App not found')
+      
+      Winnie::Command.run('command', ["'puts User.count'", '--app', 'flower'])
+    end
+    
+    it "should notify user when command doesn't exist" do
+      Winnie::Command.should_receive(:error).with('Unknown command')
+      Winnie::Command.run('unknown')
+
+      @command.should_receive(:respond_to?).with("foooo").and_return(false)
+      Winnie::Command.should_receive(:error).with('Unknown command')
+      Winnie::Command.run('help:foooo')
+    end
+  end
+end

data/spec/commands/app_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Winnie::Commands::App do
+  before do
+    @app = Winnie::Commands::App.new('--app', 'flower')
+    @app.stub(:display_columns)
+    @app.stub(:line)
+    @client = mock(Winnie::Client.new('secret-api-key'))
+    @app.stub(:winnie).and_return(@client)
+  end
+  
+  describe "when user has some apps" do
+    it "should list apps" do
+      @client.should_receive(:apps).and_return(apps)
+      @app.should_receive(:display_columns).exactly(3)
+      @app.should_receive(:line)
+      @app.list
+    end
+  end
+  
+  describe "when user doesn't have any app" do
+    it "should inform the user that he doesn't have any app" do
+      @client.should_receive(:apps).and_return([])
+      @app.should_receive(:display).with("You don't have any apps yet")
+      @app.list
+    end
+  end
+
+  describe "running commands" do
+    before do
+      @app = Winnie::Commands::App.new('--app', 'shop-16', "Product.cleanup_cache!")
+      @app.stub(:display_columns)
+      @app.stub(:display)
+      @app.stub(:line)
+      @app.stub(:winnie).and_return(@client)
+    end
+    
+    it "should send command to winnie given as a command line parameter" do
+      @client.should_receive(:command).with('Product.cleanup_cache!', 'shop-16').and_return({})
+      @app.command
+    end
+    
+    it "should display the result" do
+      @client.should_receive(:command).with('Product.cleanup_cache!', 'shop-16').and_return('result' => 'foo')
+      @app.should_receive(:display).with('foo')
+      @app.command      
+    end
+  end
+end
+
+def apps
+  [
+    {"app" => {"name" => "Green One", "code_name" => "green-one"}},
+    {"app" => {"name" => "Pink", "code_name" => "pink"}}
+  ]
+end

data/spec/commands/auth_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Winnie::Commands::Auth do
+  include FakeFS::SpecHelpers
+  
+  before do
+    @auth = Winnie::Commands::Auth.new
+    @auth.stub(:display)
+  end
+  
+  describe "initialize" do
+    describe "when API key doesn't exist" do
+      it "should not load API key" do
+        @auth.api_key.should be_nil
+      end
+    end
+    
+    describe "when API key exists" do
+      before { create_api_key_file('NobodyKnowsIt') }
+      
+      it "should load API key" do
+        auth = Winnie::Commands::Auth.new
+        auth.api_key.should == 'NobodyKnowsIt'
+      end
+    end
+  end
+  
+  describe "run" do
+    before do
+      @auth.stub(:ask_for_api_key)
+      @auth.stub(:save_api_key)
+      @auth.stub(:validate_api_key)
+    end
+    
+    describe "when API key doesn't exist" do
+      it "should ask for API key" do
+        @auth.should_receive(:ask_for_api_key)
+        @auth.run
+      end
+      
+      it "should save API key" do
+        @auth.should_receive(:save_api_key)
+        @auth.run
+      end
+      
+      it "should validate API key" do
+        @auth.should_receive(:validate_api_key)
+        @auth.run        
+      end
+    end
+    
+    describe "when API key exists" do
+      it "should ask if overwrite API key" do
+        @auth.should_receive(:confirm).with('Do you want to change your API key?')
+        @auth.stub!(:api_key_exists?).and_return(true)
+        @auth.run
+      end
+    end
+  end
+  
+  describe "save_api_key" do
+    before { @auth.api_key = 'secret_api_key' }
+    
+    it "should create config directory" do
+      FileUtils.should_receive(:mkdir_p).with(@auth.config_path)
+      @auth.save_api_key
+    end
+    
+    it "should save API key to file" do
+      @auth.save_api_key
+      key = File.read(@auth.api_key_path)
+      key.should == 'secret_api_key'
+    end    
+  end
+  
+  describe "load_api_key" do
+    before { create_api_key_file('VerySecretOne') }
+
+    it "should load api key from a file" do
+      @auth.load_api_key
+      @auth.api_key.should == 'VerySecretOne'
+    end
+  end
+  
+  it "should return api_key_path" do
+    @auth.api_key_path.should == File.join(@auth.config_path, 'api_key')
+  end
+end
+
+def create_api_key_file(key)
+  File.open(@auth.api_key_path, 'w') { |file| file << key }
+end

data/spec/commands/base_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Winnie::Commands::Base do
+  describe "config_path" do
+    it "should return default config path" do
+      Winnie::Commands::Base.new.config_path.should == File.expand_path('~/.winnie')
+    end
+  end
+  
+  describe "extract_options" do
+    it "should extract app code name if provided" do
+      base = Winnie::Commands::Base.new('--app', 'crazy-one')
+      base.code_name.should == 'crazy-one'
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'winnie/winnie'
+require 'spec'
+require 'spec/autorun'
+require 'fakefs'
+require 'fakefs/spec_helpers'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/winnie_spec.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')

data/winnie.gemspec

@@ -0,0 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{winnie}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["winnie"]
+  s.date = %q{2010-08-27}
+  s.default_executable = %q{winnie}
+  s.description = %q{Command line tool which allows interacting with winnie's API}
+  s.email = %q{winnie-devs@ragnarson.com}
+  s.executables = ["winnie"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/winnie",
+     "lib/winnie/client.rb",
+     "lib/winnie/command.rb",
+     "lib/winnie/commands/app.rb",
+     "lib/winnie/commands/auth.rb",
+     "lib/winnie/commands/base.rb",
+     "lib/winnie/commands/help.rb",
+     "lib/winnie/helpers.rb",
+     "lib/winnie/winnie.rb",
+     "spec/client_spec.rb",
+     "spec/command_spec.rb",
+     "spec/commands/app_spec.rb",
+     "spec/commands/auth_spec.rb",
+     "spec/commands/base_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/winnie_spec.rb",
+     "winnie.gemspec"
+  ]
+  s.homepage = %q{http://winniecloud.net}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Winnie command line tool}
+  s.test_files = [
+    "spec/client_spec.rb",
+     "spec/command_spec.rb",
+     "spec/commands/app_spec.rb",
+     "spec/commands/auth_spec.rb",
+     "spec/commands/base_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/winnie_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<rest-client>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<fakefs>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<rest-client>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<fakefs>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<rest-client>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<fakefs>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: winnie
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- winnie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-27 00:00:00 +02:00
+default_executable: winnie
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Command line tool which allows interacting with winnie's API
+email: winnie-devs@ragnarson.com
+executables: 
+- winnie
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/winnie
+- lib/winnie/client.rb
+- lib/winnie/command.rb
+- lib/winnie/commands/app.rb
+- lib/winnie/commands/auth.rb
+- lib/winnie/commands/base.rb
+- lib/winnie/commands/help.rb
+- lib/winnie/helpers.rb
+- lib/winnie/winnie.rb
+- spec/client_spec.rb
+- spec/command_spec.rb
+- spec/commands/app_spec.rb
+- spec/commands/auth_spec.rb
+- spec/commands/base_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/winnie_spec.rb
+- winnie.gemspec
+has_rdoc: true
+homepage: http://winniecloud.net
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Winnie command line tool
+test_files: 
+- spec/client_spec.rb
+- spec/command_spec.rb
+- spec/commands/app_spec.rb
+- spec/commands/auth_spec.rb
+- spec/commands/base_spec.rb
+- spec/spec_helper.rb
+- spec/winnie_spec.rb