fixably 0.1.0

data/docs/order/note.md

@@ -0,0 +1,34 @@
+# Fixably::Order::Note
+
+## List order notes
+
+```ruby
+Fixably::Order::Note.all(order_id: 1000)
+```
+
+## Get an order note
+
+```ruby
+Fixably::Order::Note.find(1000, order_id: 1000)
+Fixably::Order::Note.first(order_id: 1000)
+Fixably::Order::Note.last(order_id: 1000)
+```
+
+## Create an order note
+
+```ruby
+order = Fixably::Order.find(1_000)
+note = Fixably::Order::Note.new(text: "New note", type: "INTERNAL")
+order.notes << note
+
+note.valid? # => true
+note.persisted? # => true
+```
+
+## Update an order note
+
+The Fixably API does not allow order notes to be updated
+
+## Destroy an order note
+
+The Fixably API does not allow order notes to be destroyed

data/docs/order/task.md

@@ -0,0 +1,27 @@
+# Fixably::Order::Task
+
+## List order tasks
+
+```ruby
+Fixably::Order::Task.all(order_id: 1000)
+```
+
+## Get an order task
+
+```ruby
+Fixably::Order::Task.find(1000, order_id: 1000)
+Fixably::Order::Task.first(order_id: 1000)
+Fixably::Order::Task.last(order_id: 1000)
+```
+
+## Create an order task
+
+The Fixably API does not allow order tasks to be created
+
+## Update an order task
+
+While supported by Fixably, this feature has not yet been implemented
+
+## Destroy an order task
+
+The Fixably API does not allow notes to be destroyed

data/docs/order.md

@@ -0,0 +1,121 @@
+# Fixably::Order
+
+## List orders
+
+```ruby
+Fixably::Order.all
+Fixably::Order.where(is_closed: false)
+Fixably::Order.where(updated_at: "2000-01-01")
+Fixably::Order.where(updated_at: ["2000-01-01",]) # >= 2000-01-01
+Fixably::Order.where(updated_at: [,"2000-01-01"]) # <= 2000-01-01
+Fixably::Order.where(updated_at: ["2000-01-01","2000-02-01"]) # 2000-01-01 <> 2000-02-01
+```
+
+### Include associations in a list
+
+**Contact**
+```ruby
+Fixably::Order.includes(:contact).all
+Fixably::Order.includes(:contact).where(internal_location: "SERVICE")
+```
+
+**Customer**
+```ruby
+Fixably::Order.includes(:customer).all
+Fixably::Order.includes(:customer).where(internal_location: "SERVICE")
+```
+
+**Device**
+```ruby
+Fixably::Order.includes(:device).all
+Fixably::Order.includes(:device).where(internal_location: "SERVICE")
+```
+
+**Handled by**
+```ruby
+Fixably::Order.includes(:handled_by).all
+Fixably::Order.includes(:handled_by).where(internal_location: "SERVICE")
+```
+
+**Ordered by**
+```ruby
+Fixably::Order.includes(:ordered_by).all
+Fixably::Order.includes(:ordered_by).where(internal_location: "SERVICE")
+```
+
+**Queue**
+```ruby
+Fixably::Order.includes(:queue).all
+Fixably::Order.includes(:queue).where(internal_location: "SERVICE")
+```
+
+**Status**
+```ruby
+Fixably::Order.includes(:status).all
+Fixably::Order.includes(:status).where(internal_location: "SERVICE")
+```
+
+**Lines**
+```ruby
+Fixably::Order.includes(:lines).all
+Fixably::Order.includes(:lines).where(internal_location: "SERVICE")
+```
+
+**Notes**
+```ruby
+Fixably::Order.includes(:notes).all
+Fixably::Order.includes(:notes).where(internal_location: "SERVICE")
+```
+
+**Tasks**
+```ruby
+Fixably::Order.includes(:tasks).all
+Fixably::Order.includes(:tasks).where(internal_location: "SERVICE")
+```
+
+## Get a customer
+
+```ruby
+Fixably::Order.find(1_000)
+Fixably::Order.first
+Fixably::Order.last
+```
+
+## Create an order
+
+```ruby
+order = Fixably::Order.create(internal_location: "SERVICE")
+customer.valid? # => true
+customer.persisted? # => true
+
+# Raises an error on failure
+Fixably::Order.create!(internal_location: "SERVICE")
+
+order = Fixably::Order.new(internal_location: "SERVICE")
+order.save
+order.valid? # => true
+order.persisted? # => true
+
+order = Fixably::Order.new(internal_location: "SERVICE")
+# Raises an error on failure
+order.save!
+```
+
+## Update an order
+
+```ruby
+customer = Fixably::Customer.first
+order = Fixably::Order.find(1_000)
+order.internal_location = "SERVICE"
+
+order.save
+order.valid? # => true
+order.persisted? # => true
+
+# Raises an error on failure
+order.save!
+```
+
+## Destroy an order
+
+The Fixably API does not allow orders to be destroyed

data/docs/queue.md

@@ -0,0 +1,36 @@
+# Fixably::Queue
+
+## List queue
+
+```ruby
+Fixably::Queue.all
+Fixably::Queue.where(name: "Mac")
+```
+
+### Include associations in a list
+
+**Statuses**
+```ruby
+Fixably::Queue.includes(:statuses).all
+Fixably::Queue.includes(:statuses).where(name: "Mac")
+```
+
+## Get a queue
+
+```ruby
+Fixably::Queue.find(1_000)
+Fixably::Queue.first
+Fixably::Queue.last
+```
+
+## Create a queue
+
+The Fixably API does not allow queues to be created
+
+## Update a queue
+
+The Fixably API does not allow queues to be updated
+
+## Destroy a queue
+
+The Fixably API does not allow queues to be destroyed

data/docs/status.md

@@ -0,0 +1,42 @@
+# Fixably::Status
+
+## List status
+
+```ruby
+Fixably::Status.all
+Fixably::Status.where(serial_number: "ABCDE123FGHI")
+```
+
+### Include associations in a list
+
+**Custom**
+```ruby
+Fixably::Status.includes(:custom).all
+Fixably::Status.includes(:custom).where(serial_number: "ABCDE123FGHI")
+```
+
+**Queue**
+```ruby
+Fixably::Status.includes(:queue).all
+Fixably::Status.includes(:queue).where(serial_number: "ABCDE123FGHI")
+```
+
+## Get a status
+
+```ruby
+Fixably::Status.find(1_000)
+Fixably::Status.first
+Fixably::Status.last
+```
+
+## Create a status
+
+The Fixably API does not allow statuses to be created
+
+## Update a status
+
+The Fixably API does not allow statuses to be updated
+
+## Destroy a status
+
+The Fixably API does not allow statuses to be destroyed

data/docs/user.md

@@ -0,0 +1,23 @@
+# Fixably::User
+
+## List users
+
+The Fixably API does not allow users to be searched
+
+## Get a user
+
+```ruby
+Fixably::User.find(1_000)
+```
+
+## Create a user
+
+The Fixably API does not allow users to be created
+
+## Update a user
+
+The Fixably API does not allow users to be updated
+
+## Destroy a user
+
+The Fixably API does not allow users to be destroyed

data/fixably.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/fixably/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fixably"
+  spec.version       = Fixably::VERSION
+  spec.authors       = ["Adam Rice"]
+  spec.email         = ["development@hashnotadam.com"]
+
+  spec.summary       = "Ruby client for the Fixably API"
+  spec.homepage      = "https://github.com/HashNotAdam/fixably-ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activeresource", "~> 5"
+
+  spec.add_development_dependency "mutant-rspec", "~> 0.10"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "rubocop", "~> 1"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rake"
+  spec.add_development_dependency "rubocop-rspec"
+end

data/lib/fixably/action_policy.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Fixably
+  class ActionPolicy
+    attr_reader :resource
+
+    def initialize(resource:)
+      @resource = resource.instance_of?(Class) ? resource : resource.class
+      validate_resource!
+    end
+
+    def create?
+      resource.actions.include?(:create)
+    end
+
+    def create!
+      return true if create?
+
+      raise(
+        UnsupportedError,
+        "Fixably does not support creating #{resource_name}"
+      )
+    end
+
+    def delete?
+      resource.actions.include?(:delete)
+    end
+
+    def delete!
+      return true if delete?
+
+      raise(
+        UnsupportedError,
+        "Fixably does not support deleting #{resource_name}"
+      )
+    end
+
+    def list?
+      resource.actions.include?(:list)
+    end
+
+    def list!
+      return true if list?
+
+      raise(
+        UnsupportedError,
+        "Fixably does not support listing #{resource_name}"
+      )
+    end
+
+    def show?
+      resource.actions.include?(:show)
+    end
+
+    def show!
+      return true if show?
+
+      raise(
+        UnsupportedError,
+        "Fixably does not support retrieving #{resource_name}"
+      )
+    end
+
+    def update?
+      resource.actions.include?(:update)
+    end
+
+    def update!
+      return true if update?
+
+      raise(
+        UnsupportedError,
+        "Fixably does not support updating #{resource_name}"
+      )
+    end
+
+    private
+
+    def validate_resource!
+      return if resource.ancestors.include?(ApplicationResource)
+
+      raise(
+        ArgumentError,
+        "The resource should inherit from ApplicationResource"
+      )
+    end
+
+    def resource_name
+      resource.name.split("::").last.underscore.humanize.pluralize.downcase
+    end
+  end
+
+  class UnsupportedError < StandardError; end
+end

data/lib/fixably/actions.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "action_policy"
+require_relative "argument_parameterisation"
+require_relative "resource_lazy_loader"
+
+module Fixably
+  module Actions
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      include ArgumentParameterisation
+
+      def actions(values = nil)
+        if eql?(ApplicationResource)
+          raise "actions can only be called on a sub-class"
+        end
+
+        @actions ||= [].freeze
+        return @actions if values.nil?
+
+        @actions = format_actions(values).freeze
+      end
+
+      def all(*arguments)
+        ActionPolicy.new(resource: self).list!
+        super(*arguments)
+      end
+
+      def create(attributes = {})
+        ActionPolicy.new(resource: self).create!
+        super(attributes)
+      end
+
+      def create!(attributes = {})
+        ActionPolicy.new(resource: self).create!
+        super(attributes)
+      end
+
+      def delete(id, options = {})
+        ActionPolicy.new(resource: self).delete!
+        super(id, options)
+      end
+
+      def exists?(id, options = {})
+        find(id, options)
+        true
+      rescue ::ActiveResource::ResourceNotFound
+        false
+      end
+
+      def find(*arguments)
+        scope = arguments.slice(0)
+
+        ActionPolicy.new(resource: self).show! unless scope.instance_of?(Symbol)
+
+        args = parametize_arguments(scope, arguments.slice(1))
+
+        super(scope, args)
+      end
+
+      def first(*arguments)
+        ActionPolicy.new(resource: self).list!
+
+        args = arguments.first || {}
+        args[:limit] = 1
+        super(args)
+      end
+
+      def includes(association)
+        ResourceLazyLoader.new(model: self).includes(association)
+      end
+
+      def last(*arguments)
+        ActionPolicy.new(resource: self).list!
+
+        args = parametize_arguments(:last, arguments.first)
+        collection = find_every(args)
+        return collection.last unless collection.offset.zero?
+        return collection.last if collection.total_items <= collection.limit
+
+        args = args[:params].merge(limit: 1, offset: collection.total_items - 1)
+        super(args)
+      end
+
+      def where(clauses = {})
+        ActionPolicy.new(resource: self).list!
+
+        arguments = stringify_array_values(clauses)
+        find(:all, arguments)
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def format_actions(values)
+        unless values.respond_to?(:to_sym) || values.respond_to?(:to_a)
+          raise(
+            ArgumentError,
+            "actions should be able to be converted into an Array or a Symbol"
+          )
+        end
+
+        Array.wrap(values).map do
+          action = _1.to_sym
+
+          unless allowed_actions.include?(action)
+            raise ArgumentError, "Unsupported action, #{action}, supplied"
+          end
+
+          action
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def allowed_actions = %i[create delete list show update]
+    end
+
+    def destroy
+      ActionPolicy.new(resource: self).delete!
+      super()
+    end
+
+    def save(validate: true)
+      if validate
+        message = new? ? :create! : :update!
+        ActionPolicy.new(resource: self).public_send(message)
+      end
+
+      super()
+    end
+
+    # rubocop:disable Style/RaiseArgs
+    def save!
+      if new?
+        ActionPolicy.new(resource: self).create!
+      else
+        ActionPolicy.new(resource: self).update!
+      end
+
+      save(validate: false) ||
+        raise(::ActiveResource::ResourceInvalid.new(self))
+    end
+    # rubocop:enable Style/RaiseArgs
+  end
+end