pennylane 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da1842f4d3dee5f1bd7c9bccd793eb1c185cb5fece2178e967da0cbec3b752be
-  data.tar.gz: 1f050f189dae434bdf4febe2c7715858b1f422273a129aa6654677c95ba94921
+  metadata.gz: 1b079bfa7d777a0adb18de2cb8b02c4b5b3f7a20ef14ee3be35ccc56c4fc5714
+  data.tar.gz: 417d611044b5329eb04040ffaab0c1e78e609b6dc5613deeeac35994aab88012
 SHA512:
-  metadata.gz: c245562b9cdcfc4754348d1a43d2029d5b6d025cd61191c0ceeb3e7b814ed81bae299cc7e86b76799a11275fc296a4e5fd8080ab133f262981ccf9091fad665f
-  data.tar.gz: 0404a595eedc597bc04c2dafa9db4796e1ab9d6a12a0bfc9f28132195b50f0ebe8516552c5de04326ed1d79cfef97a2d07de0e7b30ce6fd188abc991e07a221c
+  metadata.gz: 8d1e5ec1c7aacb11921d8d7490c8bfcfd626fb185a74c6199b1ac9b75e4b4cae03dc8f66be2e70effada0cc21a1d563b1aef205beca5d906bc522637d76b429c
+  data.tar.gz: fbec4d19969a69390de3903fcb7a1e9e372fcdc4d6bb9b3f735ac09e3a31b7bbea14963e0e35d0c0815d42140385e168e21f21e764caae06d6fdbea08ebec21c

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.0.0] - 2024-04-29
+
+- Support CustomerInvoice:
+  - `finalize`
+  - `mark_as_paid`
+  - `send_by_email`
+  - `links`
+  - `import`
+- Support per request `api_key` e.g `Pennylane::Customer.retrieve('cus_id', {api_key: 'x0fd....'})`
+- Endpoints returning empty response we are doing +1 GET request at the resource. Not the best solution but at least we are sure we have fresh data.
+- Added resource properties access with `#[]` e.g `cus['name']`
+
+## [0.2.0-alpha] - 2024-04-20
+
+- Support resources 
+  - `CategoryGroup`
+  - `Category` 
+  - `Product`
+- Added missing `#create` to `Supplier`
+- Adding `#update` to `Customer` and `Supplier`
+
+
 ## [0.1.0] - 2024-04-04
 
-- Initial release
+- Initial release

data/Gemfile.lock

@@ -1,15 +1,33 @@
 PATH
   remote: .
   specs:
-    pennylane (0.1.0)
+    pennylane (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.1.3.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
     ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.7)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    drb (2.2.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
     minitest (5.22.3)
+    mutex_m (0.2.0)
     parallel (1.24.0)
     parser (3.3.0.5)
       ast (~> 2.4.1)
@@ -36,6 +54,8 @@ GEM
     ruby-progressbar (1.13.0)
     test-unit (3.6.2)
       power_assert
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.5.0)
     vcr (6.2.0)
 
@@ -43,6 +63,7 @@ PLATFORMS
   arm64-darwin-22
 
 DEPENDENCIES
+  activesupport (~> 7.1)
   minitest (~> 5.22)
   pennylane!
   rake (~> 13.0)

data/README.md

@@ -32,12 +32,177 @@ Pennylane.api_key = 'x0fd....'
 
 # list customers
 Pennylane::Customer.list
+```
+
+### Customers ([API Doc](https://pennylane.readme.io/reference/customers-post-1))
 
+```ruby
 # filter and paginate customers
 Pennylane::Customer.list(filter: [{field: 'name', operator: 'eq', value: 'Apple'}], page: 2)
 
 # Retrieve single customer
 Pennylane::Customer.retrieve('38a1f19a-256d-4692-a8fe-0a16403f59ff')
+
+# Update a customer
+cus = Pennylane::Customer.retrieve('38a1f19a-256d-4692-a8fe-0a16403f59ff')
+cus.update(name: 'Apple Inc')
+
+# Create a customer
+Pennylane::Customer.create customer_type: 'company', name: 'Tesla', address: '4 rue du faubourg', postal_code: '75008', city: 'Paris', country_alpha2: 'FR'
+```
+
+### CustomerInvoices ([API Doc](https://pennylane.readme.io/reference/customer_invoices-import-1))
+
+```ruby
+# Create a customer invoice
+Pennylane::CustomerInvoice.create(
+  create_customer: true,
+  create_products: true,
+  invoice: {
+    date: '2021-01-01',
+    deadline: '2021-01-31',
+    customer: {
+      name: 'Tesla',
+      customer_type: 'company',
+      address: '4 rue du faubourg',
+      postal_code: '75001',
+      city: 'Paris',
+      country_alpha2: 'FR',
+      emails: ['stephane@tesla.com'] },
+    line_items: [
+      {
+        description: 'Consulting',
+        quantity: 1,
+        unit_price: 1000
+      }
+    ]
+  }
+)
+
+# List customer invoices
+Pennylane::CustomerInvoice.list
+
+# Retrieve a customer invoice
+invoice = Pennylane::CustomerInvoice.retrieve('38a1f19a-256d-4692-a8fe-0a16403f59ff')
+
+# Finalize a customer invoice
+invoice.finalize
+
+# Send a customer invoice
+invoice.send_by_email
+
+# Mark a customer invoice as paid
+invoice.mark_as_paid
+
+# Link an invoice and a credit note
+credit_note = Pennylane::CustomerInvoice.retrieve('some-credit-note-id')
+Pennylane::CustomerInvoice.links(invoice.quote_group_uuid, credit_note.quote_group_uuid)
+
+# Import a customer invoice
+Pennylane::CustomerInvoice.import(file: Util.file(File.expand_path('../fixtures/files/invoice.pdf', __FILE__)),
+                                  create_customer: true,
+                                  invoice: { date: Date.today, deadline: Date.today >> 1,
+                                             customer: {
+                                               name: 'Tesla',
+                                               customer_type: 'company',
+                                               address: '4 rue du faubourg',
+                                               postal_code: '75001',
+                                               city: 'Paris',
+                                               country_alpha2: 'FR',
+                                               emails: ['stephane@tesla.com'] },
+                                             line_items: [
+                                               {
+                                                 description: 'Consulting',
+                                                 quantity: 1,
+                                                 unit_price: 1000
+                                               }
+                                             ]
+                                  }
+)
+```
+### Suppliers ([API Doc](https://pennylane.readme.io/reference/suppliers-post))
+
+```ruby
+# Create a supplier
+Pennylane::Supplier.create(name: 'Apple Inc', address: '4 rue du faubourg', postal_code: '75008', city: 'Paris', country_alpha2: 'FR')
+
+# Retrieve a supplier
+Pennylane::Supplier.retrieve('supplier_id')
+
+# List all suppliers
+Pennylane::Supplier.list
+```
+
+### Products ([API Doc](https://pennylane.readme.io/reference/products-post-1))
+
+```ruby
+# Create a product
+Pennylane::Product.create(label: 'Macbook Pro', unit: 'piece', price: 2_999, vat_rate: 'FR_200', currency: 'EUR')
+
+# List all products
+Pennylane::Product.list
+
+# Retrieve a product
+product = Pennylane::Product.retrieve('product_id')
+
+# Update a product
+product.update(label: 'Macbook Pro 2021')
+```
+
+### Categories ([API Doc](https://pennylane.readme.io/reference/tags-get))
+
+```ruby
+# Create a category
+Pennylane::Category.create(name: 'IT')
+
+# Retrieve a category
+Pennylane::Category.retrieve('category_id')
+
+# List all categories
+Pennylane::Category.list
+
+# Update a category
+category = Pennylane::Category.retrieve('category_id')
+category.update(name: 'IT Services')
+```
+### CategoryGroups ([API Doc](https://pennylane.readme.io/reference/tag-groups-get))
+```ruby
+# List all category groups
+Pennylane::CategoryGroup.list
+```
+
+### Per-request api key
+For apps that need to use multiple keys during the lifetime of a process. it's also possible to set a per-request key:
+```ruby
+require "pennylane"
+
+Pennylane::Customer.list(
+  {},
+  {
+    api_key: 'x1fa....'
+  }
+)
+
+Pennylane::Customer.retrieve(
+  '38a1f19a-256d-4692-a8fe-0a16403f59ff',
+  {
+    api_key: 'x1fa....'
+  }
+)
+
+```
+### Accessing resource properties
+
+Both indexer and accessors can be used to retrieve values of resource properties.
+
+```ruby
+customer = Pennylane::Customer.retrieve('customer_id')
+puts customer['name']
+puts customer.name
+
+# NOTE: To do this the gem will try to guess the key of the resource.
+# Otherwise we will have to do Pennylane::Customer.retrieve('customer_id').customer.name
+# We rely on `method_missing` to do Pennylane::Customer.retrieve('customer_id').name
 ```
 
 ## Test mode
@@ -46,9 +211,30 @@ Pennylane provide a [test environment](https://help.pennylane.com/fr/articles/18
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test-unit` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```bash
+bundle install
+bundle exec rake test
+```
+
+Resources implemented so far :
+### CUSTOMER INVOICING
+
+- Customer Invoices ✅
+- Estimates 🚧
+- Billing Subscriptions 🚧
+
+### REFERENTIALS
+
+- Customers ✅
+- Suppliers ✅
+- Categories ✅
+- CategoryGroups ✅
+- Products ✅
+- Plan Items 🚧
+- Enums 🚧
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### SUPPLIER INVOICING
+- Supplier Invoices 🚧
 
 ## Contributing
 

data/lib/pennylane/client.rb

@@ -3,7 +3,7 @@ module Pennylane
     BASE_URI = 'app.pennylane.com/api/external'.freeze
     VERSION = 'v1'.freeze
 
-    attr_accessor :key, :version
+    attr_accessor :version
 
     def initialize(key, version: 'v1')
       @key = key
@@ -21,7 +21,7 @@ module Pennylane
     end
 
 
-    def authorization
+    def authorization(key)
       "Bearer #{key}"
     end
     def http
@@ -34,10 +34,9 @@ module Pennylane
       Net::HTTP.const_get(method.to_s.capitalize)
     end
 
-    def request method, path, params:, opts: {}
-      req = initialize_request(method, path, params[:query]).tap do |req|
-        req.body = params[:body].to_json if params[:body] && method != :get
-        # req.query = params if !params.empty? && method == :get
+    def request method, path, params: {}, opts: {}
+      req = initialize_request(method, path, params[:query], opts).tap do |req|
+        req.body = params[:body].to_json if params[:body]
       end
 
       http.request(req).tap do |resp|
@@ -62,10 +61,11 @@ module Pennylane
     def should_handle_as_error?(code)
       code.to_i >= 400
     end
-    def initialize_request method=nil, path=nil, params={}
+
+    def initialize_request method=nil, path=nil, params={}, opts={}
       klass(method).new(url(path, params)).tap do |request|
         request["content-type"] = 'application/json'
-        request["authorization"] = authorization
+        request["authorization"] = authorization(opts.fetch(:api_key, @key))
       end
     end
 

data/lib/pennylane/object.rb

@@ -1,10 +1,7 @@
 module Pennylane
   class Object
     include Enumerable
-
-    def initialize(id = nil)
-      @id = id
-    end
+    attr_reader :id
 
     def initialize_from_response(response, params = {}, opts = {})
       values = Util.symbolize_names(response)
@@ -19,7 +16,7 @@ module Pennylane
     end
 
     def self.build_from(response, params = {}, opts = {})
-      new(response['id']).initialize_from_response(response, params, opts)
+      new.initialize_from_response(response, params, opts)
     end
 
     def self.objects
@@ -89,9 +86,7 @@ module Pennylane
       when Pennylane::Object
         obj.class.build_from(
           deep_copy(obj.instance_variable_get(:@values)),
-          obj.instance_variable_get(:@opts).select do |k, _v|
-            Util::OPTS_COPYABLE.include?(k)
-          end
+          obj.instance_variable_get(:@opts)
         )
       else
         obj

data/lib/pennylane/resources/base.rb

@@ -1,6 +1,7 @@
 module Pennylane
   module Resources
     class Base < Pennylane::Object
+
       class << self
 
         def object_name
@@ -11,40 +12,74 @@ module Pennylane
           "#{object_name}s"
         end
 
-        def request_pennylane_object(method:, path:, params: {}, opts: {}, usage: [])
+        def request_pennylane_object(method:, path:, params: {}, opts: {}, usage: [], with: {})
           resp, opts = execute_resource_request(method, path, params, opts, usage)
-          Util.convert_to_pennylane_object(Util.normalize_response(resp), params, opts)
+          if resp.empty?
+            {}
+          else
+            Util.convert_to_pennylane_object(Util.normalize_response(resp, with), params, opts)
+          end
         end
 
         def execute_resource_request(method, path, params = {}, opts = {}, usage = [])
-          api_key = opts.delete(:api_key) || Pennylane.api_key
-
-
           resp = client.request(
             method,
             path,
             params: params,
             opts: opts
           )
-
-          [JSON.parse(resp.read_body), opts]
+          [JSON.parse(resp.read_body || "{}"), opts] # in case body is nil ew return an empty hash
         end
 
         def client
-          @client ||= Pennylane::Client.new(Pennylane.api_key)
+          @client ||= {}
+          @client[Pennylane.api_key] ||= Pennylane::Client.new(Pennylane.api_key)
         end
+
+        def normalize_filters(filters)
+          filters[:filter] = filters[:filter].to_json if filters[:filter]
+          filters
+        end
+      end
+
+      # object happens to be nil when the object is in a list
+      def id
+        object.source_id
+      rescue
+        super
+      end
+
+      # object happens to be nil when the object is the nested object
+      def [](k)
+        (object && object[k.to_sym]) || @values[k.to_sym]
+      end
+
+      #
+      def object
+        @values[self.class.object_name.to_sym]
+      end
+
+      # def inspect
+      #   id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ""
+      #   "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " +
+      #     JSON.pretty_generate(object.instance_variable_get(:@values) || @values)
+      # end
+
+      def update(attributes)
+        resp, opts = self.class.request_pennylane_object(method: :put, path: "/#{self.class.object_name_plural}/#{id}", params: { body: { self.class.object_name => attributes } })
+        @values = resp.instance_variable_get :@values
+        self
       end
 
       # So we can call directly method on the object rather than going through his key
       # Pennylane::Customer.retrieve('any-id').name == Pennylane::Customer.retrieve('any-id').customer.name
       def method_missing(method_name, *args, &block)
-        obj = @values[self.class.object_name.to_sym]
-        raise NoMethodError, "undefined method `#{method_name}` for #{self.class}" unless obj
-        obj.send(method_name, *args, &block)
+        raise NoMethodError, "undefined method `#{method_name}` for #{self.class}" unless object
+        object.send(method_name, *args, &block)
       end
 
       def respond_to_missing?(method_name, include_private = false)
-        @values[self.class.object_name.to_sym].respond_to?(method_name) || super
+        object.respond_to?(method_name) || super
       end
 
     end

data/lib/pennylane/resources/category.rb

@@ -0,0 +1,27 @@
+module Pennylane
+  class Category < Resources::Base
+
+    class << self
+
+      # override the object_name_plural method otherwise it will return 'categorys'
+      def object_name_plural
+        'categories'
+      end
+
+      def list filters = {}, opts = {}
+        normalize_filters(filters)
+        request_pennylane_object(method: :get, path: "/categories", params: { query: filters }, opts: opts)
+      end
+
+      def retrieve id, opts = {}
+        request_pennylane_object(method: :get, path: "/categories/#{id}", params: {}, opts: opts)
+      end
+
+      def create params, opts = {}
+        request_pennylane_object(method: :post, path: "/categories", params: { body: { object_name => params } }, opts: opts)
+      end
+
+    end
+
+  end
+end

data/lib/pennylane/resources/category_group.rb

@@ -0,0 +1,16 @@
+module Pennylane
+  class CategoryGroup < Resources::Base
+
+    class << self
+
+      def object_name
+        'category_group'
+      end
+
+      def list filters = {}, opts = {}
+        request_pennylane_object(method: :get, path: "/category_groups", params: { query: filters }, opts: opts)
+      end
+    end
+
+  end
+end

data/lib/pennylane/resources/customer.rb

@@ -4,11 +4,12 @@ module Pennylane
     class << self
 
       def list filters = {}, opts = {}
+        normalize_filters(filters)
         request_pennylane_object(method: :get, path: "/customers", params: { query: filters }, opts: opts)
       end
 
-      def retrieve customer_id, opts = {}
-        request_pennylane_object(method: :get, path: "/customers/#{customer_id}", params: {}, opts: opts)
+      def retrieve id, opts = {}
+        request_pennylane_object(method: :get, path: "/customers/#{id}", params: {}, opts: opts)
       end
 
       def create params, opts = {}

data/lib/pennylane/resources/customer_invoice.rb

@@ -0,0 +1,90 @@
+module Pennylane
+  class CustomerInvoice < Resources::Base
+
+    class << self
+
+      def object_name
+        'customer_invoice'
+      end
+
+      def list filters = {}, opts = {}
+        normalize_filters(filters)
+        request_pennylane_object(method: :get, path: "/customer_invoices", params: { query: filters }, opts: opts, with: { invoice: 'customer_invoice' })
+      end
+
+      def retrieve id, opts = {}
+        request_pennylane_object(method: :get, path: "/customer_invoices/#{id}", params: {}, opts: opts, with: { invoice: 'customer_invoice' })
+      end
+
+      def create params, opts = {}
+        request_pennylane_object(method: :post, path: "/customer_invoices", params: { body: params }, opts: opts, with: { invoice: 'customer_invoice' })
+      end
+
+      def import params, opts={}
+        request_pennylane_object(method: :post, path: "/customer_invoices/import", params: { body: params }, opts: opts, with: { invoice: 'customer_invoice' })
+      end
+
+      def links(*quote_group_uuids, opts: {})
+        request_pennylane_object(method: :post, path: "/customer_invoices/links", params: { body: { quote_group_uuids: quote_group_uuids } },
+                                                                                opts: {})
+      end
+    end
+
+    # since object name is different from the class name, we need to override the object_name method
+    def object
+      @values[:invoice]
+    end
+
+    # doesnt have a `source_id` so we override it
+    def id
+      object.id
+    end
+
+    # API CALLS
+
+    # since object name is different from the class name, we need to override the method
+    def update(attributes)
+      resp, opts = self.class.request_pennylane_object(method: :put,
+                                                       path: "/customer_invoices/#{id}",
+                                                       params: { body: { 'invoice' => attributes } },
+                                                       opts: {}, with: { invoice: 'customer_invoice' })
+      @values = resp.instance_variable_get :@values
+      self
+    end
+
+    def finalize
+      request_and_retrieve(method: :put, path: "/customer_invoices/#{id}", action: 'finalize')
+    end
+
+    def mark_as_paid
+      resp, opts = self.class.request_pennylane_object(method: :put,
+                                          path: "/customer_invoices/#{id}/mark_as_paid",
+                                          params: {},
+                                          opts: {}, with: { invoice: 'customer_invoice' })
+      @values = resp.instance_variable_get :@values
+      self
+    end
+
+    def send_by_email
+      request_and_retrieve(method: :post, path: "/customer_invoices/#{id}", action: 'send_by_email')
+    end
+
+    private
+
+    # When API returns an empty body
+    # so we need to skip values assignment from the response
+    # GET /customer_invoices/:id again to get the updated values
+    def request_and_retrieve(method:, path:, action:)
+      self.class.request_pennylane_object(method: method,
+                                          path: "#{path}/#{action}",
+                                          params: {},
+                                          opts: {}, with: { invoice: 'customer_invoice' })
+      resp, opts = self.class.request_pennylane_object(method: :get,
+                                                       path: path,
+                                                       params: {},
+                                                       opts: {}, with: { invoice: 'customer_invoice' })
+      @values = resp.instance_variable_get :@values
+      self
+    end
+  end
+end

data/lib/pennylane/resources/product.rb

@@ -0,0 +1,22 @@
+module Pennylane
+  class Product < Resources::Base
+
+    class << self
+
+      def list filters = {}, opts = {}
+        normalize_filters(filters)
+        request_pennylane_object(method: :get, path: "/products", params: { query: filters }, opts: opts)
+      end
+
+      def retrieve id, opts = {}
+        request_pennylane_object(method: :get, path: "/products/#{id}", params: {}, opts: opts)
+      end
+
+      def create params, opts = {}
+        request_pennylane_object(method: :post, path: "/products", params: { body: { product: params } }, opts: opts)
+      end
+
+    end
+
+  end
+end

data/lib/pennylane/resources/supplier.rb

@@ -0,0 +1,20 @@
+module Pennylane
+  class Supplier < Resources::Base
+    class << self
+
+      def list filters = {}, opts = {}
+        normalize_filters(filters)
+        request_pennylane_object(method: :get, path: "/suppliers", params: { query: filters }, opts: opts)
+      end
+
+      def retrieve supplier_id, opts = {}
+        request_pennylane_object(method: :get, path: "/suppliers/#{supplier_id}", params: {}, opts: opts)
+      end
+
+      def create params, opts = {}
+        request_pennylane_object(method: :post, path: "/suppliers", params: { body: { object_name => params } }, opts: opts)
+      end
+
+    end
+  end
+end

data/lib/pennylane/util.rb

@@ -20,34 +20,49 @@ module Pennylane
       # It will add an _object key to each hash in the response
       # This key will contain the name of the object
       # It will also add an _object key to the root of the response
-      def normalize_response(object)
+      # with: is used to map the object name to a different class
+      # Example : GET /customer_invoices will return a list of invoices
+      #  {
+      #   "total_pages": 5,
+      #   "current_page": 1,
+      #   "total_invoices": 12,
+      #   "invoices": []
+      # }
+      # `invoices` should be `customer_invoice` so we can cast it to the right class CustomerInvoice
+      # Since we don't have the ability to change the API response.
+      # We can achieve this by calling normalize_response(response, with: {invoice: 'customer_invoice'})
+      def normalize_response(object, with={})
         # puts object.inspect
         case object
         when Hash
           new_hash = {}
-          new_hash['_object'] = object.has_key?('total_pages') ? 'list' : singularize(object.keys.first)
-
+          new_hash['_object'] = object.has_key?('total_pages') ? 'list' : (with[singularize(object.keys.first).to_sym] || singularize(object.keys.first))
           object.each do |key, value|
             if value.is_a? Array
               new_hash[key] = value.map do |h|
-                h['_object'] = singularize(key) if h.is_a? Hash
-                normalize_response(h)
+                h['_object'] = with[singularize(key).to_sym] || singularize(key) if h.is_a? Hash
+                normalize_response(h, with)
               end
             elsif value.is_a? Hash
-              value['_object'] = singularize(key)
+              value['_object'] = with[singularize(key).to_sym] || singularize(key)
             end
-            new_hash[key] = normalize_response(value)
+            new_hash[key] = normalize_response(value, with)
           end
           new_hash
         when Array
           object.map do |value|
-            normalize_response(value)
+            normalize_response(value, with)
           end
         else
           object
         end
       end
 
+      def file(file_path)
+        file_data = File.open(file_path).read
+        Base64.strict_encode64(file_data)
+      end
+
       # This method is used to convert the keys of a hash from strings to symbols
       def symbolize_names(object)
         case object

data/lib/pennylane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pennylane
-  VERSION = "0.1.0"
-end
+  VERSION = "1.0.0"
+end

data/lib/pennylane.rb

@@ -22,7 +22,12 @@ module Pennylane
 
   API_RESOURCES = {
     ListObject.object_name => ListObject,
-    Customer.object_name => Customer
+    Category.object_name => Category,
+    CategoryGroup.object_name => CategoryGroup,
+    Customer.object_name => Customer,
+    CustomerInvoice.object_name => CustomerInvoice,
+    Product.object_name => Product,
+    Supplier.object_name => Supplier
   }.freeze
 
   @config = Pennylane::Configuration.new

data/pennylane.gemspec

@@ -34,5 +34,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "vcr", "~> 6.2"
   spec.add_development_dependency "test-unit", "~> 3.6"
   spec.add_development_dependency "minitest", "~> 5.22"
+  spec.add_development_dependency "activesupport", "~> 7.1"
   # guide at: https://bundler.io/guides/creating_gem.html
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pennylane
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Stephane Bounmy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vcr
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.22'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
 description: Pennylane offers integrated financial management and accounting tools
   for businesses. See https://pennylane.com for details.
 email:
@@ -74,7 +88,12 @@ files:
 - lib/pennylane/list_object.rb
 - lib/pennylane/object.rb
 - lib/pennylane/resources/base.rb
+- lib/pennylane/resources/category.rb
+- lib/pennylane/resources/category_group.rb
 - lib/pennylane/resources/customer.rb
+- lib/pennylane/resources/customer_invoice.rb
+- lib/pennylane/resources/product.rb
+- lib/pennylane/resources/supplier.rb
 - lib/pennylane/util.rb
 - lib/pennylane/version.rb
 - pennylane.gemspec