ecoportal-api-oozes 0.5.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f6ecefc83d30f273a4ededb781765cde494d5e6e0facad8a501fc6ef023e73ee
+  data.tar.gz: b1e0b4dab879d237580bb4d599ea500fe7a5154f6f7f874e418360bfefc9700d
+SHA512:
+  metadata.gz: 98694b883b97f35fc71c0633717d92ec9da2704bd6d63c824a38c43eca512645ab6f3ecd77924d41ae527d112ffc36fcc4190f82e06b4b6453d21ccca44de22d
+  data.tar.gz: 9ef14de17795590c48d3b3cb0a6e2ba96be3b1d1ff76cee959a1860cbf1689d17b0551842352b7326094d1c8071a8569cf58c6b8feb5dd8933da8cd6a69521fc

data/.gitignore

@@ -0,0 +1,20 @@
+# it's a gem, ignore the lockfile
+Gemfile.lock
+
+# build artifacts
+*.gem
+/.bundle/
+/vendor/bundle
+/spec/reports/
+/tmp/
+/pkg/
+
+# docs
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+
+# rspec failure tracking
+.rspec_status
+scratch.rb

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,55 @@
+AllCops:
+  TargetRubyVersion: 2.5.1
+  Exclude:
+    - 'config/routes.rb'
+
+Metrics/LineLength:
+  Enabled: false
+Metrics/BlockLength:
+  ExcludedMethods: [context, describe]
+  Max: 50
+Metrics/MethodLength:
+  Max: 50
+Metrics/ClassLength:
+  Max: 200
+Metrics/AbcSize:
+  Max: 30
+
+ParameterLists:
+  Max: 5
+  CountKeywordArgs: false
+
+Style/StringLiterals:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/CommentedKeyword:
+  Enabled: false
+Style/MultilineBlockChain:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+Style/AndOr:
+  Enabled: false
+
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: false
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+Layout/SpaceAroundOperators:
+  Enabled: false
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+Layout/AccessModifierIndentation:
+  EnforcedStyle: indent
+Layout/DotPosition:
+  EnforcedStyle: trailing
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+Layout/IndentHash:
+  Enabled: false
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.1

data/.yardopts

@@ -0,0 +1,10 @@
+--readme README.md
+--charset utf-8
+--markup-provider=redcarpet
+--markup=markdown
+--no-private
+--output-dir ./doc
+'lib/**/*.rb'
+-
+CHANGELOG.md
+LICENSE

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ecoportal-api.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 ecoPortal
+
+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.md

@@ -0,0 +1,20 @@
+# Ecoportal::API::V2
+
+This is a basic collection of helpers that can be used to interact with the
+[ecoPortal](https://www.ecoportal.com) `APIv2`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ecoportal-api-oozes', require: %w[ecoportal/api-oozes]
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ecoportal-api-oozes

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "yard"
+require "redcarpet"
+
+desc "run the specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "run rspec showing backtrace"
+RSpec::Core::RakeTask.new(:spec_trace) do |task|
+  task.rspec_opts = ['--backtrace']
+end
+
+desc "run rspec stopping on first fail, and show backtrace"
+RSpec::Core::RakeTask.new(:spec_fast) do |task|
+  task.rspec_opts = ['--fail-fast', '--backtrace']
+end
+
+# default task name is yard
+desc "Yard: generate all the documentation"
+YARD::Rake::YardocTask.new(:doc) do |t|
+  #t.files = ['lib/**/*.rb']
+end
+
+task :default     => [:spec]
+task :rspec_trace => :spec_trace
+task :rspec_fast  => :spec_fast

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ecoportal/api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "pry"
+Pry.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ecoportal-api-oozes.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ecoportal/api/v2/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ecoportal-api-oozes"
+  spec.version       = Ecoportal::API::V2::VERSION
+  spec.authors       = ["Oscar Segura"]
+  spec.email         = ["rien@ecoportal.co.nz", "oscar@ecoportal.co.nz", "bozydar@ecoportal.co.nz"]
+
+  spec.summary       = %q{A collection of helpers for interacting with the ecoPortal MS's V2 API}
+  spec.homepage      = "https://www.ecoportal.com"
+  spec.licenses      = %w[MIT]
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler",   "~> 2.1"
+  spec.add_development_dependency "rake",      "~> 12.0"
+  spec.add_development_dependency "rspec",     "~> 3.0"
+  spec.add_development_dependency "yard",      "~> 0.9", ">= 0.9.18"
+  spec.add_development_dependency "redcarpet", "~> 3.5", ">= 3.5.0"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency 'ecoportal-api',  '~> 0.5', '>= 0.5.5'
+end

data/lib/ecoportal/api-oozes.rb

@@ -0,0 +1,10 @@
+require "ecoportal/api"
+require "ecoportal/api/v2/version"
+
+module Ecoportal
+  module API
+  end
+end
+
+require "ecoportal/api/common"
+require "ecoportal/api/v2"

data/lib/ecoportal/api/common.rb

@@ -0,0 +1,18 @@
+module Ecoportal
+  module API
+    module Common
+    end
+  end
+end
+
+require 'ecoportal/api/common/base_class'
+require 'ecoportal/api/common/hash_diff'
+require 'ecoportal/api/common/base_model'
+require 'ecoportal/api/common/doc_helpers'
+require 'ecoportal/api/common/logging'
+require 'ecoportal/api/common/client'
+require 'ecoportal/api/common/response'
+require 'ecoportal/api/common/wrapped_response'
+require 'ecoportal/api/common/batch_response'
+require 'ecoportal/api/common/batch_operation'
+require 'ecoportal/api/common/content'

data/lib/ecoportal/api/common/content.rb

@@ -0,0 +1,18 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+      end
+    end
+  end
+end
+
+require 'ecoportal/api/common/content/class_helpers'
+require 'ecoportal/api/common/content/string_digest'
+require 'ecoportal/api/common/content/double_model'
+require 'ecoportal/api/common/content/array_model'
+require 'ecoportal/api/common/content/collection_model'
+require 'ecoportal/api/common/content/doc_helpers'
+require 'ecoportal/api/common/content/hash_diff_patch'
+require 'ecoportal/api/common/content/client'
+require 'ecoportal/api/common/content/wrapped_response'

data/lib/ecoportal/api/common/content/array_model.rb

@@ -0,0 +1,287 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        # Class to handle a plain Array embedded in a Hashed model.
+        # @note its purpose is to handle an Array of basic objects (i.e. `Date`, `String`, `Number`)
+        class ArrayModel < Content::DoubleModel
+          class TypeMismatchedComparison < Exception
+            def initialize (this: nil, that: msg = "Trying to compare objects with different behavior.")
+              if this
+                msg += " From object with 'order_matters: #{this.order_matters?}' and 'uniq: #{this.uniq?}'."
+              end
+              if that
+                msg += " To object where 'order_matters: #{that.order_matters?}' and 'uniq: #{that.uniq?}'."
+              end
+              super(msg)
+            end
+          end
+
+          include Enumerable
+
+          class << self
+            attr_accessor :order_matters, :uniq
+
+            # @param a [ArrayModel]
+            # @param b [ArrayModel]
+            # @return [Boolean] `true` if both elements have same behaviour
+            def same_type?(a, b)
+              raise "To use this comparison both objects should be `ArrayModel`" unless a.is_a?(ArrayModel) && b.is_a?(ArrayModel)
+              (a.order_matters? == b.order_matters?) && (a.uniq? == b.uniq?)
+            end
+
+          end
+
+          def initialize(doc = {}, parent: self, key: nil)
+            super(doc, parent: parent, key: key)
+          end
+
+          def order_matters?; self.class.order_matters; end
+          def uniq?;          self.class.uniq;          end
+
+          def length;   count;      end
+          def empty?;   count == 0; end
+          def present?; count > 0;  end
+
+          def each(&block)
+            return to_enum(:each) unless block
+            _items.each(&block)
+          end
+
+          # @return [Array] the array element represented by this object
+          def _items
+            replace_doc([]) unless doc.is_a?(Array)
+            doc.tap {|d| d.uniq! if uniq?}
+          end
+
+          # @see #_items
+          # @return [Array] a **copy** of the `Array` elements
+          def to_a
+            _items.slice(0..-1)
+          end
+
+          # @param value [Object, Array<Object>, ArrayModel] the value(s) of the new object
+          # @return [ArrayModel] a new object with the current class
+          def new_from(value)
+            self.class.new(into_a(value))
+          end
+
+          # @return [ArrayModel] a copy of the current object
+          def dup
+            new_from(to_a)
+          end
+
+          # @return [Integer] the position of the element in the `Array`
+          def index(value)
+            _items.index(value)
+          end
+
+          # Retrieves the element of a certain position
+          # @param pos [Integer] the position of the element
+          # @return [Date, String, Number]
+          def [](pos)
+            _items[pos]
+          end
+
+          # Sets the element of a certain position
+          # @param pos [Integer] the position of the element
+          # @param value [String, Date, Number] the element
+          # @return [Date, String, Number]
+          def []=(post, value)
+            _items[pos] = value
+            on_change
+            self[pos]
+          end
+
+          # Compares with an `Array` or another `ArrayModel`
+          # @param a [ArrayModel, Array]
+          def ==(a)
+            return true if self.equal?(a)
+            return false unless (a.class == self.class) || a.is_a?(Array)
+            case a
+            when Array
+              self == new_from(a)
+            when ArrayModel
+              return true if
+              raise TypeMismatchedComparison.new(this: self, that: a) unless self.class.same_type?(self, a)
+
+              if self.order_matters?
+                _items == a.to_a
+              else
+                (_items - a.to_a).empty? && (a.to_a - _items).empty?
+              end
+            end
+          end
+
+          # @return [Boolean] `true` if `value` is present, `false` otherwise
+          def include?(value)
+            _items.include?(value)
+          end
+
+          def include_any?(*value)
+            value.any? {|v| _items.include?(v)}
+          end
+
+          def include_all?(*value)
+            value.all? {|v| _items.include?(v)}
+          end
+
+          # Adds an element to the subjacent `Array`
+          # @note if the class variable `uniq` is `true`, it skips duplicates
+          def <<(value)
+            _items.concat(into_a(value)).tap do |doc|
+              doc.uniq! if uniq?
+            end
+            on_change
+            self
+          end
+
+          # @see #<<
+          def push!(value)
+            self << value
+          end
+
+          # @see #<<
+          # @note same as #push! but for multiple elements
+          def concat!(values)
+            self << values
+          end
+
+          # Resets the `Array` by keeping its reference and adds the value(s)
+          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be added
+          # @param values [Array]
+          def <(values)
+            _items.clear
+            self << values
+          end
+
+          # Clears the `Array` keeping its reference
+          def clear!
+            _items.clear
+            on_change
+            self
+          end
+
+          # Concat to new
+          def +(value)
+            new_from(self.to_a + into_a(value))
+          end
+
+          # Join
+          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be joined
+          # @return [ArrayModel] a new object instance with the intersection done
+          def |(value)
+            new = new_from(value) - self
+            new_from(to_a + new.to_a)
+          end
+
+          # Intersect
+          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be deleted
+          # @return [ArrayModel] a new object instance with the intersection done
+          def &(value)
+            self.dup.tap do |out|
+              self.dup.tap do |delta|
+                delta.delete!(*into_a(value))
+                out.delete!(*into_a(delta))
+              end
+            end
+          end
+
+          # Subtract
+          # @param value [Object, Array<Object>, ArrayModel] the value(s) to be deleted
+          # @return [ArrayModel] a **copy** of the object with the elements subtracted
+          def -(value)
+            self.dup.tap do |copy|
+              copy.delete!(*into_a(value))
+            end
+          end
+
+          # Deletes `values` from the `Array`
+          def delete!(*values)
+            values.map do |v|
+              deletion!(v)
+            end.tap do |r|
+              on_change
+            end
+          end
+
+          # Swaps two values' positions
+          # @note this will work with first instances when **not** `uniq?`
+          # @param val1 [Object] the first value to swap
+          # @param val2 [Object] the second value to swap
+          # @return [Integer] the new of `value1`, `nil` if it wasn't moved
+          def swap(value1, value2)
+            index(value2).tap do |dest|
+              if dest && pos = index(value1)
+                _items[dest] = value1
+                _items[pos]  = value2
+              end
+            end
+          end
+
+          # TODO
+          def insert_one(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
+            i = index(value)
+            return i if (i && uniq?)
+
+            pos = case
+                  when used_param?(pos)
+                    pos
+                  when used_param?(before)
+                    index(before)
+                  when used_param?(after)
+                    if i = index(after)
+                      i + 1
+                    end
+                  else
+                    length
+                  end
+
+            pos.tap do |i|
+              unless !i
+                _items.insert(pos, value)
+                on_change
+              end
+            end
+          end
+
+          # TODO
+          def move(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
+            if i = index(value)
+              unless i == pos
+
+                on_change
+              end
+              pos
+            end
+          end
+
+          protected
+
+          def on_change
+            # to be overriden by child classes
+          end
+
+          private
+
+          def into_a(value)
+            raise "Can't convert to 'Array' a 'Hash', as is a key_value pair Enumerable" if value.is_a?(Hash)
+            return value.to_a.slice(0..-1) if value.is_a?(Enumerable)
+            [].push(value).compact
+          end
+
+          def deletion!(value)
+            if !uniq?
+              if i = _items.index(value)
+                _items.slice!(i)
+              end
+            else
+              _items.delete(value)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end