kenai_tools 0.0.7

data/lib/kenai_tools/kenai_client.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require "bundler/setup"
+
+require 'rest_client'
+require 'json'
+
+module KenaiTools
+  class KenaiClient
+    DEFAULT_HOST = 'https://kenai.com/'
+
+    RestClient.proxy = ENV['http_proxy'] if ENV['http_proxy']
+
+    attr_reader :host, :user, :password
+
+    def initialize(host = nil, opts = {})
+      @host = host || DEFAULT_HOST
+      @opts = opts
+    end
+
+    # check credentials using the login/authenticate method; if successful,
+    # cache the credentials for future calls
+    def authenticate(user, password)
+      @user = user
+      @password = password
+      begin
+        client = self['login/authenticate']
+        client["?username=#{@user}&password=#{@password}"].get
+        @auth = true
+      rescue RestClient::Unauthorized, RestClient::RequestFailed
+        @auth = false
+        @user = @password = nil
+      end
+
+      return @auth
+    end
+
+    def authenticated?
+      @auth
+    end
+
+    def project(proj_name)
+      begin
+        JSON.parse(self["projects/#{proj_name}"].get)
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+    end
+
+    # collect all project hashes (scope may be :all, or all projects, or
+    # :mine, for projects in which the current user has some role)
+    def projects(scope=:all)
+      fetch_all('projects', 'projects')
+    end
+
+    def my_projects
+      fetch_all('projects/mine', 'projects')
+    end
+
+    # get wiki images for a project
+    def wiki_images(project, on_page = nil)
+      fetch_all("projects/#{project}/features/wiki/images", 'images', on_page)
+    end
+
+    # get the wiki raw image data for an image
+    def wiki_image_data(image)
+      RestClient.get(image['image_url'], :accept => image['image_content_type'])
+    end
+
+    # hash has the following keys
+    # +:uploaded_data+ = raw image data, required only if creating a new image
+    # +:comments+ = optional comments for the image
+    # throws IOError unless create or update was successful
+    def create_or_update_wiki_image(proj_name, image_filename, hash)
+      req_params = {}
+      if data = hash[:uploaded_data]
+        upload_io = UploadIO.new(StringIO.new(data), "image/png", image_filename)
+        req_params["image[uploaded_data]"] = upload_io
+      end
+      if comments = hash[:comments]
+        req_params["image[comments]"] = comments
+      end
+      return false if req_params.empty?
+    end
+
+    # get wiki pages for a project
+    def wiki_pages(project, on_page = nil)
+      fetch_all("projects/#{project}/features/wiki/pages", 'pages', on_page)
+    end
+
+    def wiki_page(proj_name, page_name)
+      page = wiki_page_client(proj_name, page_name)
+      JSON.parse(page.get)
+    end
+
+    # edit a single wiki page -- yields the current page contents, and
+    # saves them back if the result of the block is different
+    def edit_wiki_page(proj_name, page_name)
+      # fetch current page contents
+      page = wiki_page_client(proj_name, page_name)
+      begin
+        page_data = JSON.parse(page.get)
+        current_src = page_data['text']
+      rescue RestClient::ResourceNotFound
+        page_data = {}
+        current_src = ''
+      end
+
+      new_src = yield(current_src)
+
+      changed = !(new_src.nil? || new_src == current_src)
+
+      if changed
+        new_data = {
+          'page' => {
+            'text' => new_src,
+            'description' => 'edited with kenai-client',
+            'number' => page_data['number']
+          }
+        }
+        page.put(JSON.dump(new_data), :content_type => 'application/json')
+      end
+
+      return changed
+    end
+
+    def api_client(fragment='')
+      params = {:headers => {:accept => 'application/json'}}
+      if @auth
+        params[:user] = @user
+        params[:password] = @password
+      end
+      params.merge!(@opts)
+
+      if fragment =~ %r{^https://}
+        RestClient::Resource.new(fragment, params)
+      else
+        RestClient::Resource.new(@host, params)['api'][fragment]
+      end
+    end
+
+    alias :[] :api_client
+
+    private
+
+    # +on_page+ means only on that particular page or all pages if nil
+    def fetch_all(initial_url, item_key, on_page = nil)
+      unless on_page
+        next_page = initial_url
+        results = []
+
+        begin
+          curr_page = JSON.parse(self[next_page].get)
+          results += curr_page[item_key]
+          next_page = curr_page['next']
+        end until next_page.nil?
+
+        results
+      else
+        url = on_page ? initial_url + "?page=#{on_page}" : initial_url
+        JSON.parse(self[url].get)[item_key]
+      end
+    end
+
+    def wiki_page_client(project, page)
+      self["projects/#{project}/features/wiki/pages/#{page}"]
+    end
+  end
+end

data/lib/kenai_tools/version.rb

@@ -0,0 +1,3 @@
+module KenaiTools
+  VERSION = "0.0.7"
+end

data/lib/kenai_tools.rb

@@ -0,0 +1,7 @@
+require 'kenai_tools/version'
+require 'kenai_tools/kenai_client'
+require 'kenai_tools/downloads_client'
+
+module KenaiTools
+  # Your code goes here...
+end

data/spec/downloads_client_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+require "open-uri"
+
+# This rspec test assumes that a development kenai/junction2 server is running
+SITE = "http://localhost:3000"
+begin
+  RestClient::Resource.new(SITE).get
+rescue
+  fail("Check that a Rails kenai/junction2 development mode server is running at #{SITE}")
+end
+
+describe KenaiTools::DownloadsClient do
+  before :all do
+    # Init downloads feature for test project oasis
+    dlclient = KenaiTools::DownloadsClient.new(SITE, "oasis", :downloads_name => "downloads")
+    dlclient.authenticate("mehdi", "mehdi") unless dlclient.authenticated?
+    dlclient.delete_feature('yes') if dlclient.ping
+    dlclient.get_or_create
+  end
+
+  # Larger timeout used here to debug server-side code or handling a large amount of data
+  let(:dlclient) { KenaiTools::DownloadsClient.new(SITE, "oasis", :timeout => 36000) }
+  let(:data) { Pathname.new(File.dirname(__FILE__) + '/fixtures/data') }
+  let(:file1) { data + "text1.txt" }
+
+  def ensure_write_permission
+    dlclient.authenticate("mehdi", "mehdi") unless dlclient.authenticated?
+  end
+
+  def ensure_remote_dir(remote_dir)
+    unless dlclient.entry_type(remote_dir) == 'directory'
+      ensure_write_permission
+      dlclient.rm_r(remote_dir) if dlclient.exist?(remote_dir)
+      dlclient.mkdir(remote_dir)
+    end
+  end
+
+  def ensure_remote_sample_data(rel_path)
+    ensure_write_permission
+    pn = data + rel_path
+    dlclient.push(pn) unless dlclient.exist?(rel_path)
+  end
+
+  describe "authentication" do
+    it "should authenticate with valid credentials" do
+      dlclient.authenticate("mehdi", "mehdi").should be_true
+      dlclient.authenticated?.should be_true
+    end
+
+    it "should fail to authenticate with invalid credentials" do
+      dlclient.authenticate("mehdi", "xmehdi").should be_false
+      dlclient.authenticated?.should be_false
+    end
+  end
+
+  describe "bootstrap" do
+    context "basic" do
+      # Note: this test depend upon sample downloads data in the development DB
+      it "should detect existence of a file" do
+        dlclient = KenaiTools::DownloadsClient.new(SITE, "glassfish")
+        dlclient.exist?("glassfishv4solaris.zip").should be_true
+      end
+
+      it "should detect non-existence of a file" do
+        dlclient = KenaiTools::DownloadsClient.new(SITE, "glassfish")
+        dlclient.exist?("non-existent-download.zip").should be_false
+      end
+
+      it "should return the entry_type of an entry" do
+        dlclient = KenaiTools::DownloadsClient.new(SITE, "glassfish")
+        dlclient.entry_type("glassfishv4solaris.zip").should == 'file'
+      end
+    end
+
+    context "authenticated" do
+      before :each do
+        dlclient.authenticate("mehdi", "mehdi")
+      end
+
+      it "should upload a single file to the top level" do
+        dlclient.rm_r(file1.basename) if dlclient.exist?(file1.basename)
+
+        dlclient.push(file1)
+        dlclient.exist?(file1.basename).should be_true
+      end
+
+      it "should destroy a single file at the top level" do
+        ensure_remote_sample_data(file1.basename)
+
+        dlclient.rm(file1.basename).should be_true
+      end
+
+      it "should make a directory" do
+        dirname = "x11r5"
+        dlclient.rm_r(dirname) if dlclient.exist?(dirname)
+
+        dlclient.mkdir(dirname)
+        dlclient.entry_type(dirname).should == 'directory'
+      end
+
+      it "should delete a directory" do
+        dirname = "x11r5"
+        dlclient.rm_r(dirname) if dlclient.exist?(dirname)
+        dlclient.mkdir(dirname)
+
+        dlclient.exist?(dirname).should be_true
+        dlclient.rm_r(dirname)
+        dlclient.exist?(dirname).should be_false
+      end
+    end
+  end
+
+  describe "listing" do
+    before :each do
+      dlclient.authenticate("mehdi", "mehdi")
+      @dir19 = 'version-1.9'
+      ensure_remote_dir(@dir19)
+      ensure_remote_sample_data(file1.basename)
+      dlclient.authenticate("mehdi", "wrong-password").should be_false
+    end
+
+    it "should list the top level downloads of a project as a directory named '/'" do
+      dlclient.ls.keys.should =~ ['href', 'display_name', 'entry_type', 'description', 'tags', 'children',
+        'created_at', 'updated_at', 'content_type']
+      dlclient.ls['entry_type'].should == 'directory'
+      dlclient.ls['display_name'].should == '/'
+      dlclient.ls['children'].map { |ch| ch['display_name'] }.should include(file1.basename.to_s, @dir19)
+    end
+
+    it "should list a file" do
+      entry = dlclient.ls(file1.basename)
+      entry['entry_type'].should == 'file'
+      entry['entry_content_type'].should == 'text/plain'
+      open(entry['content_url']).read == file1.open.read
+      entry.keys.should =~ ['href', 'display_name', 'entry_type', 'description', 'tags', 'size',
+        'created_at', 'updated_at', 'content_url', 'entry_content_type', 'content_type']
+    end
+
+    it "should list a subdirectory" do
+      entry = dlclient.ls(@dir19)
+      entry['entry_type'].should == 'directory'
+      entry.keys.should =~ ['href', 'display_name', 'entry_type', 'description', 'tags', 'children',
+        'created_at', 'updated_at', 'content_type']
+    end
+  end
+
+  describe "push" do
+    before :each do
+      dlclient.authenticate("mehdi", "mehdi")
+    end
+
+    it "should upload a single file to a remote directory specified with a relative path" do
+      target_dir = "version-1.9"
+      ensure_remote_dir(target_dir)
+
+      dlclient.push(file1, target_dir)
+      target_file = File.join(target_dir, file1.basename)
+      dlclient.exist?(target_file).should be_true
+    end
+
+    it "should upload a single file to a remote directory specified with an absolute path" do
+      target_dir = "/version-1.9"
+      ensure_remote_dir(target_dir)
+
+      dlclient.push(file1, target_dir)
+      target_file = File.join(target_dir, file1.basename)
+      dlclient.exist?(target_file).should be_true
+    end
+
+    it "should recursively upload a directory into a new target directory" do
+      target_dir = "tax_year_2010"
+      ensure_remote_dir(target_dir)
+      src_dir = data + "irs_docs"
+
+      dlclient.push(src_dir, target_dir)
+      target_subdir = File.join(target_dir, src_dir.basename)
+      dlclient.entry_type(target_subdir).should == 'directory'
+      expected_names = src_dir.children.map { |ch| ch.basename.to_s }
+      actual_names = dlclient.ls(target_subdir)['children'].map { |ch| ch['display_name'] }
+      actual_names.should =~ expected_names
+    end
+
+    it "should recursively upload source directory contents if the source argument ends with a '/'" do
+      target_dir = "sax2r2"
+      ensure_remote_dir(target_dir)
+      src_dir = data + "sax2/"
+
+      dlclient.push(src_dir, target_dir)
+      expected_names = src_dir.children.map { |ch| ch.basename.to_s }
+      actual_names = dlclient.ls(target_dir)['children'].map { |ch| ch['display_name'] }
+      actual_names.should =~ expected_names
+    end
+  end
+
+  describe "remove files" do
+    before :each do
+      dlclient.authenticate("mehdi", "mehdi")
+    end
+
+    it "should remove a directory and its contents" do
+      dir = "irs_docs"
+      ensure_remote_sample_data(dir)
+
+      dlclient.rm_r(dir)
+      dlclient.exist?(dir).should be_false
+    end
+
+    it "should not remove a directory and its contents for rmdir" do
+      dir = "irs_docs"
+      ensure_remote_sample_data(dir)
+
+      lambda { dlclient.rmdir(dir) }.should raise_error(/not empty/)
+      dlclient.exist?(dir).should be_true
+    end
+  end
+
+  describe "miscellaneous" do
+    it "should ping a working service" do
+      dlclient.ping.should be_true
+    end
+
+    it "should fail to ping a non-working service" do
+      down_dlclient = KenaiTools::DownloadsClient.new(SITE, "bad-project")
+      down_dlclient.ping.should be_false
+    end
+
+    it "should discover the name of a downloads feature if a project only has one" do
+      dlclient2 = KenaiTools::DownloadsClient.new(SITE, "oasis")
+      dlclient2.downloads_name.should == 'downloads'
+    end
+
+    it "should discover the downloads feature if a project only has one" do
+      dlclient2 = KenaiTools::DownloadsClient.new(SITE, "oasis")
+      dlclient2.downloads_feature['type'].should == 'downloads'
+    end
+
+    it "should delete a downloads feature" do
+      dlclient2 = KenaiTools::DownloadsClient.new(SITE, "openjdk")
+      dlclient2.authenticate("craigmcc", "craigmcc") unless dlclient2.authenticated?
+      dlclient2.get_or_create
+
+      dlclient2.ping.should be_true
+      lambda { dlclient2.delete_feature }.should raise_error(/[Cc]onfirm/)
+      dlclient2.delete_feature('yes').should be_true
+      dlclient2.ping.should be_false
+    end
+
+    it "should create a downloads feature" do
+      dlclient2 = KenaiTools::DownloadsClient.new(SITE, "openjdk")
+      dlclient2.authenticate("craigmcc", "craigmcc") unless dlclient2.authenticated?
+      dlclient2.delete_feature('yes') if dlclient2.ping
+
+      dlclient2.ping.should be_false
+      dlclient2.get_or_create.should == 'downloads'
+      dlclient2.ping.should be_true
+    end
+
+    it "should make a directory with a name that needs to be encoded" do
+      dirname = "Web 2.0"
+      ensure_write_permission
+      dlclient.rm_r(dirname) if dlclient.exist?(dirname)
+
+      dlclient.mkdir(dirname)
+      dlclient.entry_type(dirname).should == 'directory'
+
+      dlclient.push(file1, dirname).should be_true
+    end
+  end
+
+  describe "pull" do
+    it "should download a single file to a local directory" do
+      ensure_remote_sample_data(file1.basename)
+
+      Dir.mktmpdir do |dir|
+        dlclient.pull(file1.basename, dir)
+        (Pathname(dir) + file1.basename).read.should == file1.read
+      end
+    end
+
+    it "should recursively download a remote subdirectory to a local directory" do
+      sample_dir = "irs_docs"
+      ensure_remote_sample_data(sample_dir)
+
+      Dir.mktmpdir do |dir|
+        dlclient.pull(sample_dir, dir)
+        dest_dir = Pathname(dir) + sample_dir
+        system("diff -r #{data + sample_dir} #{dest_dir}").should be_true
+      end
+    end
+
+    it "should recursively download all entries to a local directory" do
+      sample_dir = "irs_docs"
+      ensure_remote_sample_data(sample_dir)
+
+      Dir.mktmpdir do |dir|
+        dlclient.pull('/', dir)
+        dest_dir = Pathname(dir) + sample_dir
+        dest_dir.should be_exist
+      end
+    end
+  end
+end

data/spec/fixtures/data/sax2/.cvsignore

@@ -0,0 +1,9 @@
+.cdtproject
+.classpath
+.project
+Log
+apidoc
+classes
+docs
+sax.jar
+sax2dist.jar