mavenlink-ruby 0.0.2

data/lib/mavenlink/api_operations/request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  module APIOperations
+    module Request
+      module ClassMethods
+        def get(path, params = {})
+          api_base = Mavenlink.api_base
+          api_key = Mavenlink.api_key
+          options = {
+            query: params,
+            headers: {
+              Authorization: "Bearer #{api_key}",
+            },
+          }
+          HTTParty.get("#{api_base}#{path}", options)
+        end
+
+        def post(path, params = {})
+          api_base = Mavenlink.api_base
+          api_key = Mavenlink.api_key
+          options = {
+            body: params,
+            headers: {
+              Authorization: "Bearer #{api_key}",
+            },
+          }
+          HTTParty.post("#{api_base}#{path}", options)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected def get(url, params = {})
+        self.class.get(url, params)
+      end
+    end
+  end
+end

data/lib/mavenlink/api_resource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class APIResource
+    include Mavenlink::APIOperations::Request
+
+    def self.resource_url
+      if self == APIResource
+        raise NotImplementedError,
+              "APIResource is an abstract class, you should before actions "\
+              "on its subclasses (Workspace, Invoice, etc.)"
+      end
+
+      "/#{plural_name}"
+    end
+
+    def self.plural_name
+      "#{self::OBJECT_NAME.downcase}s"
+    end
+
+    def self.retrieve(id)
+      instance = new(id: id)
+      instance.refresh
+    end
+
+    def self.list(params = {}, options = {})
+      response = get(resource_url, params)
+      List.new(self, response, options)
+    end
+
+    def refresh
+      response = get(resource_url)
+      data = Util.results(response).first
+      self.class.new(data)
+    end
+
+    def initialize(data)
+      @values = data
+
+      update_attributes(@values)
+    end
+
+    def resource_url
+      unless (id = self.id)
+        raise InvalidRequestError.new(
+          "Could not determine which URL to request: #{self.class} instance " \
+          "has invalid ID: #{id.inspect}",
+          "id"
+        )
+      end
+      "#{self.class.resource_url}/#{CGI.escape(id)}"
+    end
+
+    protected def metaclass
+      class << self; self; end
+    end
+
+    protected def update_attributes(values)
+      values.each do |k, v|
+        add_accessor(k, v) unless metaclass.method_defined? k.to_sym
+      end
+    end
+
+    protected def add_accessor(key, value)
+      metaclass.instance_eval do
+        define_method(key) { value }
+      end
+    end
+  end
+end

data/lib/mavenlink/list.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class List
+    include Enumerable
+
+    attr_accessor :data
+
+    attr_reader :page_number
+    attr_reader :page_count
+
+    def initialize(klass, response, options = {})
+      @meta = response["meta"]
+      @klass = klass
+      @page_number = @meta["page_number"]
+      @page_count = @meta["page_count"]
+      @options = options
+      results = setup_results(response)
+      @data = results.map { |thing| klass.new(thing) }
+    end
+
+    def each(&blk)
+      @data.each(&blk)
+    end
+
+    def auto_paging_each(&blk)
+      return enum_for(:auto_paging_each) unless block_given?
+
+      page = self
+      loop do
+        page.each(&blk)
+
+        break if page.last_page?
+
+        page = page.next_page
+      end
+    end
+
+    def last_page?
+      @page_number == @page_count
+    end
+
+    def next_page
+      @klass.list({ page: @page_number + 1 }, @options)
+    end
+
+    private def setup_results(response)
+      results = Util.results(response)
+
+      if (filters = Util.stringify_keys(@options[:filters]))
+        results.select! do |res|
+          filters.map { |key, value| res[key] == value }.all?
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/mavenlink/resources.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mavenlink/resources/custom_field_value"
+require "mavenlink/resources/invoice"
+require "mavenlink/resources/workspace"
+require "mavenlink/resources/workspace_group"

data/lib/mavenlink/resources/custom_field_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class CustomFieldValue < APIResource
+    OBJECT_NAME = "custom_field_value"
+
+    def self.list(subject_type = nil)
+      if subject_type.nil?
+        raise ArgumentError,
+              "CustomFieldValues can only be listed with a subject, " \
+              "e.g. CustomFieldValue.list('user')"
+      end
+
+      super(subject_type: subject_type)
+    end
+
+    def subject
+      case subject_type
+      when "workspace_group"
+        WorkspaceGroup.retrieve(subject_id)
+      end
+    end
+  end
+end

data/lib/mavenlink/resources/invoice.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class Invoice < APIResource
+    include Mavenlink::APIOperations::Request
+
+
+    OBJECT_NAME = "invoice"
+
+    def self.create(params = {})
+      response = post(resource_url, params)
+      data = Util.results(response).first
+      self.class.new(data)
+    end
+  end
+end

data/lib/mavenlink/resources/workspace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class Workspace < APIResource
+    OBJECT_NAME = "workspace"
+
+    def self.list_invoices(id)
+      response = get("/invoices?workspace_id=#{id}")
+      List.new(Invoice, response)
+    end
+  end
+end

data/lib/mavenlink/resources/workspace_group.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mavenlink
+  class WorkspaceGroup < APIResource
+    OBJECT_NAME = "workspace_group"
+
+    def self.list_workspaces(id)
+      response = get("/workspaces?workspace_groups=#{id}")
+      List.new(Workspace, response)
+    end
+
+    def self.list_custom_field_values(id)
+      response = get("/custom_field_values", subject_type: OBJECT_NAME)
+      List.new(CustomFieldValue, response, filters: { subject_id: id.to_i })
+    end
+
+    def workspaces
+      @workspaces ||= self.class.list_workspaces(id)
+    end
+
+    def custom_field_values
+      @custom_field_values ||= self.class.list_custom_field_values(id)
+    end
+  end
+end

data/lib/mavenlink/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Util
+  def self.results(response)
+    pp response
+    response["results"].map do |result|
+      key = result["key"]
+      id = result["id"]
+      response[key][id]
+    end
+  end
+
+  def self.stringify_keys(hash)
+    new_hash = {}
+    return new_hash unless hash.is_a? Hash
+
+    hash.each do |k, v|
+      new_hash[k.to_s] = v
+    end
+
+    new_hash
+  end
+end

data/mavenlink-ruby.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "lib"))
+
+Gem::Specification.new do |s|
+  s.name        = "mavenlink-ruby"
+  s.version     = "0.0.2"
+  s.date        = "2020-03-15"
+  s.summary     = "Ruby Mavenlink API Wrapper"
+  s.description = "Inspired by Stripe's stripe-ruby"
+  s.authors     = ["Adam Dawkins"]
+  s.email       = "adam@dragondrop.uk"
+  s.homepage    = "https://rubygems.org/gems/mavenlink-ruby"
+  s.license     = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+
+  s.require_paths = ["lib"]
+end

data/spec/.rubocop.yml

@@ -0,0 +1,20 @@
+inherit_from:
+  - ../.rubocop.yml
+
+Layout/LineLength:
+  Max: 100
+
+Metrics/BlockLength:
+  # `context` in specs are blocks and get quite large, so exclude the spec
+  # directory from having to adhere to this rule.
+  Enabled: false
+
+Metrics/ClassLength:
+  # spec classes get quite large, so exclude the spec directory from having
+  # to adhere to this rule.
+  Enabled: false
+
+Style/NumericLiterals:
+  # We have a lot of numeric ids in our specs and it looks weird splitting
+  # them into thousand separators
+  Enabled: false

data/spec/lib/mavenlink/list_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "../../spec_helper"
+
+RSpec.describe Mavenlink::List do
+  let(:response) do
+    {
+      "count" => 3,
+      "results" => [
+        { "key" => "invoices", "id" => "1" },
+        { "key" => "invoices", "id" => "2" },
+        { "key" => "invoices", "id" => "3" },
+      ],
+      "invoices" => {
+        "1" => { "id" => 1 },
+        "2" => { "id" => 2 },
+        "3" => { "id" => 3 },
+      },
+      "meta" => {
+        "count" => 3,
+        "page_count" => 1,
+        "page_number" => 1,
+      },
+    }
+  end
+
+  class MockResource
+    attr_reader :id
+    def initialize(args)
+      @id = args[:id]
+    end
+  end
+
+  it "should provide #count via Enumerable" do
+    list = Mavenlink::List.new(MockResource, response)
+
+    expect(list.count).to eq 3
+  end
+
+  it "should provide #each" do
+    list = Mavenlink::List.new(MockResource, response)
+    expect(list.each.to_a.count).to eq 3
+    expect(list.each.to_a.first).to be_a MockResource
+  end
+
+  describe "filtering" do
+    let(:response) do
+      {
+        "count" => 4,
+        "results" => [
+          { "key" => "things", "id" => "1" },
+          { "key" => "things", "id" => "2" },
+          { "key" => "things", "id" => "3" },
+          { "key" => "things", "id" => "4" },
+        ],
+        "things" => {
+          "1" => { "id" => 1, "subject_id" => "A" },
+          "2" => { "id" => 2, "subject_id" => "A" },
+          "3" => { "id" => 3, "subject_id" => "B" },
+          "4" => { "id" => 4, "subject_id" => "C" },
+        },
+        "meta" => {
+          "count" => 4,
+          "page_count" => 1,
+          "page_number" => 1,
+        },
+      }
+    end
+
+    it "applies a given filter to the results of the list" do
+      list = Mavenlink::List.new(Mavenlink::Thing, response, filters: { "subject_id" => "A" })
+      expect(list.each.to_a.count).to eq 2
+    end
+  end
+
+  describe "#auto_paging_each" do
+    # We do a lot of setup here to mimic three pages worth of results.
+    # A `foo` flag is added to each result to allow us to test filtering
+    let(:initial_response) do
+      {
+        "count" => 5,
+        "results" => [
+          { "key" => "things", "id" => "1" },
+          { "key" => "things", "id" => "2" },
+        ],
+        "things" => {
+          "1" => { "id" => 1, "foo" => true },
+          "2" => { "id" => 2, "foo" => false },
+        },
+        "meta" => {
+          "count" => 5,
+          "page_count" => 3,
+          "page_number" => 1,
+        },
+      }
+    end
+
+    before do
+      stub_request(:get, "#{Mavenlink.api_base}/things")
+        .with(query: { page: 2 })
+        .to_return(
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.generate(
+            count: 5,
+            results: [
+              { key: "things", id: "3" },
+              { key: "things", id: "4" },
+            ],
+            things: {
+              "3": { id: 3, foo: true },
+              "4": { id: 4, foo: false },
+            },
+            meta: {
+              count: 5,
+              page_count: 3,
+              page_number: 2,
+              page_size: 2,
+            }
+          )
+        )
+      stub_request(:get, "#{Mavenlink.api_base}/things")
+        .with(query: { page: 3 })
+        .to_return(
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.generate(
+            count: 5,
+            results: [
+              { key: "things", id: "5" },
+            ],
+            things: {
+              "5": { id: 5, foo: false },
+            },
+            meta: {
+              count: 5,
+              page_count: 3,
+              page_number: 3,
+              page_size: 1,
+            }
+          )
+        )
+    end
+
+    let(:list) { Mavenlink::List.new(Mavenlink::Thing, initial_response) }
+    let(:url) { "#{Mavenlink.api_base}/things" }
+    it "requests all the pages from the API" do
+      list.auto_paging_each(&:id)
+      expect(a_request(:get, url).with(query: { page: 2 })).to have_been_made
+      expect(a_request(:get, url).with(query: { page: 3 })).to have_been_made
+      expect(a_request(:get, url).with(query: { page: 4 })).to_not have_been_made
+    end
+
+    it "returns an Enumerable" do
+      expect(list.auto_paging_each).to be_an Enumerable
+    end
+
+    it "implements #count" do
+      expect(list.auto_paging_each.count).to eq 5
+    end
+
+    it "iterates all the results" do
+      class Foo
+        def self.bar; end
+      end
+      allow(Foo).to receive(:bar)
+      list.auto_paging_each { Foo.bar }
+      expect(Foo).to have_received(:bar).exactly(5).times
+    end
+    describe "filtering" do
+      let(:list) { Mavenlink::List.new(Mavenlink::Thing, initial_response, filters: { foo: true }) }
+      it "passes filters through each page" do
+        expect(list.auto_paging_each.map(&:foo).all?).to eq true
+      end
+    end
+  end
+end
+
+module Mavenlink
+  class Thing < Mavenlink::APIResource
+    OBJECT_NAME = "thing"
+  end
+end