raiblocks_rpc 0.3.0 → 0.4.0

data/lib/raiblocks/proxy.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Raiblocks::Proxy
+  attr_accessor :client
+
+  def initialize(opts = {})
+    @client = opts[:client] || Raiblocks.client
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    attr_reader :proxy_method_def, :proxy_param_def
+
+    def proxy_params(param_def = nil)
+      @proxy_param_def = param_def
+    end
+
+    def proxy_method(name, signature = nil)
+      @proxy_method_def ||= {}
+      @proxy_method_def[name] = signature
+    end
+
+    def proxy_methods
+      proxy_method_def.keys.sort
+    end
+
+    def methods
+      (super + proxy_methods).sort
+    end
+
+    def define_proxy_method(m, singleton = false)
+      send(
+        singleton ? :define_singleton_method : :define_method,
+        method_alias(m)
+      ) do |opts = {}|
+        params = Raiblocks::ProxyContext.new(
+          singleton ? self : self.class, m, opts
+        ).populate_params(singleton ? nil : base_params)
+        data = Raiblocks.client.call(m, params)
+        data.is_a?(Hash) && data.keys.map(&:to_s) == [m.to_s] ? data[m] : data
+      end
+    end
+
+    private
+
+    # Raiblocks `send` action is also the method caller in Ruby ;)
+    def method_alias(m)
+      m == :send ? :tx_send : m
+    end
+
+    def method_missing(m, *args, &_block)
+      return super unless valid_method?(m)
+      define_proxy_method(m, true)
+      send(m, args.first)
+    end
+
+    def respond_to_missing?(m, include_private = false)
+      valid_method?(m) || super
+    end
+
+    def valid_method?(m)
+      proxy_param_def.nil? && methods.include?(m)
+    end
+
+    def proxy_context(m)
+      @proxy_context ||= {}
+      @proxy_context[m] ||= Raiblocks::ProxyContext.new(self, m)
+    end
+  end
+
+  def proxy_methods
+    self.class.proxy_methods
+  end
+
+  def methods
+    (super + proxy_methods).sort
+  end
+
+  private
+
+  def base_params
+    return if self.class.proxy_param_def.nil?
+    self.class
+        .proxy_param_def
+        .each_with_object({}) do |(k, v), params|
+      params[k] ||= send(v)
+    end
+  end
+
+  def method_missing(m, *args, &_block)
+    return super unless methods.include?(m)
+    self.class.define_proxy_method(m)
+    send(m, args.first)
+  end
+
+  def respond_to_missing?(m, include_private = false)
+    methods.include?(m) || super
+  end
+end

data/lib/raiblocks/proxy_context.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+class Raiblocks::ProxyContext
+  def initialize(klass, m, opts = {})
+    @klass = klass
+    @method_def = klass.proxy_method_def
+    @param_def = klass.proxy_param_def
+    @m = m
+    @opts = opts
+  end
+
+  def valid_proxy_method?
+    rpc_action?
+  end
+
+  def populate_params(params)
+    opts = validate_opts!
+    opts.merge!(params) if params
+    validate_params!
+    opts.delete_if { |_k, v| v.nil? }
+    opts
+  end
+
+  def validate_opts!
+    return @opts if @opts.is_a?(Hash)
+    return {} if @opts.nil?
+    raise Raiblocks::InvalidParameterType,
+          'You must pass a hash to an action method'
+  end
+
+  def validate_params!
+    ensure_required_params!
+    ensure_no_forbidden_params!
+  end
+
+  def ensure_required_params!
+    missing_params = required_params - opts_keys
+    return unless missing_params.any?
+    raise Raiblocks::MissingParameters,
+          "Missing required parameter(s): #{missing_params.join(', ')}"
+  end
+
+  def ensure_no_forbidden_params!
+    forbidden_params = base_param_keys + opts_keys - allowed_params
+    return unless forbidden_params.any?
+    raise Raiblocks::ForbiddenParameter,
+          "Forbidden parameter(s) passed: #{forbidden_params.join(', ')}"
+  end
+
+  private
+
+  def opts_keys
+    @opts.nil? ? [] : @opts.keys
+  end
+
+  def allowed_params
+    base_param_keys + required_params + optional_params
+  end
+
+  def required_params
+    return [] unless @method_def && @method_def[@m]
+    @method_def[@m][:required]
+  end
+
+  def optional_params
+    return [] unless @method_def && @method_def[@m]
+    @method_def[@m][:optional]
+  end
+
+  def base_param_keys
+    @param_def.is_a?(Hash) ? @param_def.keys : []
+  end
+
+  def method_expansion
+    "#{action_prefix}#{@m}"
+  end
+
+  def action_prefix
+    @klass.name.split('::').last.downcase + '_'
+  end
+end

data/lib/raiblocks/response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'hashie'
+
+class Raiblocks::Response < Hash
+  include ::Hashie::Extensions::MergeInitializer
+  include ::Hashie::Extensions::IndifferentAccess
+  include ::Hashie::Extensions::MethodAccess
+
+  def initialize(hash = {})
+    super
+    coerce_values
+  end
+
+  private
+
+  def coerce_values
+    merge!(self) { |_k, v| to_f_or_i_or_s(v) }
+  end
+
+  def to_f_or_i_or_s(v)
+    (float = Float(v)) && (float % 1.0).zero? ? float.to_i : float
+  rescue ArgumentError, TypeErrror
+    v
+  end
+end

data/lib/raiblocks/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Raiblocks
+  VERSION = '0.4.0'
+end

data/lib/raiblocks_rpc.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
-require 'raiblocks_rpc/version'
-require 'raiblocks_rpc/client'
-require 'raiblocks_rpc/errors'
-require 'raiblocks_rpc/proxy'
-require 'raiblocks_rpc/response'
-require 'raiblocks_rpc/proxies/account'
-require 'raiblocks_rpc/proxies/accounts'
-require 'raiblocks_rpc/proxies/network'
-require 'raiblocks_rpc/proxies/node'
-require 'raiblocks_rpc/proxies/util'
-require 'raiblocks_rpc/proxies/wallet'
-
-module RaiblocksRpc
-  def self.client
-    @client ||= Client.new
-  end
-end
+require 'raiblocks/version'
+require 'raiblocks/client'
+require 'raiblocks/errors'
+require 'raiblocks/proxy'
+require 'raiblocks/proxy_context'
+require 'raiblocks/response'
+require 'raiblocks/helpers/account_proxy_helper'
+require 'raiblocks/helpers/accounts_proxy_helper'
+require 'raiblocks/helpers/node_proxy_helper'
+require 'raiblocks/helpers/wallet_proxy_helper'
+require 'raiblocks/proxies/account'
+require 'raiblocks/proxies/accounts'
+require 'raiblocks/proxies/node'
+require 'raiblocks/proxies/wallet'

data/raiblocks_rpc.gemspec

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'raiblocks_rpc/version'
+require 'raiblocks/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'raiblocks_rpc'
-  spec.version       = RaiblocksRpc::VERSION
+  spec.version       = Raiblocks::VERSION
   spec.authors       = ['Justin Craig-Kuhn (JCK)']
   spec.email         = ['jcraigk@gmail.com']
 
@@ -29,8 +29,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry', '~> 0.11.3'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'simplecov', '~> 0.15.1'
   spec.add_development_dependency 'rubocop', '~> 0.52.1'
+  spec.add_development_dependency 'simplecov', '~> 0.15.1'
 
   spec.add_runtime_dependency 'hashie', '~> 3.5', '>= 3.5.7'
   spec.add_runtime_dependency 'rest-client', '~> 2.0', '>= 2.0.2'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raiblocks_rpc
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Justin Craig-Kuhn (JCK)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,33 +67,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.52.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.1
+        version: 0.52.1
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: 0.15.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.1
+        version: 0.15.1
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -152,18 +152,21 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/raiblocks/client.rb
+- lib/raiblocks/errors.rb
+- lib/raiblocks/helpers/account_proxy_helper.rb
+- lib/raiblocks/helpers/accounts_proxy_helper.rb
+- lib/raiblocks/helpers/node_proxy_helper.rb
+- lib/raiblocks/helpers/wallet_proxy_helper.rb
+- lib/raiblocks/proxies/account.rb
+- lib/raiblocks/proxies/accounts.rb
+- lib/raiblocks/proxies/node.rb
+- lib/raiblocks/proxies/wallet.rb
+- lib/raiblocks/proxy.rb
+- lib/raiblocks/proxy_context.rb
+- lib/raiblocks/response.rb
+- lib/raiblocks/version.rb
 - lib/raiblocks_rpc.rb
-- lib/raiblocks_rpc/client.rb
-- lib/raiblocks_rpc/errors.rb
-- lib/raiblocks_rpc/proxies/account.rb
-- lib/raiblocks_rpc/proxies/accounts.rb
-- lib/raiblocks_rpc/proxies/network.rb
-- lib/raiblocks_rpc/proxies/node.rb
-- lib/raiblocks_rpc/proxies/util.rb
-- lib/raiblocks_rpc/proxies/wallet.rb
-- lib/raiblocks_rpc/proxy.rb
-- lib/raiblocks_rpc/response.rb
-- lib/raiblocks_rpc/version.rb
 - raiblocks_rpc.gemspec
 homepage: https://github.com/jcraigk/ruby_raiblocks_rpc
 licenses:

data/lib/raiblocks_rpc/client.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require 'singleton'
-require 'rest-client'
-require 'json'
-
-class RaiblocksRpc::Client
-  attr_accessor :host, :port
-
-  def initialize(host: 'localhost', port: 7076)
-    @host = host
-    @port = port
-  end
-
-  def call(action, params = {})
-    post({ action: action }.merge(params))
-  end
-
-  private
-
-  def post(params)
-    response = RestClient.post(url, params.to_json)
-    ensure_status_success!(response)
-
-    data = RaiblocksRpc::Response.new(JSON[response.body])
-    ensure_valid_response!(data)
-
-    data
-  end
-
-  def url
-    "http://#{host}:#{port}"
-  end
-
-  def ensure_status_success!(response)
-    return if response.code == 200
-    raise RaiblocksRpc::BadRequest,
-          "Error response from node: #{JSON[response.body]}"
-  end
-
-  def ensure_valid_response!(data)
-    return unless data['error']
-    raise RaiblocksRpc::InvalidRequest,
-          "Invalid request: #{data['error']}"
-  end
-end

data/lib/raiblocks_rpc/proxies/account.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Account < RaiblocksRpc::Proxy
-  attr_accessor :address
-
-  def initialize(address)
-    unless address
-      raise RaiblocksRpc::MissingArguments,
-            'Missing argument: address (str)'
-    end
-
-    self.address = address
-  end
-
-  def proxy_params
-    { account: :address }
-  end
-
-  def proxy_methods
-    {
-      account_balance: nil,
-      account_block_count: nil,
-      account_info: nil,
-      account_create: { required: %i[wallet] },
-      account_history: { required: %i[count] },
-      account_list: nil,
-      account_move: { required: %i[wallet source accounts] },
-      account_key: nil,
-      account_remove: { required: %i[wallet] },
-      account_representative: nil,
-      account_representative_set: { required: %i[wallet representative] },
-      account_weight: nil,
-      delegators: nil,
-      delegators_count: nil,
-      frontiers: { required: %i[count] },
-      frontier_count: nil,
-      ledger: { required: %i[count] },
-      validate_account_number: nil,
-      pending: { required: %i[count], optional: %i[threshold exists] },
-      payment_wait: { required: %i[amount timeout] },
-      accounts_balances: { required: %i[accounts] },
-      accounts_create: {
-        required: %i[accounts wallet count], optional: %i[work]
-      },
-      accounts_frontiers: { required: %i[accounts] },
-      accounts_pending: {
-        required: %i[accounts count], optional: %i[threshold source]
-      }
-    }
-  end
-end

data/lib/raiblocks_rpc/proxies/accounts.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Accounts < RaiblocksRpc::Proxy
-  attr_accessor :addresses
-
-  def initialize(addresses)
-    unless addresses.is_a?(Array)
-      raise RaiblocksRpc::MissingArguments,
-            'Missing argument: addresses (str[])'
-    end
-
-    self.addresses = addresses
-  end
-
-  def proxy_params
-    { accounts: :addresses }
-  end
-
-  def proxy_methods
-    {
-      accounts_balances: nil,
-      accounts_create: { required: %i[wallet count], optional: %i[work] },
-      accounts_frontiers: nil,
-      accounts_pending: { required: %i[count], optional: %i[threshold source] }
-    }
-  end
-
-  # TODO implement ability to instantiate Account instances like
-  # accounts = Accounts.new(['abc', 'def'])
-  # accounts.first
-  # => RaiblocksRpc::Account address='abc'
-  # [], each (more iterators?)
-end

data/lib/raiblocks_rpc/proxies/network.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Network < RaiblocksRpc::Proxy
-  def proxy_methods
-    {
-      available_supply: nil,
-      block: { required: %i[hash] },
-      blocks: { required: %i[hashes] },
-      blocks_info: { required: %i[hashes], optional: %i[pending source] },
-      block_account: { required: %i[hash] },
-      block_count: nil,
-      block_count_type: nil,
-      chain: { required: %i[block count] },
-      history: { required: %i[hash count] },
-      block_create: {
-        required: %i[type key representative source], optional: %i[work]
-      },
-      process: { required: %i[block] },
-      republish: {
-        required: %i[hash], optional: %i[count sources destinations]
-      },
-      successors: { required: %i[block count] },
-      pending_exists: { required: %i[hash] },
-      unchecked: { required: %i[count] },
-      unchecked_clear: nil,
-      unchecked_get: { required: %i[hash] },
-      unchecked_keys: { required: %i[key count] },
-      work_cancel: { required: %i[hash] },
-      work_generate: { required: %i[hash] },
-      payment_wait: { required: %i[account amount timeout] },
-      work_validate: { required: %i[work hash] },
-      bootstrap: { required: %i[address port] },
-      keepalive: { required: %i[address port] },
-      work_peer_add: { required: %i[address port] },
-      bootstrap_any: nil
-    }
-  end
-end

data/lib/raiblocks_rpc/proxies/node.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Node < RaiblocksRpc::Proxy
-  def proxy_methods
-    {
-      bootstrap: { required: %i[address port] },
-      bootstrap_any: nil,
-      keepalive: { required: %i[address port] },
-      work_peer_add: { required: %i[address port] },
-      deterministic_key: { required: %i[seed index] },
-      receive_minimum: nil,
-      receive_minimum_set: { required: %i[amount] },
-      representatives: nil,
-      stop: nil,
-      version: nil,
-      peers: nil,
-      work_peers: nil,
-      work_peers_clear: nil,
-      work_validate: { required: %i[work hash] },
-      search_pending: { required: %i[wallet] },
-      search_pending_all: nil,
-      available_supply: nil,
-      block: { required: %i[hash] },
-      blocks: { required: %i[hashes] },
-      blocks_info: { required: %i[hashes], optional: %i[pending source] },
-      block_account: { required: %i[hash] },
-      block_count: nil,
-      block_count_type: nil,
-      unchecked: { required: %i[count] },
-      unchecked_clear: nil,
-      unchecked_get: { required: %i[hash] },
-      unchecked_keys: { required: %i[key count] },
-      payment_wait: { required: %i[account amount timeout] }
-    }
-  end
-end

data/lib/raiblocks_rpc/proxies/util.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Util < RaiblocksRpc::Proxy
-  def proxy_methods
-    {
-      mrai_from_raw: { required: %i[amount] },
-      mrai_to_raw: { required: %i[amount] },
-      krai_from_raw: { required: %i[amount] },
-      krai_to_raw: { required: %i[amount] },
-      rai_from_raw: { required: %i[amount] },
-      rai_to_raw: { required: %i[amount] },
-      key_create: nil,
-      key_expand: { required: %i[key] },
-      work_validate: { required: %i[work hash] }
-    }
-  end
-end

data/lib/raiblocks_rpc/proxies/wallet.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-class RaiblocksRpc::Wallet < RaiblocksRpc::Proxy
-  attr_accessor :seed
-
-  def initialize(wallet_seed)
-    unless wallet_address.is_a?(String) || public_key.is_a?(Symbol)
-      raise RaiblocksRpc::MissingArguments,
-            'Missing argument: wallet_seed (str)'
-    end
-
-    self.seed = wallet_seed
-  end
-
-  def proxy_params
-    { wallet: :seed }
-  end
-
-  def proxy_methods
-    {
-      wallet_balances: nil,
-      wallet_add: { required: %i[key], optional: %i[work] },
-      password_change: { required: %i[password] },
-      wallet_change_seed: { required: %i[seed] },
-      wallet_contains: { required: %i[account] },
-      wallet_create: nil,
-      wallet_destroy: nil,
-      wallet_export: nil,
-      wallet_frontiers: nil,
-      wallet_locked: nil,
-      password_enter: { required: %i[password] },
-      wallet_pending: { required: %i[count], optional: %i[threshold source] },
-      wallet_republish: { required: %i[count] },
-      wallet_balance_total: nil,
-      password_valid: nil,
-      wallet_work_get: nil,
-      send: { required: %[wallet source destination amount] },
-      work_get: nil,
-      work_set: nil,
-      search_pending: nil,
-      wallet_representative: nil,
-      wallet_representative_set: %i[representative],
-      payment_begin: nil,
-      payment_init: nil,
-      payment_end: { required: %i[account] },
-      receive: { required: %i[account block] }
-    }
-  end
-end