wikirate4ruby 1.0.0

data/lib/wikirate4ruby/entities/metric.rb

@@ -0,0 +1,43 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class Metric < Entities::Card
+      ATTRIBUTES = %i[metric_name metric_designer metric_type question about methodology value_type value_options report_type
+                      research_policy unit range hybrid topics scores formula rubric variables answers bookmarkers datasets
+                      companies calculations answers_url].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(metric)
+        super metric
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not a Metric but a #{@type}" if @type != 'Metric'
+
+        @metric_name = @data['title']
+        @metric_designer = @data['designer']
+        @metric_type = get_content 'metric_type'
+        @question = get_content 'question'
+        @about = get_content 'about'
+        @methodology = get_content 'methodology'
+        @value_options = get_content 'value_options'
+        @value_type = get_content 'value_type'
+        @report_type = get_content 'report_type'
+        @research_policy = get_content 'research_policy'
+        @unit = get_content 'unit'
+        @range = get_content 'range'
+        @hybrid = get_content 'hybrid'
+        @topics = get_content 'topics'
+        @scores = get_content 'scores'
+        @formula = get_content 'formula'
+        @rubric = get_content 'rubric'
+        @variables = get_content 'variables'
+        @answers = get_content 'answers'
+        @bookmarkers = get_content 'bookmarkers'
+        @datasets = get_content 'datasets'
+        @companies = get_content 'companies'
+        @calculations = get_content 'calculations'
+        @answers_url = get_content 'answers_url'
+
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/entities/region.rb

@@ -0,0 +1,20 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class Region < Entities::Card
+      ATTRIBUTES = %i[jurisdiction_code ilo_region country].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(region)
+        super region
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not a Region but a #{@type}" if @type != 'Region'
+
+        @jurisdiction_code = @data["items"][1]["content"]
+        @ilo_region = @data["items"][2]["content"]
+        @country = @data["items"][3]["content"][0]
+
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/entities/relationship_answer.rb

@@ -0,0 +1,23 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class RelationshipAnswer < Entities::Answer
+      ATTRIBUTES = %i[metric_id inverse_metric_id subject_company subject_company_id object_company object_company_id].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(relationship_answer)
+        super relationship_answer
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not an Relationship Answer but a #{@type}" if @type != 'Relationship Answer'
+
+        @metric_id = get_content 'metric_id'
+        @inverse_metric_id = get_content 'inverse_metric_id'
+        @subject_company = get_name 'subject_company'
+        @subject_company_id = get_content 'subject_company_id'
+        @object_company = get_name 'object_company'
+        @object_company_id = get_content 'object_company_id'
+
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/entities/research_group.rb

@@ -0,0 +1,19 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class ResearchGroup < Entities::Card
+      ATTRIBUTES = %i[researchers].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(research_group)
+        super research_group
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not a Research Group but a #{@type}" if @type != 'Research Group'
+
+        @researchers = get_content 'researchers'
+
+      end
+
+    end
+  end
+end

data/lib/wikirate4ruby/entities/source.rb

@@ -0,0 +1,27 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class Source < Entities::Card
+      ATTRIBUTES = %i[title file link description report_type metrics companies
+       answers year].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(source)
+        super source
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not a Source but a #{@type}" if @type != 'Source'
+
+        @title = get_content 'title'
+        @file = get_content 'file'
+        @link = get_content 'link'
+        @description = get_content 'description'
+        @report_type = get_content 'report_type'
+        @metrics = get_content 'metric'
+        @companies = get_content 'company'
+        @answers = get_content 'answer'
+        @year = get_content 'year'
+
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/entities/topic.rb

@@ -0,0 +1,20 @@
+require_relative '../error'
+
+module Wikirate4ruby
+  module Entities
+    class Topic < Entities::Card
+      ATTRIBUTES = %i[bookmarkers metrics datasets].freeze
+      attr_reader(*ATTRIBUTES)
+
+      def initialize(topic)
+        super topic
+        raise parsing_error name = "IncompatibleCardType", message = "The input Card is not a Topic but a #{@type}" if @type != 'Topic'
+
+        @bookmarkers = get_content 'bookmarkers'
+        @metrics = get_content 'metrics'
+        @datasets = get_content 'datasets'
+
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/error.rb

@@ -0,0 +1,98 @@
+module Wikirate4ruby
+  class Error < StandardError
+
+    # @return [Integer]
+    attr_reader :code
+
+    Wikirate4rubyError = Class.new(self)
+
+    # Raised when a Parsing error is occured
+    ParsingError = Class.new(self)
+
+    #Raised when an Incompatible Card Type is given as a type when try to parse an API response
+    IncompatibleCardTypeError = Class.new(ParsingError)
+
+    # Raised when Wikirate returns a 4xx HTTP status code
+    ClientError = Class.new(self)
+
+    # Raised when Wikirate returns the HTTP status code 400
+    BadRequest = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 401
+    Unauthorized = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 403
+    Forbidden = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 413
+    RequestEntityTooLarge = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 404
+    NotFound = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 406
+    NotAcceptable = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 422
+    UnprocessableEntity = Class.new(ClientError)
+
+    # Raised when Wikirate returns the HTTP status code 429
+    TooManyRequests = Class.new(ClientError)
+
+    # Raised when Wikirate returns a 5xx HTTP status code
+    ServerError = Class.new(self)
+
+    # Raised when Wikirate returns the HTTP status code 500
+    InternalServerError = Class.new(ServerError)
+
+    # Raised when Wikirate returns the HTTP status code 502
+    BadGateway = Class.new(ServerError)
+
+    # Raised when Wikirate returns the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+
+    # Raised when Wikirate returns the HTTP status code 504
+    GatewayTimeout = Class.new(ServerError)
+
+    # Raised when an operation subject to timeout takes too long
+    TimeoutError = Class.new(self)
+
+    HTTP_ERRORS = {
+      400 => Wikirate4ruby::Error::BadRequest,
+      401 => Wikirate4ruby::Error::Unauthorized,
+      403 => Wikirate4ruby::Error::Forbidden,
+      404 => Wikirate4ruby::Error::NotFound,
+      406 => Wikirate4ruby::Error::NotAcceptable,
+      413 => Wikirate4ruby::Error::RequestEntityTooLarge,
+      422 => Wikirate4ruby::Error::UnprocessableEntity,
+      429 => Wikirate4ruby::Error::TooManyRequests,
+      500 => Wikirate4ruby::Error::InternalServerError,
+      502 => Wikirate4ruby::Error::BadGateway,
+      503 => Wikirate4ruby::Error::ServiceUnavailable,
+      504 => Wikirate4ruby::Error::GatewayTimeout
+    }.freeze
+
+    PARSING_ERRORS = {
+      'IncompatibleCardType' => Wikirate4ruby::Error::IncompatibleCardTypeError
+    }.freeze
+
+    class << self
+
+      def from_processing_response(error)
+        klass = PARSING_ERRORS[error[:name]] || self
+        message = error[:message]
+        klass.new(message)
+      end
+    end
+
+    # Initializes a new Error object
+    #
+    # @param message [Exception, String]
+    # @param code [Integer]
+    # @return [Wikirate4ruby::Error]
+    def initialize(message = '', code = nil)
+      super(message)
+      @code = code
+    end
+  end
+end

data/lib/wikirate4ruby/request.rb

@@ -0,0 +1,99 @@
+require 'faraday'
+require 'logger'
+require_relative './request_utils'
+
+module Wikirate4ruby
+  module REST
+    class Request
+      include Wikirate4ruby::RequestUtils
+
+      attr :wikirate_api_url, :api_key, :auth, :logger
+
+      def initialize(api_key, wikirate_api_url, auth = {})
+        @wikirate_api_url = wikirate_api_url
+        @api_key = api_key
+        @auth = auth
+        @logger = Logger.new(STDOUT)
+      end
+
+      # @param [String] endpoint
+      # @param [Array] endpoint_params
+      # @param [Array] filters
+      # @param [Hash] params
+      def get(endpoint, endpoint_params = [], filters = [], params = {})
+        data = {}
+        params.each do |key, value|
+          next if value.nil?
+
+          if endpoint_params.include? key
+            data[key] = value.to_s
+          elsif filters.include? key
+            if %w[value_from value_to].include?(key)
+              data["filter[value][#{key.gsub(/.*_/, '')}]"] = value.to_s
+            else
+              data["filter[#{key}]"] = value.to_s
+            end
+          else
+            @logger.warn("Unexpected parameter #{key}")
+          end
+        end
+        request(:get, endpoint, data)
+      end
+
+      def post(endpoint, data = {})
+        request(:post, endpoint, data)
+      end
+
+      private
+
+      # @param [String] method
+      # @param [String] endpoint
+      # @param [Array] data
+      # @param [Hash] _options
+      # @return [Hash]
+      def request(method, endpoint, data = {}, **_options)
+        url = URI.parse("#{@wikirate_api_url}#{endpoint}")
+
+        connection = Faraday.new do |conn|
+          conn.request :authorization, :basic, @auth[:username], @auth[:password] unless auth.nil?
+          conn.request :url_encoded
+          conn.request :json
+          conn.response :json
+        end
+
+        response = case method
+                   when :get
+                     connection.get(url) do |req|
+                       req.params = data
+                       req.headers = headers(@api_key)
+                     end
+                   when :post
+                     connection.post(url) do |req|
+                       req.params = data
+                       req.headers = headers(@api_key)
+                     end
+                   when :put
+                     connection.put(url) do |req|
+                       req.data = data
+                       req.headers = headers(@api_key)
+                     end
+                   when :delete
+                     connection.delete(url) do |req|
+                       req.data = data
+                       req.headers = headers(@api_key)
+                     end
+                   end
+
+        #follow redirect
+        if response.status == 303
+          endpoint = response.headers['location']
+          endpoint[wikirate_api_url] = ''
+          return get(endpoint)
+        end
+
+        return response.body unless response.status != 200
+        raise(error(response.status, response.body))
+      end
+    end
+  end
+end

data/lib/wikirate4ruby/request_utils.rb

@@ -0,0 +1,36 @@
+module Wikirate4ruby
+  module RequestUtils
+
+    private
+
+    def creation_params(entity, optional_params = {}, allowed_params = [])
+      params = {
+        'card[type]' => entity,
+        'format' => 'json',
+        'success[format]' => 'json'
+      }
+
+      optional_params.each do |key, value|
+        next if value.nil?
+
+        if allowed_params.include? key
+          params["card[subcards][+#{key}]"] = (%w[company subject_company object_company].include? key) ? str_identifier(value) : value.to_s
+        else
+          @logger.warn("Unexpected parameter: #{key}")
+        end
+      end
+      params
+    end
+
+    def error(code, body)
+      Wikirate4ruby::Error::HTTP_ERRORS[code].new(JSON.pretty_generate(body))
+    end
+
+    def headers(api_key)
+      {
+        'Content-Type' => 'application/json',
+        'X-API-KEY' => api_key
+      }
+    end
+  end
+end

data/lib/wikirate4ruby/utils.rb

@@ -0,0 +1,16 @@
+module Wikirate4ruby
+  module Utils
+
+    private
+
+    def str_identifier(identifier)
+      (identifier.is_a? String) ? "#{tranform_to_wr_friendly_name(identifier)}" : "~#{identifier}"
+    end
+
+    def tranform_to_wr_friendly_name(name)
+      name = name.gsub(%r{,|\.|/|\(|\)|&|;|@|#|\^|!|=|"|'|%|-}, ' ').squeeze(' ')
+      name.strip!
+      name.gsub(/ /, '_')
+    end
+  end
+end

data/lib/wikirate4ruby/version.rb

@@ -0,0 +1,3 @@
+module Wikirate4ruby
+  VERSION = "1.0.0"
+end

data/lib/wikirate4ruby.rb

@@ -0,0 +1,28 @@
+require_relative "wikirate4ruby/version"
+require_relative "wikirate4ruby/entities/card"
+require_relative "wikirate4ruby/entities/answer"
+require_relative "wikirate4ruby/entities/checked_by"
+require_relative "wikirate4ruby/entities/company_group"
+require_relative "wikirate4ruby/entities/company"
+require_relative "wikirate4ruby/entities/dataset"
+require_relative "wikirate4ruby/entities/metric"
+require_relative "wikirate4ruby/entities/region"
+require_relative "wikirate4ruby/entities/relationship_answer"
+require_relative "wikirate4ruby/entities/source"
+require_relative "wikirate4ruby/entities/topic"
+require_relative "wikirate4ruby/client"
+require_relative "wikirate4ruby/error"
+require_relative "wikirate4ruby/request_utils"
+require_relative "wikirate4ruby/utils"
+require_relative "wikirate4ruby/request"
+
+module Wikirate4ruby
+  module REST
+  end
+  module Entities
+  end
+  module RequestUtils
+  end
+  module StringUtils
+  end
+end

data/sig/wikirate4ruby.rbs

@@ -0,0 +1,4 @@
+module Wikirate4ruby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: wikirate4ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vasiliki Gkatziaki
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.4
+description: 'The Wikirate4ruby is an open-source ruby library for the Wikirate API. '
+email:
+- vasgat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/wikirate4ruby.rb
+- lib/wikirate4ruby/client.rb
+- lib/wikirate4ruby/entities/answer.rb
+- lib/wikirate4ruby/entities/card.rb
+- lib/wikirate4ruby/entities/checked_by.rb
+- lib/wikirate4ruby/entities/company.rb
+- lib/wikirate4ruby/entities/company_group.rb
+- lib/wikirate4ruby/entities/dataset.rb
+- lib/wikirate4ruby/entities/metric.rb
+- lib/wikirate4ruby/entities/region.rb
+- lib/wikirate4ruby/entities/relationship_answer.rb
+- lib/wikirate4ruby/entities/research_group.rb
+- lib/wikirate4ruby/entities/source.rb
+- lib/wikirate4ruby/entities/topic.rb
+- lib/wikirate4ruby/error.rb
+- lib/wikirate4ruby/request.rb
+- lib/wikirate4ruby/request_utils.rb
+- lib/wikirate4ruby/utils.rb
+- lib/wikirate4ruby/version.rb
+- sig/wikirate4ruby.rbs
+homepage: https://github.com/wikirate/wikirate4ruby
+licenses:
+- GPL-3.0-or-later
+metadata:
+  homepage_uri: https://github.com/wikirate/wikirate4ruby
+  source_code_uri: https://github.com/wikirate/wikirate4ruby
+  changelog_uri: https://github.com/wikirate/wikirate4ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A Simple API wrapper for Wikirate's API
+test_files: []