blockfrost-ruby 0.1.0

data/lib/blockfrostruby/validator.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+
+# rubocop:disable Style/GuardClause
+module Validator
+  class << self
+    # rubocop:disable Metrics/AbcSize
+
+    # Validates params, which is passed to instanse of Net subclass object.
+    # Callings from Params module.
+    # If params don't meet specific conditions, it raise an ArgumentError.
+    #
+    # @param params [Hash] includes passed params.
+    # @return [ArgumentError | nil] if there is no valid params
+    def validate_params(params)
+      validate_count(params[:count])
+      validate_page(params[:page])
+      validate_order(params[:order])
+      validate_both_from_and_to(params[:from], params[:to])
+      validate_both_from_page_and_to_page(params[:from_page], params[:to_page])
+      validate_parallel_requests(params[:parallel_requests])
+      validate_sleep_between_retries(params[:sleep_between_retries_ms])
+
+      if (params[:from_page] || params[:to_page]) && params[:page]
+        raise ArgumentError,
+              'Do not specify "page" with "to_page" or "from_page"'
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Validates config, which is passed to constructor of instanse of Net subclass object.
+    # If params don't meet specific conditions, it raise an ArgumentError.
+    #
+    # @param config [Hash] includes passed params.
+    # @return [ArgumentError | nil] if there is no valid params
+    def validate_init_params(config)
+      validate_count(config[:default_count_per_page])
+      validate_use_order(config[:use_asc_order_as_default])
+      validate_parallel_requests(config[:parallel_requests])
+      validate_sleep_between_retries(config[:sleep_between_retries_ms])
+    end
+
+    private
+
+    def validate_use_order(param)
+      param_name = 'use_asc_order_as_default'
+      validate_is_boolean(param, param_name) if param
+    end
+
+    def validate_parallel_requests(param)
+      param_name = 'parallel_requests'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+        validate_lower_or_equal_than(param, param_name, MAX_NUMBER_OF_PARALLEL_REQUESTS)
+      end
+    end
+
+    def validate_sleep_between_retries(param)
+      param_name = 'sleep_between_retries_ms'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+      end
+    end
+
+    def validate_count(param)
+      param_name = 'count'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+        validate_lower_or_equal_than(param, param_name, MAX_COUNT_PER_PAGE)
+      end
+    end
+
+    def validate_page(param)
+      param_name = 'page'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+        validate_lower_or_equal_than(param, param_name, MAX_COUNT_PER_PAGE)
+      end
+    end
+
+    def validate_order(param)
+      param_name = 'order'
+      valid_values = %w[asc desc]
+      if param
+        validate_is_string(param, param_name)
+        validate_string_is_in_array(param, param_name, valid_values)
+      end
+    end
+
+    def validate_from(param)
+      param_name = 'from'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+      end
+    end
+
+    def validate_to(param)
+      param_name = 'to'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+      end
+    end
+
+    def validate_from_page(param)
+      param_name = 'from_page'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+      end
+    end
+
+    def validate_to_page(param)
+      param_name = 'to_page'
+      if param
+        validate_is_numeric(param, param_name)
+        validate_is_integer(param, param_name)
+        validate_is_positive(param, param_name)
+      end
+    end
+
+    def validate_both_from_page_and_to_page(from_page, to_page)
+      if to_page && from_page.nil?
+        raise ArgumentError,
+              '"to_page" argument should be specified with "from_page"'
+      end
+
+      validate_from_page(from_page) if from_page
+
+      if from_page && to_page
+        validate_to_page(to_page)
+
+        unless from_page <= to_page
+          raise ArgumentError,
+                '"to_page" argument should be greater or equal than "from_page"'
+        end
+      end
+    end
+
+    def validate_both_from_and_to(from, to)
+      validate_from(from)
+      validate_to(to)
+      if from && to && from > to
+        raise ArgumentError,
+              '"to" argument must be greater or equal than "from"'
+      end
+    end
+
+    def validate_is_numeric(param, param_name)
+      unless param.is_a?(Numeric)
+        raise ArgumentError,
+              "\"#{param_name}\" is not a numeric"
+      end
+    end
+
+    def validate_is_integer(param, param_name)
+      unless param.is_a?(Integer)
+        raise ArgumentError,
+              "\"#{param_name}\" is not an integer"
+      end
+    end
+
+    def validate_is_boolean(param, param_name)
+      unless param.is_a?(TrueClass) || param.is_a?(FalseClass)
+        raise ArgumentError,
+              "\"#{param_name}\" is not a true or a false"
+      end
+    end
+
+    def validate_is_string(param, param_name)
+      unless param.is_a?(String)
+        raise ArgumentError,
+              "\"#{param_name}\" is not a string"
+      end
+    end
+
+    def validate_is_positive(param, param_name)
+      unless param.positive?
+        raise ArgumentError,
+              "\"#{param_name}\" should be greater than zero"
+      end
+    end
+
+    def validate_greater_or_equal_than(param, param_name, value)
+      unless param >= value
+        raise ArgumentError,
+              "\"#{param_name}\" should be greater or equal than #{value}"
+      end
+    end
+
+    def validate_lower_or_equal_than(param, param_name, value)
+      unless param <= value
+        raise ArgumentError,
+              "\"#{param_name}\" should be lower or equal than #{value}"
+      end
+    end
+
+    def validate_string_is_in_array(param, param_name, array)
+      unless array.include?(param.downcase.strip)
+        raise ArgumentError,
+              "\"#{param_name}\" should be one of: #{array}"
+      end
+    end
+  end
+end
+# rubocop:enable Style/GuardClause

data/lib/blockfrostruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Blockfrostruby
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: blockfrost-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan (https://github.com/18bitmood)
+autorequire:
+bindir: exe
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies: []
+description: Blockfrost is a hosted API as a service serving the data from the Cardano
+  blockchain.                        This gem is Ruby SDK for Blockfrost.io to enable
+  developers                        to use full power of this API without having to
+  create basic functions for it.                        The OpenAPI documentation
+  is hosted at https://github.com/blockfrost/openapi.                        This
+  gem is licensed under ASL 2.0.
+email:
+- ivan.papushoi@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- blockfrost-ruby.gemspec
+- lib/blockfrost-ruby.rb
+- lib/blockfrostruby/config.yml
+- lib/blockfrostruby/configuration.rb
+- lib/blockfrostruby/constants.rb
+- lib/blockfrostruby/endpoints/cardano/accounts_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/addresses_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/assets_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/blocks_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/epochs_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/health_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/ledger_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/metadata_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/metrics_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/network_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/nutlink_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/pools_endpoints.rb
+- lib/blockfrostruby/endpoints/cardano/transactions_endpoints.rb
+- lib/blockfrostruby/endpoints/custom_endpoints.rb
+- lib/blockfrostruby/endpoints/ipfs/ipfs_endpoints.rb
+- lib/blockfrostruby/params.rb
+- lib/blockfrostruby/request.rb
+- lib/blockfrostruby/validator.rb
+- lib/blockfrostruby/version.rb
+homepage: https://github.com/blockfrost/blockfrost-ruby
+licenses: []
+metadata:
+  homepage_uri: https://github.com/blockfrost/blockfrost-ruby
+  source_code_uri: https://github.com/blockfrost/blockfrost-ruby
+  changelog_uri: https://github.com/blockfrost/blockfrost-ruby/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.16
+signing_key:
+specification_version: 4
+summary: Ruby SDK to work with Blockfrost (Cardano Blockchain API)
+test_files: []