ripple-rest 0.0.2 → 1.0.0

data/lib/ripple-rest/{schemas/payments.rb → helpers.rb}

@@ -1,35 +1,103 @@
 module RippleRest
-  class Payment
-    # Gets Account object of this Payment's source account
-    def account
-      @account
+  class Account
+    # Account's Address (rXXXXXX...)
+    # @return [String]
+    attr_accessor :address
+    
+    # Account's secret
+    # @return [String]
+    attr_accessor :secret
+    
+    def initialize address, secret = nil
+      @address = address
+      @secret = secret
     end
     
-    # Sets source account and secret for this Payment
-    # @param val [Account]
-    def account= val
-      @account = val
-      self.source_account = val.address
+    # 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
     
-    # Submits a payment
-    # @return [String] Client resource ID
-    # @raise [ArgumentError] if secret is missing from the Account object
+    # 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 submit
-      @account.require_secret
-      
-      hash = {}
-      hash["payment"] = self.to_hash
-      hash["secret"] = @account.secret
-      hash["client_resource_id"] = client_resource_id = RippleRest.next_uuid
-      
-      RippleRest.post("v1/payments", hash)["client_resource_id"]
+    def trustlines
+      data = RippleRest
+        .get("v1/accounts/#{@address}/trustlines")["trustlines"]
+        .map(&Trustline.method(:new))
+      obj = Trustlines.new data
+      obj.account = self
+      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
+      obj.account = self
+      obj
+    end
+    
+    # Returns a Notifications object for this account.
+    # @return [Notifications]
+    def notifications
+      @notifications ||= lambda {
+        obj = Notifications.new
+        obj.account = self
+        obj
+      }.call
+    end
+    
+    # Returns a Payments object for this account.
+    # @return [Payments]
+    def payments
+      payments ||= lambda {
+        obj = Payments.new
+        obj.account = self
+        obj
+      }.call
+    end
+    
+    # Returns the address of attribute address.
     # @return [String]
-    attr_accessor :client_resource_id
+    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
+  
+  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"]
+    end
   end
   
   class Payments
@@ -103,4 +171,43 @@ module RippleRest
       end
     end
   end
+  
+  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
+    
+    # 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
+        hash["trustline"] = { "limit" => obj }
+      else
+        hash["trustline"] = obj.to_hash
+      end
+      
+      RippleRest.post "v1/accounts/#{account.address}/trustlines", hash
+    end
+  end
 end

data/lib/ripple-rest/rest-object.rb

@@ -0,0 +1,191 @@
+require 'uri'
+require 'time'
+
+module RippleRest
+  # @api private
+  module RestTypeHelper
+    # @!visibility private
+    # @api private
+    def self.exist? key
+      @converter ||= {}
+      @converter.keys.include? key
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.register key, to, from, check, name = nil
+      return key if exist? key
+      
+      @converter ||= {}
+      @converter[key] = [to, from, check, name ? name : key.to_s]
+      
+      key
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.register_string key, regexp
+      reg = Regexp.new regexp
+      
+      register key,
+        RETURN_SELF, 
+        RETURN_SELF, 
+        lambda { |x| (x.is_a?(String) && x.match(reg)) },
+        "String<#{key}>: #{reg.inspect}"
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.register_array type
+      register :"Array<#{type}>",
+        lambda { |x| x.map { |i| self.convert_to(type, i) } }, 
+        lambda { |x| x.map { |i| self.convert_from(type, i) } }, 
+        lambda { |x| (x.is_a?(Array) && x.all? {|i| self.convert_check(type, i) }) },
+        "Array<#{type}>"
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.register_string_otg regexp
+      register_string :"String<#{regexp.inspect}>", regexp
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.register_object key, klass
+      register key, 
+        lambda { |x| x.to_hash },
+        lambda { |x| x.is_a?(klass) ? x : klass.new(x) },
+        lambda { |x| x.is_a? klass },
+        "#{key}"
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.convert_to type, obj
+      return nil if obj.nil?
+      @converter[type][0].call obj
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.convert_from type, obj
+      return nil if obj.nil?
+      @converter[type][1].call obj
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.convert_check type, obj
+      return true if obj.nil?
+      @converter[type][2].call obj
+    end
+    
+    # @!visibility private
+    # @api private
+    def self.convert_raise type, obj
+      raise ArgumentError.new "#{obj.inspect} cannot be casted to #{@converter[type][3]}"
+    end
+    
+    # @api private
+    RETURN_SELF = lambda { |x| x }
+    
+    register :String, 
+        RETURN_SELF, 
+        RETURN_SELF, 
+        lambda { |x| x.is_a?(String) }
+    
+    register :Boolean,
+        RETURN_SELF, 
+        RETURN_SELF, 
+        lambda { |x| [true, false].include? x }
+    
+    register :FloatString,
+        lambda { |x| x.is_a?(BigDecimal) ? x.to_s("F") : BigDecimal.new(x.to_s).to_s("F") },
+        lambda { |x| x.is_a?(BigDecimal) ? x : BigDecimal.new(x) },
+        lambda { |x| x.is_a?(BigDecimal) || x.respond_to?(:to_f)}
+    
+    register :UINT32,
+        lambda { |x| x.to_i.to_s },
+        lambda { |x| x.to_i },
+        lambda { |x| x.is_a?(Numeric) && x >= 0 && x <= 4294967295 }
+    
+    register :Timestamp,
+        lambda { |x| x.iso8601 },
+        lambda { |x| x.is_a?(Time) ? x : Time.iso8601(x) },
+        lambda { |x| x.is_a?(Time) || x.is_a?(String) }
+    
+    register :URL,
+        lambda { |x| x.to_s },
+        lambda { |x| URI(x.to_s) },
+        lambda { |x| x.is_a?(URI) || x.respond_to?(:to_s) }
+  end
+  
+  class RestObject
+    # @param data [Hash]
+    def initialize data = nil
+      data.each do |key, value|
+        if @@properties[self.class][key.to_sym]
+          self.instance_variable_set :"@#{key}", RestTypeHelper.convert_from(@@properties[self.class][key.to_sym], value)
+        else
+          warn "Cannot found field `#{key}' in RippleRestObject #{self.class}. The value will leave as-is. However, this will not be serialized to JSON."
+          self.instance_variable_set :"@#{key}",  value
+        end
+      end if data
+    end
+    
+    # Convert to a hash
+    # @return [Hash]
+    def to_hash
+      result = {}
+      @@properties[self.class].each do |key, type|
+        value = self.instance_variable_get(:"@#{key}")
+        if @@required[self.class][key] && value == nil
+          raise ArgumentError.new("Field `#{key}' is required in RippleRestObject #{self.class}.")
+        end
+        result[key] = RestTypeHelper.convert_to(type, value) if value != nil
+      end
+      
+      result
+    end
+    
+    # @!visibility protected
+    # @api private
+    def self.required symbol
+      @@required[self][symbol] = true
+    end
+    
+    # @!visibility protected
+    # @api private
+    def self.property symbol, typeobj
+      if typeobj.is_a? Symbol
+        type = typeobj
+      elsif typeobj.is_a?(Array) && typeobj[0] == :String
+        type = RestTypeHelper.register_string_otg typeobj[1]
+      elsif typeobj.is_a?(Array) && typeobj[0] == :Array
+        type = RestTypeHelper.register_array typeobj[1]
+      end
+      
+      define_method :"#{symbol}", &lambda { self.instance_variable_get :"@#{symbol}" }
+      define_method :"#{symbol}=", &lambda { |value|
+        begin
+          raise "" unless RestTypeHelper.convert_check(type, value)
+          self.instance_variable_set :"@#{symbol}", RestTypeHelper.convert_from(type, value)
+        rescue
+          RestTypeHelper.convert_raise type, value
+        end
+      }
+      
+      @@properties[self][symbol] = type
+    end
+    
+    @@required ||= Hash.new { |h, k| h[k] = Hash.new }
+    @@properties ||= Hash.new { |h, k| h[k] = Hash.new }
+  end
+  
+  
+  class << RestObject
+    protected :property
+    protected :required
+  end
+end

data/lib/ripple-rest/schemas.rb

@@ -0,0 +1,82 @@
+module RippleRest
+  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
+      
+      account.require_secret
+      
+      hash = to_hash
+      hash["secret"] = account.secret
+      
+      RippleRest.post "v1/accounts/#{account.address}/settings", hash
+    end
+  end
+  
+  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)
+      
+      arr = s.split("+")
+      Amount.new({
+        "value" => arr[0],
+        "currency" => arr[1],
+        "issuer" => arr[2]
+      })
+    end
+  end
+  
+  class Balance
+    # @return [String]
+    def inspect
+      "#{value.to_s} #{currency}#{counterparty.to_s.size > 0 ? " (#{counterparty})" : ""}"
+    end
+  end
+  
+  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
+      
+      hash = {}
+      hash["payment"] = self.to_hash
+      hash["secret"] = @account.secret
+      hash["client_resource_id"] = client_resource_id = RippleRest.next_uuid
+      
+      RippleRest.post("v1/payments", hash)["client_resource_id"]
+    end
+    
+    # @return [String]
+    attr_accessor :client_resource_id
+  end
+end

data/lib/ripple-rest/version.rb

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