github-api-client 0.3.3 → 0.4.0.pre

data/VERSION

@@ -1 +0,0 @@
-0.3.3

data/db/migrate/001_create_users.rb

@@ -1,21 +0,0 @@
-class CreateUsers < ActiveRecord::Migration
-  def self.up
-    create_table :users do |t|
-      %w(login token type name company location blog email language permission).each do |attr|
-        t.string attr
-      end
-      
-      %w(gravatar_id score record).each do |attr|
-        t.integer attr
-      end
-      
-      %w(created_at pushed).each do |attr|
-        t.datetime attr
-      end
-    end
-  end
-  
-  def self.down
-    drop_table :users
-  end
-end

data/db/migrate/002_create_user_followings.rb

@@ -1,12 +0,0 @@
-class CreateUserFollowings < ActiveRecord::Migration
-  def self.up
-    create_table :user_followings, :id => false do |t|
-      t.references :follower
-      t.references :following
-    end
-  end
-  
-  def self.down
-    drop_table :user_followings
-  end
-end

data/db/migrate/003_create_repos.rb

@@ -1,32 +0,0 @@
-class CreateRepos < ActiveRecord::Migration
-  def self.up
-    create_table :repos do |t|
-      %w(name description url language integrate_branch homepage source).each do |attr|
-        t.string attr
-      end
-      
-      %w(parent).each do |attr|
-        t.references attr
-      end
-      
-      t.references :owner, :polymorphic => true
-      
-      # TODO: organization temporarily a string, only when there's no organization model
-      %w(size score).each do |attr|
-        t.integer attr
-      end
-      
-      %w(has_downloads b_fork deleted locked has_wiki private open_issues has_issues).each do |attr|
-        t.boolean attr
-      end
-      
-      %w(created_at pushed_at).each do |attr|
-        t.datetime attr
-      end
-    end
-  end
-  
-  def self.down
-    drop_table :repos
-  end
-end

data/db/migrate/004_create_repo_watchings.rb

@@ -1,12 +0,0 @@
-class CreateRepoWatchings < ActiveRecord::Migration
-  def self.up
-    create_table :repo_watchings, :id => false do |t|
-      t.references :watcher
-      t.references :repo
-    end
-  end
-  
-  def self.down
-    drop_table :repo_watchings
-  end
-end

data/db/migrate/005_create_organizations.rb

@@ -1,15 +0,0 @@
-class CreateOrganizations < ActiveRecord::Migration
-  def self.up
-    create_table :organizations do |t|
-      %w(name company location blog type login email gravatar_id billing_email permission).each do |attr|
-        t.string attr
-      end
-      
-      t.timestamps
-    end
-  end
-  
-  def self.down
-    drop_table :organizations
-  end
-end

data/db/migrate/006_create_organizations_members.rb

@@ -1,12 +0,0 @@
-class CreateOrganizationsMembers < ActiveRecord::Migration
-  def self.up
-    create_table :organizations_members, :id => false do |t|
-      t.references :user
-      t.references :organization
-    end
-  end
-  
-  def self.down
-    drop_table :organizations_member
-  end
-end

data/lib/github-api-client/organization.rb

@@ -1,64 +0,0 @@
-module GitHub
-  class Organization < ActiveRecord::Base
-    has_and_belongs_to_many :members, :class_name => 'GitHub::User', :join_table => 'organizations_members'
-    has_many :repositories, :class_name => 'GitHub::Repo', :as => :owner
-    
-    def get
-      self.update_attributes(
-        GitHub::Base.parse_attributes(:org_get,
-          YAML::load(
-            GitHub::Browser.get("/organizations/#{self.login}"))['organization']))
-      self
-    end
-    
-    def self.get(login)
-      o   = GitHub::Organization.find_by_login(login)
-      o ||= GitHub::Organization.new(:login => login).get
-    end
-    
-    def fetch(*things)
-      things.each do |thing|
-        case thing
-          when :self then get
-          when :members then get_members
-          when :repositories then get_repositories
-        end
-      end
-      self
-    end
-    
-    private
-    def get_members
-      members = YAML::load(GitHub::Browser.get "/organizations/#{login}/public_members")['users']
-      puts "Fetching members for #{"organization".color(:magenta).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, members.count.to_s.color(:green).bright
-      self.transaction do
-        members.each do |user|
-          i += 1
-          u = GitHub::User.find_or_create_by_login(user['login'])
-          self.association(:members).find_or_create u
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-      
-    def get_repositories
-      repos = YAML::load(GitHub::Browser.get "/organizations/#{login}/public_repositories")['repositories']
-      puts "Fetching repositories for #{"organization".color(:magenta).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, repos.count.to_s.color(:green).bright
-      self.transaction do
-        repos.each do |repo|
-          i += 1
-          r   = GitHub::Repo.find_by_url(repo[:url])
-          r ||= GitHub::Repo.create(GitHub::Base.parse_attributes :org_repo_index, repo)
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-    
-  end
-end

data/lib/github-api-client/repo.rb

@@ -1,99 +0,0 @@
-module GitHub
-  class Repo < ActiveRecord::Base
-    belongs_to :owner, :polymorphic => true
-    belongs_to :parent, :class_name => 'GitHub::Repo'
-    has_and_belongs_to_many :watchers, :class_name => 'GitHub::User', :join_table => 'repo_watchings', :foreign_key => 'repo_id', :association_foreign_key => 'watcher_id'
-    
-    def get
-      parser = case self.owner_type
-        when 'GitHub::User'
-          :repo_get
-        when 'GitHub::Organization'
-          :org_repo_get
-      end
-      self.update_attributes GitHub::Base.parse_attributes(parser, 
-        YAML::load(
-          GitHub::Browser.get("/repos/show/#{self.permalink}"))['repository'])
-      self
-    end
-    
-    def self.get(information, o_type = :user)
-      #FIXME: permalink column must be present, comparing url's is surely not the most efficient way for the db
-      conditions = {:name => information.split('/').last}
-      if o_type == :user
-        conditions.merge! :owner_id => GitHub::User.find_or_create_by_login(information.split('/').first).id, :owner_type => 'GitHub::User'
-      else
-        conditions.merge! :owner_id => GitHub::Organization.find_or_create_by_login(information.split('/').first).id, :owner_type => 'GitHub::Organization'
-      end
-      if r = GitHub::Repo.where(conditions).first
-        r.get
-      else
-        r = GitHub::Repo.new(conditions).get
-        p r.parent
-        r
-      end
-    end
-    
-    def fetch(*things)
-      things.each do |thing|
-        case thing
-          when :self then get
-          when :watchers then get_watchers
-        end
-      end
-      self
-    end
-    
-    private
-    def get_watchers
-      watchers = YAML::load(GitHub::Browser.get("/repos/show/#{self.permalink}/watchers"))['watchers']
-      puts "Fetching watchers for #{"repo".color(:blue).bright} #{self.permalink.dup.color(:green).bright}"
-      i, count = 0, watchers.count.to_s.color(:green).bright
-      self.transaction do
-        watchers.each do |watcher|
-          i += 1
-          attr = {:login => watcher}
-          self.association(:watchers).find_or_create(GitHub::User.find_or_create_by_login(attr))
-          print "\r#{i.to_s.color(:blue).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-    
-    public
-    def owner_login=(user)
-      if user
-        self.owner = GitHub::User.find_or_create_by_login(user)
-      end
-    end
-    
-    def organization_login=(organization)
-      if organization
-        self.owner = Organization.find_or_create_by_login(organization)
-      end
-    end
-    
-    def parent=(permalink)
-      #FIXME: parent repo does not allow organization to be owner ATM
-      owner = GitHub::User.find_or_create_by_login permalink.split('/').first
-      name = permalink.split('/').last
-      repo = GitHub::Repo.where(:owner_id => owner.id, :owner_type => 'GitHub::Repo', :name => name).first
-      repo ||= GitHub::Repo.create(:owner => owner, :name => name)
-      self.parent_id = repo.id
-    end
-    
-    def permalink
-      "#{owner.login}/#{name}"
-    end
-    
-    # For future, when sql will be find_or_create_by_permalink
-    def permalink=(anything)
-      @permalink = permalink
-    end
-    
-    def fork?
-      b_fork
-    end
-  end
-end

data/lib/github-api-client/user.rb

@@ -1,186 +0,0 @@
-module GitHub
-  # Basic model, stores retrieved user and his associations
-  class User < ActiveRecord::Base
-    has_and_belongs_to_many :followers, :foreign_key => 'follower_id', :association_foreign_key => 'following_id', :join_table => 'user_followings', :class_name => 'User'
-    has_and_belongs_to_many :followings, :foreign_key => 'following_id', :association_foreign_key => 'follower_id', :join_table => 'user_followings', :class_name => 'User'
-    has_many :repos, :class_name => 'GitHub::Repo', :as => :owner
-    
-    # FIXME: Does GitHub allow a user to have multiple organizations?
-    has_and_belongs_to_many :organizations, :join_table => 'organizations_members'
-    
-    # Fetches info about current_user from GitHub
-    # GitHub::User.new.build(:login => 'asd', :token => 'token').get #=> GitHub::User
-    # @return [GitHub::User] Chainable self object after syncing attributes with GitHub
-    def get
-      self.update_attributes(
-        GitHub::Base.parse_attributes(:user_get,
-          YAML::load(
-            GitHub::Browser.get("/user/show/#{self.login}"))['user']))
-      self
-    end
-    
-    # Static function, that gets information about GitHub::User by login.
-    # === Examples
-    #  GitHub::User.get('defunkt') #=> GitHub::User
-    # @param [String] login GitHub user login to fetch
-    # @return [GitHub::User] Newly created, in local database user synced with github
-    def self.get(login)
-      if u = GitHub::User.find_by_login(login)
-        u.get
-      else
-        u = GitHub::User.new(:login => login).fetch(:self)
-      end
-    end
-    
-    # Searches for users in GitHub database
-    # @param [String] login GitHub user login to search
-    # @return [Array<GitHub::User>] All users that matched login
-    def self.search(login)
-      users = []
-      YAML::load(GitHub::Browser.get("/user/search/#{login}"))['users'].each do |user|
-        users << GitHub::User.find_or_create_by_login(GitHub::Base.parse_attributes(:user_search, user))
-      end
-      users
-    end
-    
-    # Experimental function, requests POST transmission to custom path of GitHub API
-    # @param [Array] route Route splitted like: ['users', 'search', 'chacon']
-    # @param [Hash] options Options to pass with the request
-    # @option [Hash] options 'values[email]' => 'test@api.com'
-    def set(route = [], options = {})
-      return GitHub::Browser.post "/#{route.join('/')}", options.merge(self.auth_info)
-    end
-    
-    # End-user way to fetch information
-    # @param [Array<Symbol>] things Things to fetch for GitHub::User
-    # @option things [Symbol] :self Sync with GitHub Database
-    # @option things [Symbol] :followers Map followers from GitHub Database
-    # @option things [Symbol] :followings Map user's followings from GitHub
-    # @return [GitHub::User] Chainable, updated User
-    # @see GitHub::User#get
-    # @see GitHub::User#get_followers
-    def fetch(*things)
-      things.each do |thing|
-        case thing
-          when :self then get
-          when :followers then get_followers
-          when :followings then get_followings
-          when :organizations then get_organizations
-          when :repos then get_repos
-        end
-      end
-      self
-    end
-    
-    # Executes when you got a real object
-    # @see GitHub::User#fetch
-    # @return GitHub::User Chainable after mapping followers association
-    private 
-    def get_followers
-      users = YAML::load(GitHub::Browser.get "/user/show/#{login}/followers")['users'] || []
-      puts "Fetching followers for #{"user".color(:yellow).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, users.count.to_s.color(:green).bright
-      self.transaction do
-        users.each do |user|
-          i += 1
-          u = GitHub::User.find_or_create_by_login(user)
-          self.association(:followers).find_or_create u
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-    
-    def get_followings
-      users = YAML::load(GitHub::Browser.get "/user/show/#{login}/following")['users'] || []
-      puts "Fetching followings for #{"user".color(:yellow).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, users.count.to_s.color(:green).bright
-      self.transaction do
-        users.each do |user|
-          i += 1
-          u = GitHub::User.find_or_create_by_login(user)
-          self.association(:followings).find_or_create u
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-    
-    def get_organizations
-      organizations = YAML::load(GitHub::Browser.get "/user/show/#{login}/organizations")['organizations'] || []
-      puts "Fetching organizations for #{"user".color(:yellow).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, organizations.count.to_s.color(:green).bright
-      self.transaction do
-        organizations.each do |org|
-          i += 1
-          u = GitHub::Organization.find_or_create_by_login(org['login'])
-          self.association(:organizations).find_or_create u
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-    
-    # Executes when you got a real object
-    # @see GitHub::User#fetch
-    # @return GitHub::User Chainable after mapping followers association
-    def get_repos
-      repos = YAML::load(GitHub::Browser.get "/repos/show/#{login}")['repositories'] || []
-      puts "Fetching repositories for #{"user".color(:yellow).bright} #{self.login.dup.color(:green).bright}"
-      i, count = 0, repos.count.to_s.color(:green).bright
-      self.transaction do
-        repos.each do |repo|
-          i += 1
-          u = GitHub::User.find_or_create_by_login(repo[:owner])
-          r = GitHub::Repo.where(:owner_id => u.id, :name => repo[:name]).first
-          r ||= GitHub::Repo.create(:owner => u, :name => repo[:name])
-          print "\r#{i.to_s.color(:yellow).bright}/#{count}"
-        end
-      end
-      puts nil
-      self
-    end
-
-    public
-    # Returns an array with logins of GitHub::User followers
-    # @param [String] login GitHub login of which followers will be mapped
-    # @return [Array<GitHub::User>] Followers
-    # @deprecated It should not support such way, there should be objects!
-    def self.get_followers(login)
-      users = YAML::load(GitHub::Browser.get "/user/show/#{login}/followers")['users']
-      
-      # Loading each user (not effective with 688 followers like schacon has)
-      objects = []
-      i = 1
-      users.each do |user|
-        puts "#{users.length.to_s} / #{i.to_s} - Fetching followers"
-        i = i + 1
-        u = GitHub::User.find_or_create_by_login(user)
-        objects << u
-      end
-      return objects
-    end
-    
-    # Collects information from authenticated user.
-    # Used by post requests to authenticate
-    # @return [Hash] Collected from GitHub::User options for HTTP POST request authentication
-    def auth_info
-      {:login => self.login, :token => self.token}
-    end
-    
-    # Experimental, sets information about GitHub::User or returns authenticated :self
-    # @param [String] login Login to which post request will be sent
-    # @param [Hash] options Options to include to a post request
-    # @option options [Hash] email 'values[email]' => 'test@api.com' - Sets user email to test@api.com if authenticated
-    # @return [String] Request retrieved data
-    def post(login, options = {})
-      if [:self, :me].include? login
-        login = self.login
-      end
-      return GitHub::Browser.post "/user/show/#{login}", options.merge(self.auth_info)
-    end
-  end
-end