activegist 0.6.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+html
+doc

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree
+  - jruby
+  - ruby-head
+  - rbx-2.0
+

data/CHANGELOG

@@ -0,0 +1,2 @@
+* 0.6.0 (01-15-2012)
+  * First release.

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_gist.gemspec
+gemspec
+
+gem 'json', :platforms => [ :ruby_18, :jruby ]
+gem 'jruby-openssl', :platforms => :jruby

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Colin MacKenzie IV
+
+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,96 @@
+= ActiveGist! {<img src="https://secure.travis-ci.org/sinisterchipmunk/active-gist.png" />}[http://travis-ci.org/sinisterchipmunk/active-gist]
+
+I needed a Ruby library to perform basic create, read, update and delete operations on Gists. I looked, I saw basically nothing (except hacky, test-less tools), and I decided to roll my own. Here's the result.
+
+ActiveGist is so named because it wraps GitHub's Gist API with a class implementing the ActiveModel modules. So, it should be pretty familiar to anyone who's ever used models in Ruby on Rails.
+
+== Installation
+
+The obligatory installation steps, in case you haven't yet figured out they're the same as any other gem...
+
+  gem install activegist
+
+== Usage
+
+  require 'rubygems' # on old rubies
+  require 'activegist'
+  
+  # Set up credentials. A required step, as far as I know.
+  ActiveGist::API.username = "gist owner's github username"
+  ActiveGist::API.password = "gist owner's github password"
+  
+  # Various examples of creating and saving a new gist
+  gist = ActiveGist.new
+  gist.description = "gist description"
+  gist.files                                              #=> {}
+  gist.files['test.txt'] = { :content => 'file content' }
+  gist.save                                               #=> true or false
+  gist.save!                                              #=> raise an error on validation error
+  
+  # gists are private by default. To make them public, pass a :public option.
+  gist = ActiveGist.new :public => true,
+                        :description => "optional",
+                        :files => { 'test.txt' => { :content => 'file content' } })
+  gist.save
+  
+  gist = ActiveGist.create!(:files => { 'test.txt' => { :content => 'file content' } })
+  
+  # Check if gist is valid
+  gist = ActiveGist.new
+  gist.valid?               #=> false
+  gist.errors.full_messages #=> ["Files can't be blank"] 
+  gist.errors[:files]       #=> ["can't be blank"]
+  
+  # Find an existing gist if you know its ID
+  gist = ActiveGist.find id
+  gist.public?  #=> true if the gist is public, false otherwise
+  gist.files
+  #=>
+  #  {"test.txt"=>
+  #    {"type"=>"text/plain",
+  #     "content"=>"file content", 
+  #     "raw_url"=>"https://gist.github.com/.../test.txt",
+  #     "size"=>12,
+  #     "filename"=>"test.txt",
+  #     "language"=>"Text"
+  #    }
+  #  }
+  
+  # Fork an existing gist. Yes, really.
+  gist = ActiveGist.find id
+  forked_gist = gist.fork
+  
+  # Check if gist is already starred, then star it, then unstar it.
+  # (Unlike most methods, these take effect immediately!)
+  gist = ActiveGist.find id
+  gist.starred?    #=> boolean
+  gist.star!
+  gist.unstar!
+  
+  # Get a whole bunch of gists.
+  ActiveGist.all
+  ActiveGist.all :public    # returns only public gists
+  ActiveGist.all :starred   # returns only starred gists
+  
+  # Get just one gist.
+  ActiveGist.first
+  ActiveGist.last
+  
+  # Count gists.
+  ActiveGist.count
+  ActiveGist.count :public
+  ActiveGist.count :starred
+  
+  # Save changes to a gist
+  gist = ActiveGist.first
+  gist.files['test.txt'][:content] = "Updated content"
+  gist.changed?  #=> true
+  gist.save      #=> true if saved, false if validation failed
+  gist.save!     #=> true if saved, raise error if validation failed
+  
+  # Destroy the gist, it's just a test gist anyway
+  gist.destroy
+
+== Good Lovin'
+
+Released under the MIT license. Copyright (c) 2012, Colin MacKenzie IV

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'active_gist/version'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'rdoc/task'
+RDoc::Task.new do |t|
+  t.rdoc_dir = 'doc'
+  t.title    = "ActiveGist #{ActiveGist::VERSION} Documentation"
+  t.options << '--line-numbers'
+  t.rdoc_files.include('README.rdoc', 'CHANGELOG', 'LICENSE', 'lib/**/*.rb')
+end
+
+task :default => :spec

data/activegist.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_gist/version"
+
+Gem::Specification.new do |s|
+  s.name        = "activegist"
+  s.version     = ActiveGist::VERSION
+  s.authors     = ["Colin MacKenzie IV"]
+  s.email       = ["sinisterchipmunk@gmail.com"]
+  s.homepage    = "http://github.com/sinisterchipmunk/active-gist"
+  s.summary     = %q{Wraps GitHub's Gist API with an intuitive class based on ActiveModel.}
+  s.description = %q{Wraps GitHub's Gist API with a class implementing the ActiveModel modules. So, it should be pretty familiar to anyone who's ever used models in Ruby on Rails.}
+
+  s.rubyforge_project = "activegist"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", '~> 2.8.0'
+  s.add_development_dependency "fakeweb", '~> 1.3.0'
+  s.add_development_dependency 'rake', "~> 0.9.2.2"
+  s.add_development_dependency 'rdoc', "~> 3.12"
+  
+  s.add_runtime_dependency "activemodel", '~> 3.1.3'
+  s.add_runtime_dependency "activesupport", '~> 3.1.3'
+  s.add_runtime_dependency "rest-client", '~> 1.6.7'
+end

data/lib/active_gist.rb

@@ -0,0 +1,134 @@
+require 'active_model'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext'
+require 'json'
+
+class ActiveGist
+  autoload :Version,      "active_gist/version"
+  autoload :VERSION,      "active_gist/version"
+  autoload :API,          "active_gist/api"
+  autoload :Attributes,   "active_gist/attributes"
+  autoload :ClassMethods, "active_gist/class_methods"
+  autoload :Errors,       "active_gist/errors/invalid"
+  autoload :Files,        "active_gist/files"
+  
+  extend ActiveModel::Naming
+  extend ActiveModel::Callbacks
+  include ActiveModel::Validations
+  include ActiveModel::Dirty
+  include ActiveModel::Conversion
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Serializers::Xml
+  
+  include ActiveGist::API
+  include ActiveGist::Attributes
+  extend ActiveGist::API
+  extend ActiveGist::ClassMethods
+  
+  define_model_callbacks :save, :create, :update, :initialize, :validation
+  validate { |record| record.errors.add(:files, "can't be blank") if record.files.empty? }
+  
+  alias _changed? changed? #:nodoc:
+  def changed?
+    _changed? || files.changed?
+  end
+  
+  def initialize(attributes = {})
+    run_callbacks :initialize do
+      self.attributes = attributes
+    end
+  end
+  
+  def inspect
+    "#<#{self.class.name} #{attributes.collect { |a| [a[0], a[1].inspect].join('=') }.join(' ')}>"
+  end
+  
+  def persisted?
+    !destroyed? && !id.blank? && !changed?
+  end
+  
+  def new_record?
+    !destroyed? && id.blank?
+  end
+  
+  def destroyed?
+    !!@destroyed
+  end
+  
+  def destroy
+    api[id].delete :accept => 'application/json'
+    @id = nil
+    @destroyed = true
+  end
+  
+  def fork
+    self.class.load(JSON.parse api[id]['fork'].post("", :accept => 'application/json'))
+  end
+  
+  def files=(hash)
+    files.replace_with hash.with_indifferent_access
+  end
+  
+  def files
+    @files ||= ActiveGist::Files.new
+  end
+  
+  def ==(other)
+    other.kind_of?(ActiveGist) && id == other.id
+  end
+  
+  def save
+    valid = begin
+      run_callbacks :validation do
+        valid?
+      end
+    end
+    
+    return false unless valid
+    
+    create_or_update_callback = new_record? ? :create : :update
+    run_callbacks create_or_update_callback do
+      run_callbacks :save do
+        if new_record?
+          data = as_json(:only => [:description, :public, :files]).delete('active_gist').to_json
+          response = api.post data, :content_type => 'application/json', :accept => 'application/json'
+        else
+          data = as_json(:only => [:description, :files]).delete('active_gist').to_json
+          response = api[id].patch data, :content_type => 'application/json', :accept => 'application/json'
+        end
+        self.attributes = JSON.parse response
+        @previously_changed = changes
+        changed_attributes.clear
+      end
+    end
+
+    true
+  end
+  
+  def save!
+    raise ActiveGist::Errors::Invalid, "Gist is invalid: #{errors.full_messages.join('; ')}" unless save
+  end
+
+  def starred?
+    if @star.nil?
+      @star = begin
+        @star = api[id]['star'].get :accept => 'application/json'
+        true
+      rescue RestClient::ResourceNotFound
+        false
+      end
+    else
+      @star
+    end
+  end
+  
+  def star!
+    api[id]['star'].put("", :accept => 'application/json')
+    @star = true
+  end
+  
+  def unstar!
+    api[id]['star'].delete(:accept => 'application/json')
+    @star = false
+  end
+end

data/lib/active_gist/api.rb

@@ -0,0 +1,33 @@
+require 'rest-client'
+
+module ActiveGist::API
+  class << self
+    def username
+      @username
+    end
+    
+    def password
+      @password
+    end
+    
+    def username=(username)
+      @username = username
+    end
+    
+    def password=(password)
+      @password = password
+    end
+  end
+  
+  def username
+    ActiveGist::API.username
+  end
+  
+  def password
+    ActiveGist::API.password
+  end
+  
+  def api
+    @api ||= RestClient::Resource.new("https://api.github.com/gists", username, password)
+  end
+end

data/lib/active_gist/attributes.rb

@@ -0,0 +1,107 @@
+module ActiveGist::Attributes
+  GIST_ATTRIBUTES = %w(url id description public user files comments
+                       html_url git_pull_url git_push_url created_at
+                       forks history updated_at)
+                       
+  def self.included(base) #:nodoc:
+    base.define_attribute_methods GIST_ATTRIBUTES
+  end
+  
+  def forks
+    @forks
+  end
+  
+  def history
+    @history
+  end
+  
+  def url
+    @url
+  end
+  
+  def id
+    @id
+  end
+  
+  def description
+    @description
+  end
+  
+  def public?
+    !!@public
+  end
+  alias public public?
+  
+  def user
+    @user
+  end
+  
+  def files
+    @files
+  end
+  
+  def comments
+    @comments
+  end
+  
+  def html_url
+    @html_url
+  end
+  
+  def git_pull_url
+    @git_pull_url
+  end
+  
+  def git_push_url
+    @git_push_url
+  end
+  
+  def created_at
+    @created_at
+  end
+  
+  def updated_at
+    @updated_at
+  end
+  
+  def description=(descr)
+    description_will_change!
+    @description = descr
+  end
+  
+  def public=(pub)
+    public_will_change!
+    @public = pub
+  end
+  
+  def files=(files)
+    files_will_change!
+    @files = files
+  end
+  
+  def attributes
+    GIST_ATTRIBUTES.inject({}) { |h,k| h[k] = self[k]; h }
+  end
+  
+  def attributes=(attributes)
+    attributes.each do |key, value|
+      if respond_to?(:"#{key}=")
+        send :"#{key}=", value
+      else
+        if GIST_ATTRIBUTES.include?(key.to_s)
+          instance_variable_set :"@#{key}", value
+        else
+          raise ArgumentError, "Unknown attribute #{key.inspect}; expected one of #{GIST_ATTRIBUTES.inspect}"
+        end
+      end
+    end
+  end
+
+  def [](attribute)
+    send attribute.to_sym
+  end
+  
+  def []=(attribute, value)
+    send :"#{attribute}=", value
+  end
+end