ripple-rest 0.0.1 → 0.0.2

data/lib/ripple-rest.rb

@@ -3,7 +3,6 @@ module RippleRest; end
 require 'json'
 require 'cgi'
 require 'bigdecimal'
-require 'autoparse'
 require 'rest-client'
 require 'ripple-rest/version'
 require 'ripple-rest/errors'
@@ -13,23 +12,61 @@ require 'ripple-rest/schemas/account_settings'
 require 'ripple-rest/schemas/trustlines'
 require 'ripple-rest/schemas/balance'
 require 'ripple-rest/schemas/notifications'
-require 'ripple-rest/schemas/order'
 require 'ripple-rest/schemas/amount'
 require 'ripple-rest/schemas/payments'
 
 class << RippleRest
+  # Set endpoint URI
+  # @param endpoint [String] "http://localhost:5990/"
   def setup endpoint
     @endpoint = endpoint.gsub %r|/$|, ""
   end
   
+  # Retrieve the details of a transaction in the standard Ripple JSON format. 
+  # @return [Hash] See the Ripple Wiki page on [Transaction Formats](https://ripple.com/wiki/Transactions) for more information.
+  # @raise [RippleRestError] if RippleRest server returns an error
+  # @raise [ProtocolError] if protocol is wrong or network is down
+  def get_transaction hash
+    get("v1/transactions/#{hash}")["transaction"]
+  end
+  
+  # A simple endpoint that can be used to check if ripple-rest is connected to a rippled and is ready to serve. If used before querying the other endpoints this can be used to centralize the logic to handle if rippled is disconnected from the Ripple Network and unable to process transactions.
+  # @return [Boolean] true if `ripple-rest` is ready to serve
+  # @raise [RippleRestError] if RippleRest server returns an error
+  # @raise [ProtocolError] if protocol is wrong or network is down
+  def server_connected?
+    get("v1/server/connected")["connected"]
+  end
+  
+  # Retrieve information about the ripple-rest and connected rippled's current status.
+  # @return [Hash] https://github.com/ripple/ripple-rest/blob/develop/docs/api-reference.md#get-server-info
+  # @raise [RippleRestError] if RippleRest server returns an error
+  # @raise [ProtocolError] if protocol is wrong or network is down
+  def server_info
+    get("v1/server")
+  end
+  
+  # A UUID v4 generator.
+  # @return [String] "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+  # @raise [RippleRestError] if RippleRest server returns an error
+  # @raise [ProtocolError] if protocol is wrong or network is down
+  def next_uuid
+    get("v1/uuid")["uuid"]
+  end
+  
+  # @!group Private APIs
+  
+  # @api private
   def get uri, args = {}
     wrap_error { RestClient.get "#{@endpoint}/#{uri}", args }
   end
   
+  # @api private
   def post uri, args = {}
     wrap_error { RestClient.post "#{@endpoint}/#{uri}", args, :content_type => :json }
   end
   
+  # @api private
   def wrap_error
     unless @endpoint
       raise ArgumentError.new "You have to setup RippleRest first."
@@ -53,20 +90,6 @@ class << RippleRest
     json || response.to_str
   end
   
-  def get_transaction hash
-    get("v1/transactions/#{hash}")["transaction"]
-  end
-  
-  def server_connected?
-    get("v1/server/connected")["connected"]
-  end
-  
-  def server_info
-    get("v1/server")
-  end
-  
-  def next_uuid
-    get("v1/uuid")["uuid"]
-  end
+  #@!endgroup
 end
   

data/lib/ripple-rest/errors.rb

@@ -1,5 +1,6 @@
 module RippleRest
   class ProtocolError < RuntimeError
+    # @return [RestClient::Response]
     attr_accessor :response
     def initialize message, response
       super message
@@ -8,6 +9,7 @@ module RippleRest
   end
   
   class RippleRestError < RuntimeError
+    # @return [String, Hash]
     attr_accessor :response
     def initialize message, response
       super message

data/lib/ripple-rest/schemas/account.rb

@@ -1,6 +1,11 @@
 module RippleRest
   class Account
+    # Account's Address (rXXXXXX...)
+    # @return [String]
     attr_accessor :address
+    
+    # Account's secret
+    # @return [String]
     attr_accessor :secret
     
     def initialize address, secret = nil
@@ -8,12 +13,21 @@ module RippleRest
       @secret = secret
     end
     
+    # Get an account's existing balances.
+    # This includes XRP balance (which does not include a counterparty) and trustline balances.
+    # @return [Array<Balance>]
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
     def balances
       RippleRest
         .get("v1/accounts/#{@address}/balances")["balances"]
         .map(&Balance.method(:new))
     end
     
+    # Returns a Trustlines object for this account.
+    # @return [Trustlines]
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
     def trustlines
       data = RippleRest
         .get("v1/accounts/#{@address}/trustlines")["trustlines"]
@@ -23,6 +37,10 @@ module RippleRest
       obj
     end
     
+    # Returns a AccountSettings object for this account.
+    # @return [AccountSettings]
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
     def settings
       data = RippleRest.get("v1/accounts/#{@address}/settings")["settings"]
       obj = AccountSettings.new data
@@ -30,6 +48,8 @@ module RippleRest
       obj
     end
     
+    # Returns a Notifications object for this account.
+    # @return [Notifications]
     def notifications
       @notifications ||= lambda {
         obj = Notifications.new
@@ -37,11 +57,9 @@ module RippleRest
         obj
       }.call
     end
-      
-    def require_secret
-      raise ArgumentError.new("Secret is required for this operation.") unless secret
-    end
     
+    # Returns a Payments object for this account.
+    # @return [Payments]
     def payments
       payments ||= lambda {
         obj = Payments.new
@@ -50,8 +68,17 @@ module RippleRest
       }.call
     end
     
+    # Returns the address of attribute address.
+    # @return [String]
     def to_s
       address
     end
+    
+    # @!group Private APIs
+    # @api private
+    def require_secret
+      raise ArgumentError.new("Secret is required for this operation.") unless secret
+    end
+    # @!endgroup
   end
 end

data/lib/ripple-rest/schemas/account_settings.rb

@@ -1,9 +1,13 @@
 module RippleRest
-  generate_schema :AccountSettings
-  
   class AccountSettings
+    # @return [Account]
     attr_accessor :account
     
+    # Save the account settings
+    # @raise [ArgumentError] if secret is missing from the Account object
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    # @return [void]
     def save
       raise ArgumentError.new("Account is missing.") unless account
       

data/lib/ripple-rest/schemas/amount.rb

@@ -1,11 +1,12 @@
 module RippleRest
-  generate_schema :Amount
-
   class Amount
+    # @return [String]
     def to_s
       "#{value}+#{currency}#{issuer.to_s.size > 0 ? ("+" + issuer) : ""}"
     end
     
+    # @param s [String, Amount] an Amount object or a String like "1+XRP" or "1+USD+r..."
+    # @return [Amount]
     def self.from_string s
       return s if s.is_a?(Amount)
       

data/lib/ripple-rest/schemas/balance.rb

@@ -1,7 +1,6 @@
 module RippleRest
-  generate_schema :Balance
-
   class Balance
+    # @return [String]
     def inspect
       "#{value.to_s} #{currency}#{counterparty.to_s.size > 0 ? " (#{counterparty})" : ""}"
     end

data/lib/ripple-rest/schemas/json.rb

@@ -1,9 +1,12 @@
+require 'autoparse'
+
 module RippleRest
-  SCHEMA_ROOT = File.join(File.dirname(__FILE__), "json")
-  
+  # @!group Private APIs
+  # @api private
   def self.generate_schema(fn)
-    RippleRest.const_set fn, AutoParse.generate(JSON.parse(File.read(File.join(SCHEMA_ROOT, "#{fn}.json"))), :uri => "#{fn}")
+    RippleRest.const_set fn, AutoParse.generate(JSON.parse(File.read(File.join(File.join(File.dirname(__FILE__), "json"), "#{fn}.json"))), :uri => "#{fn}")
   end
+  # @!endgroup
   
   generate_schema :Currency
   generate_schema :FloatString
@@ -13,5 +16,435 @@ module RippleRest
   generate_schema :RippleAddress
   generate_schema :Timestamp
   generate_schema :UINT32
-  generate_schema :URL
-end
+  generate_schema :URL  
+  
+  generate_schema :Order
+  generate_schema :Balance
+  generate_schema :Notification
+  generate_schema :Payment
+  generate_schema :Trustline
+  generate_schema :AccountSettings
+  generate_schema :Amount
+  
+  # A 
+  class Notification < AutoParse::Instance
+    # @!attribute account
+    #   The Ripple address of the account to which the notification pertains
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute type
+    #   The resource type this notification corresponds to. Possible values are "payment", "order", "trustline", "accountsettings"
+    #   @return [String] +"^payment|order|trustline|accountsettings$"+
+
+
+    # @!attribute direction
+    #   The direction of the transaction, from the perspective of the account being queried. Possible values are "incoming", "outgoing", and "passthrough"
+    #   @return [String] +"^incoming|outgoing|passthrough$"+
+
+
+    # @!attribute state
+    #   The state of the transaction from the perspective of the Ripple Ledger. Possible values are "validated" and "failed"
+    #   @return [String] +"^validated|failed$"+
+
+
+    # @!attribute result
+    #   The rippled code indicating the success or failure type of the transaction. The code "tesSUCCESS" indicates that the transaction was successfully validated and written into the Ripple Ledger. All other codes will begin with the following prefixes: "tec", "tef", "tel", or "tej"
+    #   @return [String] +"te[cfjlms][A-Za-z_]+"+
+
+
+    # @!attribute ledger
+    #   The string representation of the index number of the ledger containing the validated or failed transaction. Failed payments will only be written into the Ripple Ledger if they fail after submission to a rippled and a Ripple Network fee is claimed
+    #   @return [String] +"^[0-9]+$"+
+
+
+    # @!attribute hash
+    #   The 256-bit hash of the transaction. This is used throughout the Ripple protocol as the unique identifier for the transaction
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+    # @!attribute timestamp
+    #   The timestamp representing when the transaction was validated and written into the Ripple ledger
+    #   @return [String<Timestamp>] +"^$|^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T(2[0-3]|[01][0-9]):[0-5][0-9]:[0-5][0-9](Z|[+](2[0-3]|[01][0-9]):[0-5][0-9])$"+
+
+
+    # @!attribute transaction_url
+    #   A URL that can be used to fetch the full resource this notification corresponds to
+    #   @return [String]
+
+
+    # @!attribute previous_notification_url
+    #   A URL that can be used to fetch the notification that preceded this one chronologically
+    #   @return [String]
+
+
+    # @!attribute next_notification_url
+    #   A URL that can be used to fetch the notification that followed this one chronologically
+    #   @return [String]
+
+
+  end
+  # A simplified Order object used by the ripple-rest API (note that "orders" are referred to elsewhere in the Ripple protocol as "offers")
+  class Order < AutoParse::Instance
+    # @!attribute account
+    #   The Ripple account address of the order's creator
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute buy
+    #   If set to true the order it indicates that the creator is looking to receive the base_amount in exchange for the counter_amount. If undefined or set to false it indicates that the creator is looking to sell the base_amount to receive the counter_amount
+    #   @return [Boolean]
+
+
+    # @!attribute base_amount
+    #   The amount of currency the seller_account is seeking to buy. If other orders take part of this one, this value will change to represent the amount left in the order. This may be specified along with the counter_amount OR exchange_rate but not both. When the order is parsed from the Ripple Ledger the base currency will be determined according to the Priority Ranking of Currencies (XRP,EUR,GBP,AUD,NZD,USD,CAD,CHF,JPY,CNY) and if neither currency is listed in the ranking the base currency will be the one that is alphabetically first
+    #   @return [Amount]
+
+
+    # @!attribute counter_amount
+    #   The amount of currency being sold. If other orders take part of this one, this value will change to represent the amount left in the order. This may be specified along with the base_amount OR the exchange_rate but not both
+    #   @return [Amount]
+
+
+    # @!attribute exchange_rate
+    #   A string representation of the order price, defined as the cost one unit of the base currency in terms of the counter currency. This may be specified along with the base_amount OR the counter_amount but not both. If it is unspecified it will be computed automatically based on the counter_amount divided by the base_amount
+    #   @return [String<FloatString>]
+
+
+    # @!attribute expiration_timestamp
+    #   The ISO combined date and time string representing the point beyond which the order will no longer be considered active or valid
+    #   @return [String<Timestamp>] +"^$|^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T(2[0-3]|[01][0-9]):[0-5][0-9]:[0-5][0-9](Z|[+](2[0-3]|[01][0-9]):[0-5][0-9])$"+
+
+
+    # @!attribute ledger_timeout
+    #   A string representation of the number of ledger closes after submission during which the order should be considered active
+    #   @return [String] +"^[0-9]*$"+
+
+
+    # @!attribute immediate_or_cancel
+    #   If set to true this order will only take orders that are available at the time of execution and will not create an entry in the Ripple Ledger
+    #   @return [Boolean]
+
+
+    # @!attribute fill_or_kill
+    #   If set to true this order will only take orders that fill the base_amount and are available at the time of execution and will not create an entry in the Ripple Ledger
+    #   @return [Boolean]
+
+
+    # @!attribute maximize_buy_or_sell
+    #   If set to true and it is a buy order it will buy up to the base_amount even if the counter_amount is exceeded, if it is a sell order it will sell up to the counter_amount even if the base_amount is exceeded
+    #   @return [Boolean]
+
+
+    # @!attribute cancel_replace
+    #   If this is set to the sequence number of an outstanding order, that order will be cancelled and replaced with this one
+    #   @return [String] +"^d*$"+
+
+
+    # @!attribute sequence
+    #   The sequence number of this order from the perspective of the seller_account. The seller_account and the sequence number uniquely identify the order in the Ripple Ledger
+    #   @return [String] +"^[0-9]*$"+
+
+
+    # @!attribute fee
+    #   The Ripple Network transaction fee, represented in whole XRP (NOT "drops", or millionths of an XRP, which is used elsewhere in the Ripple protocol) used to create the order
+    #   @return [String<FloatString>]
+
+
+    # @!attribute state
+    #   If the order is active the state will be "active". If this object represents a historical order the state will be "validated", "filled" if the order was removed because it was fully filled, "cancelled" if it was deleted by the owner, "expired" if it reached the expiration_timestamp, or "failed" if there was an error with the initial attempt to place the order
+    #   @return [String] +"^active|validated|filled|cancelled|expired|failed$"+
+
+
+    # @!attribute ledger
+    #   The string representation of the index number of the ledger containing this order or, in the case of historical queries, of the transaction that modified this Order. 
+    #   @return [String] +"^[0-9]+$"+
+
+
+    # @!attribute hash
+    #   When returned as the result of a historical query this will be the hash of Ripple transaction that created, modified, or deleted this order. The transaction hash is used throughout the Ripple Protocol to uniquely identify a particular transaction
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+    # @!attribute previous
+    #   If the order was modified or partially filled this will be a full Order object. If the previous object also had a previous object that will be removed to reduce data complexity. Order changes can be walked backwards by querying the API for previous.hash repeatedly
+    #   @return [Order]
+
+
+  end
+  # An object 
+  class AccountSettings < AutoParse::Instance
+    # @!attribute account
+    #   The Ripple address of the account in question
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute regular_key
+    #   The hash of an optional additional public key that can be used for signing and verifying transactions
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute url
+    #   The domain associated with this account. The ripple.txt file can be looked up to verify this information
+    #   @return [String<URL>] +"^(ftp://|http://|https://)?([A-Za-z0-9_]+:{0,1}[A-Za-z0-9_]*@)?(^([ \\t\\r\\n\\f])+)(:[0-9]+)?(/|/([[A-Za-z0-9_]#!:.?+=&%@!-\\/]))?$"+
+
+
+    # @!attribute email_hash
+    #   The MD5 128-bit hash of the account owner's email address
+    #   @return [String<Hash128>] +"^$|^[A-Fa-f0-9]{32}$"+
+
+
+    # @!attribute message_key
+    #   An optional public key, represented as hex, that can be set to allow others to send encrypted messages to the account owner
+    #   @return [String] +"^([0-9a-fA-F]{2}){0,33}$"+
+
+
+    # @!attribute transfer_rate
+    #   A number representation of the rate charged each time a holder of currency issued by this account transfers it. By default the rate is 100. A rate of 101 is a 1% charge on top of the amount being transferred. Up to nine decimal places are supported
+    #   @return [Float]
+
+
+    # @!attribute require_destination_tag
+    #   If set to true incoming payments will only be validated if they include a destination_tag. This may be used primarily by gateways that operate exclusively with hosted wallets
+    #   @return [Boolean]
+
+
+    # @!attribute require_authorization
+    #   If set to true incoming trustlines will only be validated if this account first creates a trustline to the counterparty with the authorized flag set to true. This may be used by gateways to prevent accounts unknown to them from holding currencies they issue
+    #   @return [Boolean]
+
+
+    # @!attribute disallow_xrp
+    #   If set to true incoming XRP payments will be allowed
+    #   @return [Boolean]
+
+
+    # @!attribute transaction_sequence
+    #   A string representation of the last sequence number of a validated transaction created by this account
+    #   @return [String<UINT32>] +"^$|^(429496729[0-5]|42949672[0-8][0-9]|4294967[01][0-9]{2}|429496[0-6][0-9]{3}|42949[0-5][0-9]{4}|4294[0-8][0-9]{5}|429[0-3][0-9]{6}|42[0-8][0-9]{7}|4[01][0-9]{8}|[1-3][0-9]{9}|[1-9][0-9]{8}|[1-9][0-9]{7}|[1-9][0-9]{6}|[1-9][0-9]{5}|[1-9][0-9]{4}|[1-9][0-9]{3}|[1-9][0-9]{2}|[1-9][0-9]|[0-9])$"+
+
+
+    # @!attribute trustline_count
+    #   The number of trustlines owned by this account. This value does not include incoming trustlines where this account has not explicitly reciprocated trust
+    #   @return [String<UINT32>] +"^$|^(429496729[0-5]|42949672[0-8][0-9]|4294967[01][0-9]{2}|429496[0-6][0-9]{3}|42949[0-5][0-9]{4}|4294[0-8][0-9]{5}|429[0-3][0-9]{6}|42[0-8][0-9]{7}|4[01][0-9]{8}|[1-3][0-9]{9}|[1-9][0-9]{8}|[1-9][0-9]{7}|[1-9][0-9]{6}|[1-9][0-9]{5}|[1-9][0-9]{4}|[1-9][0-9]{3}|[1-9][0-9]{2}|[1-9][0-9]|[0-9])$"+
+
+
+    # @!attribute ledger
+    #   The string representation of the index number of the ledger containing these account settings or, in the case of historical queries, of the transaction that modified these settings
+    #   @return [String] +"^[0-9]+$"+
+
+
+    # @!attribute hash
+    #   If this object was returned by a historical query this value will be the hash of the transaction that modified these settings. The transaction hash is used throughout the Ripple Protocol to uniquely identify a particular transaction
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+  end
+  # A flattened Payment object used by the ripple-rest API
+  class Payment < AutoParse::Instance
+    # @!attribute source_account
+    #   The Ripple account address of the Payment sender
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute source_tag
+    #   A string representing an unsigned 32-bit integer most commonly used to refer to a sender's hosted account at a Ripple gateway
+    #   @return [String<UINT32>] +"^$|^(429496729[0-5]|42949672[0-8][0-9]|4294967[01][0-9]{2}|429496[0-6][0-9]{3}|42949[0-5][0-9]{4}|4294[0-8][0-9]{5}|429[0-3][0-9]{6}|42[0-8][0-9]{7}|4[01][0-9]{8}|[1-3][0-9]{9}|[1-9][0-9]{8}|[1-9][0-9]{7}|[1-9][0-9]{6}|[1-9][0-9]{5}|[1-9][0-9]{4}|[1-9][0-9]{3}|[1-9][0-9]{2}|[1-9][0-9]|[0-9])$"+
+
+
+    # @!attribute source_amount
+    #   An optional amount that can be specified to constrain cross-currency payments
+    #   @return [Amount]
+
+
+    # @!attribute source_slippage
+    #   An optional cushion for the source_amount to increase the likelihood that the payment will succeed. The source_account will never be charged more than source_amount.value + source_slippage
+    #   @return [String<FloatString>]
+
+
+    # @!attribute destination_account
+    #   
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute destination_tag
+    #   A string representing an unsigned 32-bit integer most commonly used to refer to a receiver's hosted account at a Ripple gateway
+    #   @return [String<UINT32>] +"^$|^(429496729[0-5]|42949672[0-8][0-9]|4294967[01][0-9]{2}|429496[0-6][0-9]{3}|42949[0-5][0-9]{4}|4294[0-8][0-9]{5}|429[0-3][0-9]{6}|42[0-8][0-9]{7}|4[01][0-9]{8}|[1-3][0-9]{9}|[1-9][0-9]{8}|[1-9][0-9]{7}|[1-9][0-9]{6}|[1-9][0-9]{5}|[1-9][0-9]{4}|[1-9][0-9]{3}|[1-9][0-9]{2}|[1-9][0-9]|[0-9])$"+
+
+
+    # @!attribute destination_amount
+    #   The amount the destination_account will receive
+    #   @return [Amount]
+
+
+    # @!attribute invoice_id
+    #   A 256-bit hash that can be used to identify a particular payment
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+    # @!attribute paths 
+    #   A "stringified" version of the Ripple PathSet structure that users should treat as opaque
+    #   @return [String]
+
+
+    # @!attribute partial_payment
+    #   A boolean that, if set to true, indicates that this payment should go through even if the whole amount cannot be delivered because of a lack of liquidity or funds in the source_account account
+    #   @return [Boolean]
+
+
+    # @!attribute no_direct_ripple
+    #   A boolean that can be set to true if paths are specified and the sender would like the Ripple Network to disregard any direct paths from the source_account to the destination_account. This may be used to take advantage of an arbitrage opportunity or by gateways wishing to issue balances from a hot wallet to a user who has mistakenly set a trustline directly to the hot wallet
+    #   @return [Boolean]
+
+
+    # @!attribute direction
+    #   The direction of the payment, from the perspective of the account being queried. Possible values are "incoming", "outgoing", and "passthrough"
+    #   @return [String] +"^incoming|outgoing|passthrough$"+
+
+
+    # @!attribute state
+    #   The state of the payment from the perspective of the Ripple Ledger. Possible values are "validated" and "failed" and "new" if the payment has not been submitted yet
+    #   @return [String] +"^validated|failed|new$"+
+
+
+    # @!attribute result
+    #   The rippled code indicating the success or failure type of the payment. The code "tesSUCCESS" indicates that the payment was successfully validated and written into the Ripple Ledger. All other codes will begin with the following prefixes: "tec", "tef", "tel", or "tej"
+    #   @return [String] +"te[cfjlms][A-Za-z_]+"+
+
+
+    # @!attribute ledger
+    #   The string representation of the index number of the ledger containing the validated or failed payment. Failed payments will only be written into the Ripple Ledger if they fail after submission to a rippled and a Ripple Network fee is claimed
+    #   @return [String] +"^[0-9]+$"+
+
+
+    # @!attribute hash
+    #   The 256-bit hash of the payment. This is used throughout the Ripple protocol as the unique identifier for the transaction
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+    # @!attribute timestamp
+    #   The timestamp representing when the payment was validated and written into the Ripple ledger
+    #   @return [String<Timestamp>] +"^$|^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T(2[0-3]|[01][0-9]):[0-5][0-9]:[0-5][0-9](Z|[+](2[0-3]|[01][0-9]):[0-5][0-9])$"+
+
+
+    # @!attribute fee
+    #   The Ripple Network transaction fee, represented in whole XRP (NOT "drops", or millionths of an XRP, which is used elsewhere in the Ripple protocol)
+    #   @return [String<FloatString>]
+
+
+    # @!attribute source_balance_changes
+    #   Parsed from the validated transaction metadata, this array represents all of the changes to balances held by the source_account. Most often this will have one amount representing the Ripple Network fee and, if the source_amount was not XRP, one amount representing the actual source_amount that was sent
+    #   @return [array]
+
+
+    # @!attribute destination_balance_changes
+    #   Parsed from the validated transaction metadata, this array represents the changes to balances held by the destination_account. For those receiving payments this is important to check because if the partial_payment flag is set this value may be less than the destination_amount
+    #   @return [array]
+
+
+  end
+  # A simplified representation of an account Balance
+  class Balance < AutoParse::Instance
+    # @!attribute value
+    #   The quantity of the currency, denoted as a string to retain floating point precision
+    #   @return [String]
+
+
+    # @!attribute currency
+    #   The currency expressed as a three-character code
+    #   @return [String<Currency>] +"^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})$"+
+
+
+    # @!attribute counterparty
+    #   The Ripple account address of the currency's issuer or gateway, or an empty string if the currency is XRP
+    #   @return [String] +"^$|^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+  end
+  # An Amount on the Ripple Protocol, used also for XRP in the ripple-rest API
+  class Amount < AutoParse::Instance
+    # @!attribute value
+    #   The quantity of the currency, denoted as a string to retain floating point precision
+    #   @return [String]
+
+
+    # @!attribute currency
+    #   The currency expressed as a three-character code
+    #   @return [String<Currency>] +"^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})$"+
+
+
+    # @!attribute issuer
+    #   The Ripple account address of the currency's issuer or gateway, or an empty string if the currency is XRP
+    #   @return [String] +"^$|^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute counterparty
+    #   The Ripple account address of the currency's issuer or gateway, or an empty string if the currency is XRP
+    #   @return [String] +"^$|^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+  end
+  # A simplified Trustline object used by the ripple-rest API
+  class Trustline < AutoParse::Instance
+    # @!attribute account
+    #   The account from whose perspective this trustline is being viewed
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute counterparty
+    #   The other party in this trustline
+    #   @return [String<RippleAddress>] +"^r[1-9A-HJ-NP-Za-km-z]{25,33}$"+
+
+
+    # @!attribute currency
+    #   The code of the currency in which this trustline denotes trust
+    #   @return [String<Currency>] +"^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})$"+
+
+
+    # @!attribute limit
+    #   The maximum value of the currency that the account may hold issued by the counterparty
+    #   @return [String<FloatString>]
+
+
+    # @!attribute reciprocated_limit
+    #   The maximum value of the currency that the counterparty may hold issued by the account
+    #   @return [String<FloatString>]
+
+
+    # @!attribute authorized_by_account
+    #   Set to true if the account has explicitly authorized the counterparty to hold currency it issues. This is only necessary if the account's settings include require_authorization_for_incoming_trustlines
+    #   @return [Boolean]
+
+
+    # @!attribute authorized_by_counterparty
+    #   Set to true if the counterparty has explicitly authorized the account to hold currency it issues. This is only necessary if the counterparty's settings include require_authorization_for_incoming_trustlines
+    #   @return [Boolean]
+
+
+    # @!attribute account_allows_rippling
+    #   If true it indicates that the account allows pairwise rippling out through this trustline
+    #   @return [Boolean]
+
+
+    # @!attribute counterparty_allows_rippling
+    #   If true it indicates that the counterparty allows pairwise rippling out through this trustline
+    #   @return [Boolean]
+
+
+    # @!attribute ledger
+    #   The string representation of the index number of the ledger containing this trustline or, in the case of historical queries, of the transaction that modified this Trustline
+    #   @return [String] +"^[0-9]+$"+
+
+
+    # @!attribute hash
+    #   If this object was returned by a historical query this value will be the hash of the transaction that modified this Trustline. The transaction hash is used throughout the Ripple Protocol to uniquely identify a particular transaction
+    #   @return [String<Hash256>] +"^$|^[A-Fa-f0-9]{64}$"+
+
+
+    # @!attribute previous
+    #   If the trustline was changed this will be a full Trustline object representing the previous values. If the previous object also had a previous object that will be removed to reduce data complexity. Trustline changes can be walked backwards by querying the API for previous.hash repeatedly
+    #   @return [Trustline]
+
+
+  end
+end

data/lib/ripple-rest/schemas/json/URL.json

@@ -3,5 +3,5 @@
   "title": "URL",
   "description": "A standard URL",
   "type": "string",
-  "pattern": "^(ftp:\/\/|http:\/\/|https:\/\/)?([A-Za-z0-9_]+:{0,1}[A-Za-z0-9_]*@)?(^([ \t\r\n\f])+)(:[0-9]+)?(\/|\/([[A-Za-z0-9_]#!:.?+=&%@!-\/]))?$"
+  "pattern": "^(ftp:\/\/|http:\/\/|https:\/\/)?([A-Za-z0-9_]+:{0,1}[A-Za-z0-9_]*@)?(^([ \\t\\r\\n\\f])+)(:[0-9]+)?(\/|\/([[A-Za-z0-9_]#!:.?+=&%@!-\\/]))?$"
 }

data/lib/ripple-rest/schemas/json/_generate.rb

@@ -0,0 +1,73 @@
+require 'json'
+schemas = {}
+Dir["*.json"].each do |i|
+  key = File.basename(i, ".json")
+  schemas[key] = JSON.parse File.read i
+end
+
+puts <<'EOF'
+require 'autoparse'
+
+module RippleRest
+  # @!group Private APIs
+  # @api private
+  def self.generate_schema(fn)
+    RippleRest.const_set fn, AutoParse.generate(JSON.parse(File.read(File.join(File.join(File.dirname(__FILE__), "json"), "#{fn}.json"))), :uri => "#{fn}")
+  end
+  # @!endgroup
+  
+  generate_schema :Currency
+  generate_schema :FloatString
+  generate_schema :Hash128
+  generate_schema :Hash256
+  generate_schema :ResourceId
+  generate_schema :RippleAddress
+  generate_schema :Timestamp
+  generate_schema :UINT32
+  generate_schema :URL  
+  
+  generate_schema :Order
+  generate_schema :Balance
+  generate_schema :Notification
+  generate_schema :Payment
+  generate_schema :Trustline
+  generate_schema :AccountSettings
+  generate_schema :Amount
+  
+EOF
+schemas.values.select{|i|i["type"] == "object"}.each do |json|
+  key = json["title"]
+  puts "  # #{json["description"]}"
+  puts "  class #{key} < AutoParse::Instance"
+  
+  json["properties"].each do |k, v|
+    type = ""
+    if v["type"] == "string" && v["pattern"]
+      type = "[String] +#{v["pattern"].inspect}+"
+    elsif v["type"] == "string"
+      type = "[String]"
+    elsif v["type"] == "boolean"
+      type = "[Boolean]"
+    elsif v["type"] == "float"
+      type = "[Float]"
+    elsif v["$ref"] == "FloatString"
+      type = "[String<FloatString>]" # BigDecimal
+    elsif v["$ref"] == "UInt32"
+      type = "[UInt32]"
+    elsif v["$ref"] && schemas[v["$ref"]]["type"] == "string"
+      type = "[String<#{v["$ref"]}>] +#{schemas[v["$ref"]]["pattern"].inspect}+"
+    elsif v["$ref"]
+      type = "[#{v["$ref"]}]"
+    elsif
+      type = "[#{v["type"]}]"
+    end
+    
+    puts "    # @!attribute #{k}"
+    puts "    #   #{v["description"]}"
+    puts "    #   @return #{type}"
+    puts
+    puts
+  end
+  puts "  end"
+end
+puts "end"

data/lib/ripple-rest/schemas/notifications.rb

@@ -1,9 +1,16 @@
 module RippleRest
-  generate_schema :Notification
-  
   class Notifications
+    # @return [Account]
     attr_accessor :account
     
+    # Get notifications.
+    # 
+    # Clients using notifications to monitor their account activity should pay particular attention to the `state` and `result` fields. The `state` field will either be `validated` or `failed` and represents the finalized status of that transaction. The `result` field will be `tesSUCCESS` if the `state` was validated. If the transaction failed, `result` will contain the `rippled` or `ripple-lib` error code.
+    # 
+    # Notifications have `next_notification_url` and `previous_notification_url`'s. Account notifications can be polled by continuously following the `next_notification_url`, and handling the resultant notifications, until the `next_notification_url` is an empty string. This means that there are no new notifications but, as soon as there are, querying the same URL that produced this notification in the first place will return the same notification but with the `next_notification_url` set.
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    # @return [Notification]
     def [] hash
       Notification.new RippleRest
         .get("v1/accounts/#{account.address}/notifications/#{hash}")["notification"]

data/lib/ripple-rest/schemas/payments.rb

@@ -1,16 +1,22 @@
 module RippleRest
-  generate_schema :Payment
-
   class Payment
+    # Gets Account object of this Payment's source account
     def account
       @account
     end
     
+    # Sets source account and secret for this Payment
+    # @param val [Account]
     def account= val
       @account = val
       self.source_account = val.address
     end
     
+    # Submits a payment
+    # @return [String] Client resource ID
+    # @raise [ArgumentError] if secret is missing from the Account object
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
     def submit
       @account.require_secret
       
@@ -22,17 +28,31 @@ module RippleRest
       RippleRest.post("v1/payments", hash)["client_resource_id"]
     end
     
+    # @return [String]
     attr_accessor :client_resource_id
   end
   
   class Payments
+    # @return [Account]
     attr_accessor :account
     
+    # Returns an individual payment.
+    # @param hash [String] Payment hash or client resource ID
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    # @return [Payment]
     def [] hash
       Payment.new RippleRest
         .get("v1/accounts/#{account.address}/payments/#{hash}")["payment"]
     end
     
+    # Query `rippled` for possible payment "paths" through the Ripple Network to deliver the given amount to the specified `destination_account`. If the `destination_amount` issuer is not specified, paths will be returned for all of the issuers from whom the `destination_account` accepts the given currency.
+    # @param destination_account [String, Account] destination account
+    # @param destination_amount [String, Amount] destination amount
+    # @param source_currencies [Array<String>] an array of source currencies that can be used to constrain the results returned (e.g. `["XRP", "USD+r...", "BTC+r..."]`) Currencies can be denoted by their currency code (e.g. USD) or by their currency code and issuer (e.g. `USD+r...`). If no issuer is specified for a currency other than XRP, the results will be limited to the specified currencies but any issuer for that currency will do.
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    # @return [Array<Payment>]
     def find_path destination_account, destination_amount, source_currencies = nil
       uri = "v1/accounts/#{account.address}/payments/paths/#{destination_account.to_s}/#{destination_amount.to_s}"
       
@@ -46,6 +66,8 @@ module RippleRest
       end
     end
     
+    # Create a Payment object with some field filled.
+    # @return [Payment]
     def create destination_account, destination_amount
       payment = Payment.new
       payment.account = account
@@ -54,6 +76,18 @@ module RippleRest
       payment
     end
     
+    # Browse historical payments in bulk.
+    # @option options [String, Account] :source_account If specified, limit the results to payments initiated by a particular account
+    # @option options [String, Account] :destination_account If specified, limit the results to payments made to a particular account
+    # @option options [Boolean] :exclude_failed if set to true, this will return only payment that were successfully validated and written into the Ripple Ledger
+    # @option options [String] :start_ledger If earliest_first is set to true this will be the index number of the earliest ledger queried, or the most recent one if earliest_first is set to false. Defaults to the first ledger the rippled has in its complete ledger. An error will be returned if this value is outside the rippled's complete ledger set
+    # @option options [String] :end_ledger If earliest_first is set to true this will be the index number of the most recent ledger queried, or the earliest one if earliest_first is set to false. Defaults to the last ledger the rippled has in its complete ledger. An error will be returned if this value is outside the rippled's complete ledger set
+    # @option options [Boolean] :earliest_first Determines the order in which the results should be displayed. Defaults to true
+    # @option options [Fixnum] :results_per_page Limits the number of resources displayed per page. Defaults to 20
+    # @option options [Fixnum] :page The page to be displayed. If there are fewer than the results_per_page number displayed, this indicates that this is the last page
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    # @return [Array<Payment>]
     def query options = {}
       qs = ""
       if options && options.size > 0

data/lib/ripple-rest/schemas/trustlines.rb

@@ -1,24 +1,31 @@
 module RippleRest
-  
-  generate_schema :Trustline
   class Trustlines
     include Enumerable
     
+    # @return [Account]
     attr_accessor :account
     
     def initialize data
       @data = data
     end
     
+    # Use with Enumerable
     def each *args, &block
       @data.each *args, &block
     end
     
-    def add obj
+    # Add trustline
+    # @param obj [String, Hash] Either a string representation of trustline limit, Hash containing value, currency, counterparty or a string form value/currency/counterparty.
+    # @param allow_rippling [Boolean] See [here](https://ripple.com/wiki/No_Ripple) for details
+    # @raise [ArgumentError] if secret is missing from the Account object
+    # @raise [RippleRestError] if RippleRest server returns an error
+    # @raise [ProtocolError] if protocol is wrong or network is down
+    def add obj, allow_rippling = true
       raise ArgumentError.new("Account is missing.") unless account
       account.require_secret
       
       hash = {}
+      hash["allow_rippling"] = allow_rippling
       hash["secret"] = account.secret
       
       if obj.is_a? String

data/lib/ripple-rest/version.rb

@@ -1,3 +1,3 @@
 module RippleRest
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripple-rest
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -49,6 +49,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ripple-rest/schemas/json/_generate.rb
 - lib/ripple-rest/schemas/json.rb
 - lib/ripple-rest/schemas/trustlines.rb
 - lib/ripple-rest/schemas/payments.rb
@@ -56,7 +57,6 @@ files:
 - lib/ripple-rest/schemas/account_settings.rb
 - lib/ripple-rest/schemas/balance.rb
 - lib/ripple-rest/schemas/notifications.rb
-- lib/ripple-rest/schemas/order.rb
 - lib/ripple-rest/schemas/account.rb
 - lib/ripple-rest/version.rb
 - lib/ripple-rest/errors.rb
@@ -95,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -284765535
+      hash: 9938735
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/ripple-rest/schemas/order.rb

@@ -1,6 +0,0 @@
-module RippleRest
-  generate_schema :Order
-
-  class Order
-  end
-end