boblail-unfuddle 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c4a223f7cf345cfab592d4b71aa877cb04bbbe7
+  data.tar.gz: fb9e1a041a454022f5c779743ef5c6df879f7fd9
+SHA512:
+  metadata.gz: 7c0da95ccb04a123c6553cfe44a488c8a8f562aa954a79ec0f26277f6ed549a48e2072d49fbbe3f28a33ffd4eb6029892f247e8d8e808d849dc36ce22b1339b7
+  data.tar.gz: 7810194c1b509809f2031c3ba061978936e56d8f2e30483ab56b444e28e2d4ecda9b7697d39bcd248bcad4fda8f924a3301adf1033fb69d18771b89c3aa1dab6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hiccup.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end

data/lib/unfuddle.rb

@@ -0,0 +1,171 @@
+require 'faraday'
+require 'json'
+require 'active_support/core_ext/benchmark'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'unfuddle/configuration'
+require 'unfuddle/error'
+require 'unfuddle/project'
+require 'unfuddle/person'
+require 'unfuddle/response'
+require 'unfuddle/has_tickets'
+
+
+class Unfuddle
+  include HasTickets
+  
+  class << self
+    
+    def config(options=nil)
+      configuration = Unfuddle::Configuration.new
+      configuration.from_options(options) if options
+      yield configuration if block_given?
+      instance.configuration = configuration
+    end
+    
+    def with_config(options)
+      current_configuration = instance.configuration
+      begin
+        config(current_configuration.merge(options))
+        yield
+      ensure
+        instance.configuration = current_configuration
+      end
+    end
+    
+    def instance
+      @unfuddle ||= self.new
+    end
+    
+    def assert_response!(expected_response_code, response)
+      unless response.status == expected_response_code
+        raise InvalidResponseError.new(response)
+      end
+    end
+    
+    # Homemade `delegate`
+    [:get, :post, :put, :delete, :configuration].each do |method|
+      module_eval <<-RUBY
+        def #{method}(*args, &block)
+          instance.#{method}(*args, &block)
+        end
+      RUBY
+    end
+    
+    [:subdomain, :username, :password, :logger, :include_associations?, :include_closed_on?, :timeout].each do |method|
+      module_eval <<-RUBY
+        def #{method}
+          configuration.#{method}
+        end
+      RUBY
+    end
+    
+  end
+  
+  attr_reader :configuration
+  
+  def configuration=(configuration)
+    @configuration = configuration
+    @http = nil
+  end
+  
+  [:subdomain, :username, :password, :logger, :include_associations?, :include_closed_on?, :timeout].each do |method|
+    module_eval <<-RUBY
+      def #{method}
+        configuration.#{method}
+      end
+    RUBY
+  end
+  
+  
+  
+  def projects
+    Unfuddle.Project.all
+  end
+  
+  def project(project_id)
+    Unfuddle::Project.new("id" => project_id)
+  end
+  
+  def people(options={})
+    Unfuddle::Person.all(options)
+  end
+  
+  def person(person_id)
+    Unfuddle::Person.new("id" => person_id)
+  end
+  
+  
+  
+  def get(path)
+    http_send_with_logging :get, path
+  end
+  
+  def post(path, object)
+    http_send_with_logging :post, path, object.to_xml
+  end
+  
+  def put(path, object)
+    http_send_with_logging :put, path, object.to_xml
+  end
+  
+  def delete(path)
+    http_send_with_logging :delete, path
+  end
+  
+  
+  
+  def configured?
+    subdomain && username && password
+  end
+  
+  
+  
+protected
+  
+  def http_send_with_logging(method, path, body=nil, headers={})
+    path = "/api/v1/#{path}"
+    headers = headers.merge({ # read JSON, write XML
+      "Accept" => "application/json",
+      "Content-type" => "application/xml" })
+    
+    response = nil
+    ms = Benchmark.ms do
+      response =  http_send(method, path, body, headers)
+    end
+    response
+  ensure
+    message = "[unfuddle:#{method}]  #{path}"
+    message << "\n  #{body}" if body
+    message = '%s (%.1fms)' % [ message, ms ] if ms
+    logger.info(message)
+    
+    url = http.url_prefix.to_s + path
+    logger.warn "[unfuddle:#{method}] URL length exceeded 2000 characters" if url.length > 2000
+  end
+  
+  def http_send(method, path, body, headers)
+    response = http.public_send(method, path, body, headers) do |req|
+      req.options[:timeout] = timeout
+    end
+    
+    Response.new(response).tap do |response|
+      raise ServerError.new(response) if response.server_error?
+      raise UnauthorizedError.new(response) if response.unauthorized?
+    end
+    
+  rescue Faraday::Error::ConnectionFailed
+    raise ConnectionError, $!.message
+  rescue Faraday::Error::TimeoutError, Errno::ETIMEDOUT
+    raise TimeoutError, $!.message
+  end
+  
+  def http
+    raise ConfigurationError, "Unfuddle is not configured" unless configured?
+    @http ||= Faraday.new("https://#{subdomain}.unfuddle.com", ssl: {verify: false}) do |faraday|
+      faraday.adapter Faraday.default_adapter
+      faraday.basic_auth username, password
+    end
+  end
+  
+end

data/lib/unfuddle/base.rb

@@ -0,0 +1,223 @@
+require 'unfuddle'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+
+
+class Unfuddle
+  class Base
+    
+    def initialize(attributes)
+      __set_attributes(attributes)
+    end
+    
+    def unfetched?
+      @attributes.keys == %w{id}
+    end
+    
+    def id
+      @attributes["id"]
+    end
+    
+    def __set_attributes(attributes)
+      raise ArgumentError, "attributes is expected to be a hash, but it was #{attributes.class} instead" unless attributes.is_a?(Hash)
+      if @attributes
+        @attributes.merge! attributes
+      else
+        @attributes = attributes
+      end
+    end
+    
+    
+    
+    # Respond to attributes
+    
+    def attributes
+      _attributes.dup
+    end
+    
+    def method_missing(method_name, *args, &block)
+      if has_attribute?(method_name)
+        _attributes[method_name.to_s]
+      else
+        super(method_name, *args, &block)
+      end
+    end
+    
+    def respond_to?(method_name)
+      super(method_name) || has_attribute?(method_name)
+    end
+    
+    def has_attribute?(attribute_name)
+      _attributes.key?(attribute_name.to_s)
+    end
+    
+    def write_attribute(attribute, value)
+      _attributes[attribute.to_s] = value
+    end
+    
+    def update_attributes!(attributes)
+      attributes.each do |key, value|
+        write_attribute(key, value)
+      end
+      save!
+    end
+    
+    def update_attribute(attribute, value)
+      write_attribute(attribute, value)
+      save!
+    end
+    
+    
+    
+    # Finders
+    
+    class << self
+      
+      def find_by(*attributes)
+        attributes.each do |attribute|
+          instance_eval <<-RUBY
+            def find_by_#{attribute}(value)
+              all.find { |instance| instance.#{attribute} == value }
+            end
+          RUBY
+        end
+      end
+      
+    end
+    
+    
+    
+    # Has many
+    
+    class << self
+      
+      def has_many(collection_name, options={})
+        collection_name = collection_name.to_s
+        path = collection_name
+        individual_name = collection_name.singularize
+        class_name = options.fetch(:class_name, individual_name.classify)
+        
+        require "unfuddle/#{individual_name}"
+        
+        class_eval <<-RUBY
+          def #{collection_name}
+            @#{collection_name} ||= get('#{path}').json.map { |attributes| #{class_name}.new(attributes) }
+          end
+          
+          def #{individual_name}(id)
+            attributes = find_#{individual_name}(id)
+            #{class_name}.new(attributes) if attributes
+          end
+          
+          def find_#{individual_name}(id)
+            response = get("#{path}/\#{id}")
+            
+            return nil if response.status == 404
+            Unfuddle.assert_response!(200, response)
+            
+            response.json
+          end
+          
+          def new_#{individual_name}(attributes)
+            #{class_name}.new(attributes)
+          end
+          
+          def create_#{individual_name}(params)
+            instance = #{class_name}.new(params)
+            response = post('#{path}', instance)
+            Unfuddle.assert_response!(201, response)
+            
+            instance.__set_attributes(response.json)
+            
+            unless instance.id
+              id = response.location.chomp("/")[/\\d+$/].to_i
+              instance.__set_attributes("id" => id) if id > 0
+            end
+            
+            @#{collection_name}.push(instance) if @#{collection_name}
+            instance
+          end
+        RUBY
+      end
+      
+    end
+    
+    
+    
+    # Nest Unfuddle requests
+    
+    def relative_path
+      raise NotImplementedError
+    end
+    
+    [:get, :post, :put, :delete].each do |method|
+      module_eval <<-RUBY
+        def #{method}(path, *args)
+          Unfuddle.#{method}(relative_path + "/" + path, *args)
+        end
+      RUBY
+    end
+    
+    
+    
+    # Serialization
+    
+    def to_params
+      attributes
+    end
+    
+    def singular_name
+      self.class.name[/[^:]*$/].tableize.singularize
+    end
+    
+    def to_xml
+      to_params.to_xml(root: singular_name)
+    end
+    
+    def to_json
+      JSON.dump({singular_name => to_params})
+    end
+    
+    def fetch!
+      response = get(get_path)
+      Unfuddle.assert_response!(200, response)
+      __set_attributes(response.json)
+    
+    rescue InvalidResponseError
+      binding.pry if binding.respond_to?(:pry)
+      raise $!
+    end
+    
+    def save!
+      put put_path, self
+    end
+    
+    def destroy!
+      delete delete_path
+    end
+    
+    
+    
+    def get_path
+      ""
+    end
+    
+    def put_path
+      ""
+    end
+    
+    def delete_path
+      ""
+    end
+    
+    
+    
+  private
+    
+    def _attributes
+      fetch! if unfetched?
+      @attributes
+    end
+    
+  end
+end

data/lib/unfuddle/comment.rb

@@ -0,0 +1,13 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class Comment < Base
+    
+    def relative_path
+      "projects/#{project_id}/tickets/#{parent_id}/comments/#{id}"
+    end
+    
+    attr_accessor :project_id
+    
+  end
+end

data/lib/unfuddle/component.rb

@@ -0,0 +1,11 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class Component < Base
+    
+    def relative_path
+      "projects/#{project_id}/components/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/configuration.rb

@@ -0,0 +1,67 @@
+class Unfuddle
+  class Configuration
+    
+    
+    [:subdomain, :username, :password, :logger, :include_associations, :include_closed_on, :timeout].each do |attribute|
+      module_eval <<-RUBY
+        def #{attribute}(*arg)
+          set_value :#{attribute}, arg.first if arg.any?
+          get_value :#{attribute}
+        end
+        
+        def #{attribute}=(value)
+          set_value :#{attribute}, value
+        end
+      RUBY
+    end
+    
+    
+    alias :include_associations? :include_associations
+    alias :include_closed_on? :include_closed_on
+    
+    
+    def merge(options)
+      to_h.merge(options)
+    end
+    
+    def to_h
+      { subdomain: subdomain,
+        username: username,
+        password: password,
+        include_associations: include_associations,
+        include_closed_on: include_closed_on,
+        logged: logger,
+        timeout: timeout }
+    end
+    
+    def from_options(options)
+      options = options.with_indifferent_access
+      self.subdomain             = options[:subdomain]             if options.key?(:subdomain)
+      self.username              = options[:username]              if options.key?(:username)
+      self.password              = options[:password]              if options.key?(:password)
+      self.include_associations  = options[:include_associations]  if options.key?(:include_associations)
+      self.include_closed_on     = options[:include_closed_on]     if options.key?(:include_closed_on)
+      self.timeout               = options.fetch :timeout, 120
+      self.logger                = options.fetch :logger, Unfuddle::Configuration::Logger.new
+    end
+    
+    
+    class Logger
+      def info(s)
+        puts s
+      end
+    end
+    
+    
+  private
+    
+    def set_value(attribute, value)
+      instance_variable_set(:"@#{attribute}", value)
+    end
+    
+    def get_value(attribute)
+      instance_variable_get(:"@#{attribute}")
+    end
+    
+  end
+end

data/lib/unfuddle/custom_field_value.rb

@@ -0,0 +1,11 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class CustomFieldValue < Base
+    
+    def relative_path
+      "projects/#{project_id}/custom_field_values/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/error.rb

@@ -0,0 +1,59 @@
+class Unfuddle
+  
+  module Error
+  end
+  
+  class ConfigurationError < StandardError
+    include ::Unfuddle::Error
+  end
+  
+  class ConnectionError < StandardError
+    include ::Unfuddle::Error
+  end
+  
+  class TimeoutError < ConnectionError
+  end
+  
+  
+  
+  class InvalidResponseError < StandardError
+    include ::Unfuddle::Error
+    
+    def initialize(response)
+      @response = response
+    end
+    
+    attr_reader :response
+    
+    def message
+      response.body
+    end
+    
+  end
+  
+  class ServerError < InvalidResponseError
+  end
+  
+  class UnauthorizedError < InvalidResponseError
+    
+    def message
+      "The user '#{Unfuddle.instance.username}' does not have permission to access this resource"
+    end
+    
+  end
+  
+  
+  
+  class UndefinedCustomField < ArgumentError
+    include ::Unfuddle::Error
+  end
+  
+  class UndefinedCustomFieldValue < ArgumentError
+    include ::Unfuddle::Error
+  end
+  
+  class UndefinedSeverity < ArgumentError
+    include ::Unfuddle::Error
+  end
+  
+end

data/lib/unfuddle/has_tickets.rb

@@ -0,0 +1,68 @@
+require 'active_support/core_ext/array/wrap'
+
+
+class Unfuddle
+  module HasTickets
+    
+    def find_ticket_by_number(number)
+      response = get("tickets/by_number/#{number}")
+      
+      return nil if response.status == 404
+      Unfuddle.assert_response!(200, response)
+      
+      response.json
+    end
+    
+    def find_tickets!(*conditions)
+      raise ArgumentError.new("No conditions supplied: that's probably not good") if conditions.none?
+      path = "ticket_reports/dynamic.json"
+      path << "?conditions_string=#{construct_ticket_query(*conditions)}"
+      fields = %w{number summary description reporter_email resolution milestone_id created_at due_on severity_id component_id}
+      fields << "associations" if Unfuddle.include_associations?
+      fields << "closed_on" if Unfuddle.include_closed_on?
+      path << "&fields_string=#{fields.join(",")}" if fields.any?
+      response = get(path)
+      
+      Unfuddle.assert_response!(200, response)
+      
+      ticket_report = response.json
+      group0 = ticket_report.fetch("groups", [])[0] || {}
+      group0.fetch("tickets", [])
+    end
+    
+    
+    
+    def construct_ticket_query(*conditions)
+      conditions_string = []
+      conditions.each do |condition|
+        case condition
+        when Hash
+          conditions_string.concat(condition.map { |key, value| Array.wrap(value).map { |value| create_condition_string(key, value) }.join("|") })
+        when Array
+          key, value = condition
+          conditions_string.push(Array.wrap(value).map { |value| create_condition_string(key, value) }.join("|"))
+        else
+          conditions_string.push(condition)
+        end
+      end
+      conditions_string.join("%2C")
+    end
+    
+    def create_condition_string(key, value)
+      comparison = "eq"
+      comparison, value = "neq", value.value if value.is_a?(Neq)
+      key, value = prepare_key_and_value_for_conditions_string(key, value)
+      "#{key}-#{comparison}-#{value}"
+    end
+    
+    def prepare_key_and_value_for_conditions_string(key, value)
+      
+      # If the value is an id, convert it to a number
+      value = value.to_i if value.is_a?(String) && value =~ /^\d+$/
+      
+      [key, value]
+    end
+    
+  end
+  
+end

data/lib/unfuddle/milestone.rb

@@ -0,0 +1,11 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class Milestone < Base
+    
+    def relative_path
+      "projects/#{project_id}/milestones/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/neq.rb

@@ -0,0 +1,24 @@
+class Unfuddle
+  module NeqHelper
+    
+    def neq(arg)
+      Neq.new(arg)
+    end
+    
+  end
+  
+  class Neq
+    
+    def initialize(value)
+      @value = value
+    end
+    
+    def to_s
+      "neq(#{value.inspect})"
+    end
+    
+    attr_reader :value
+    
+  end
+end
+  

data/lib/unfuddle/person.rb

@@ -0,0 +1,24 @@
+require 'unfuddle/base'
+
+
+class Unfuddle
+  class Person < Base
+    
+    def self.all(options={})
+      url = options[:including_removed] == true ? "people.json?removed=true" : "people.json"
+      response = Unfuddle.get(url)
+      
+      if response.status == 404
+        nil
+      else
+        Unfuddle.assert_response!(200, response)
+        response.json.map { |attributes| self.new(attributes) }
+      end
+    end
+    
+    def relative_path
+      "people/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/project.rb

@@ -0,0 +1,136 @@
+require 'unfuddle/base'
+require 'unfuddle/has_tickets'
+
+
+class Unfuddle
+  class Project < Base
+    include HasTickets
+    
+    def self.all
+      @projects ||= begin
+        response = Unfuddle.get('projects')
+        
+        if response.status == 404
+          nil
+        else
+          Unfuddle.assert_response!(200, response)
+          response.json.map { |attributes| self.new(attributes) }
+        end
+      end
+    end
+    
+    def self.fetch(id)
+      response = Unfuddle.get("projects/#{id}")
+      
+      if response.status == 404
+        nil
+      else
+        Unfuddle.assert_response!(200, response)
+        self.new response.json
+      end
+    end
+    
+    def relative_path
+      "projects/#{id}"
+    end
+    
+    
+    
+    find_by :title
+    
+    has_many :custom_field_values
+    has_many :severities
+    has_many :components
+    has_many :ticket_reports
+    has_many :tickets
+    has_many :milestones
+    
+    
+    
+    def open_milestones
+      @open_milestones ||= get("projects/#{id}/milestones/upcoming").json.map { |attributes| Milestone.new(attributes) }
+    end
+    
+    
+    
+    def custom_fields
+      { 1 => ticket_field1_active ? ticket_field1_title : nil,
+        2 => ticket_field2_active ? ticket_field2_title : nil,
+        3 => ticket_field3_active ? ticket_field3_title : nil }
+    end
+    
+    def custom_fields_defined
+      custom_fields.values.compact
+    end
+    
+    def custom_field_defined?(field_title)
+      custom_fields_defined.member?(field_title)
+    end
+    
+    def first_available_custom_field
+      (1..3).find { |n| custom_fields[n].nil? }
+    end
+    
+    def number_of_custom_field_named!(name)
+      number_of_custom_field_named(name) || (raise UndefinedCustomField, "A custom field named \"#{name}\" is not defined!")
+    end
+    
+    def number_of_custom_field_named(name)
+      custom_fields.key(name)
+    end
+    
+    
+    
+    def find_custom_field_value_by_value!(field, value)
+      n = number_of_custom_field_named!(field)
+      result = custom_field_values.find { |cfv| cfv.field_number == n && cfv.value == value }
+      raise UndefinedCustomFieldValue, "\"#{value}\" is not a value for the custom field \"#{field}\"!" unless result
+      result
+    end
+    
+    def find_custom_field_value_by_id!(field, id)
+      n = number_of_custom_field_named!(field)
+      result = custom_field_values.find { |cfv| cfv.field_number == n && cfv.id == id }
+      raise UndefinedCustomFieldValue, "\"#{id}\" is not the id of a value for the custom field \"#{field}\"!" unless result
+      result
+    end
+    
+    
+    
+    def find_severity_by_name!(name)
+      find_severity_by_name(name) || (raise UndefinedSeverity, "A severity named \"#{name}\" is not defined!")
+    end
+    
+    def find_severity_by_name(name)
+      severities.find { |severity| severity.name == name }
+    end
+    
+    
+    
+    def prepare_key_and_value_for_conditions_string(key, value)
+      key, value = super
+      
+      # If the value is the name of a severity, try to look it up
+      value = find_severity_by_name!(value).id if key == :severity && value.is_a?(String)
+      
+      # If the key is a custom field, look up the key and value
+      if key.is_a?(String)
+        value = find_custom_field_value_by_value!(key, value).id unless value.is_a?(Fixnum)
+        key = get_key_for_custom_field_named!(key)
+      end
+      
+      [key, value]
+    end
+    
+    def get_key_for_custom_field_named!(name)
+      "field_#{number_of_custom_field_named!(name)}"
+    end
+    
+    def get_ticket_attribute_for_custom_value_named!(name)
+      "field#{number_of_custom_field_named!(name)}_value_id"
+    end
+    
+    
+    
+  end
+end

data/lib/unfuddle/response.rb

@@ -0,0 +1,49 @@
+require 'unfuddle/error'
+
+
+class Unfuddle
+  class Response
+    
+    
+    def initialize(faraday_response)
+      @faraday_response = faraday_response
+    end
+    
+    def status
+      faraday_response.status
+    end
+    
+    def server_error?
+      status == 500
+    end
+    
+    def unauthorized?
+      status == 401
+    end
+    
+    def body
+      faraday_response.body
+    end
+    
+    def location
+      faraday_response["location"]
+    end
+    
+    def json
+      @json ||= begin
+        json = self.class.normalized_body(body)
+        json.empty? ? {} : JSON.load(json)
+      end
+    end
+    
+    def self.normalized_body(body)
+      body.gsub(/\u0000/, "").strip
+    end
+    
+    
+  private
+    
+    attr_reader :faraday_response
+    
+  end
+end

data/lib/unfuddle/severity.rb

@@ -0,0 +1,11 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class Severity < Base
+    
+    def relative_path
+      "projects/#{project_id}/severities/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/ticket.rb

@@ -0,0 +1,13 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class Ticket < Base
+    
+    def relative_path
+      "projects/#{project_id}/tickets/#{id}"
+    end
+    
+    has_many :comments
+    
+  end
+end

data/lib/unfuddle/ticket_report.rb

@@ -0,0 +1,11 @@
+require 'unfuddle/base'
+
+class Unfuddle
+  class TicketReport < Base
+    
+    def relative_path
+      "projects/#{parent_id}/ticket_reports/#{id}"
+    end
+    
+  end
+end

data/lib/unfuddle/version.rb

@@ -0,0 +1,3 @@
+class Unfuddle
+  VERSION = "0.7.0"
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require "rubygems"
+require "simplecov"
+require "rails"
+require "rails/test_help"
+require "active_support/core_ext"
+require "turn"

data/unfuddle.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "unfuddle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "boblail-unfuddle"
+  s.version     = Unfuddle::VERSION
+  s.authors     = ["Bob Lail"]
+  s.email       = ["bob.lailfamily@gmail.com"]
+
+  s.homepage    = "http://boblail.github.com/unfuddle/"
+  s.summary     = %q{A library for communicating with Unfuddle}
+  s.description = %q{A library for communicating with Unfuddle}
+
+  s.add_dependency "activesupport"
+  s.add_dependency "builder"
+  s.add_dependency "faraday", "~> 0.8.8"
+
+  s.add_development_dependency "rails"
+  s.add_development_dependency "turn"
+  s.add_development_dependency "simplecov"
+
+  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"]
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: boblail-unfuddle
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Bob Lail
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library for communicating with Unfuddle
+email:
+- bob.lailfamily@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/unfuddle.rb
+- lib/unfuddle/base.rb
+- lib/unfuddle/comment.rb
+- lib/unfuddle/component.rb
+- lib/unfuddle/configuration.rb
+- lib/unfuddle/custom_field_value.rb
+- lib/unfuddle/error.rb
+- lib/unfuddle/has_tickets.rb
+- lib/unfuddle/milestone.rb
+- lib/unfuddle/neq.rb
+- lib/unfuddle/person.rb
+- lib/unfuddle/project.rb
+- lib/unfuddle/response.rb
+- lib/unfuddle/severity.rb
+- lib/unfuddle/ticket.rb
+- lib/unfuddle/ticket_report.rb
+- lib/unfuddle/version.rb
+- test/test_helper.rb
+- unfuddle.gemspec
+homepage: http://boblail.github.com/unfuddle/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A library for communicating with Unfuddle
+test_files:
+- test/test_helper.rb