Allow asset objects to be passed instead of list of parameters (#59)

Author: JakeUrban

lib/stellar/operation.rb

@@ -43,7 +43,7 @@ def self.make(attributes={})
     #                              Stellar::PaymentOp body
     def self.payment(attributes={})
       destination = attributes[:destination]
-      asset, amount = extract_amount(attributes[:amount])
+      asset, amount = get_asset_amount(attributes[:amount])
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -96,9 +96,11 @@ def self.path_payment(attributes={})
     #                              
     def self.path_payment_strict_receive(attributes={})
       destination             = attributes[:destination]
-      asset, amount           = extract_amount(attributes[:amount])
-      send_asset, send_max    = extract_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+      asset, amount           = get_asset_amount(attributes[:amount])
+      send_asset, send_max    = get_asset_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{
+        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+      }
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -132,9 +134,11 @@ def self.path_payment_strict_receive(attributes={})
     #                              
     def self.path_payment_strict_send(attributes={})
       destination             = attributes[:destination]
-      asset, dest_min         = extract_amount(attributes[:amount])
-      send_asset, send_amount = extract_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+      asset, dest_min         = get_asset_amount(attributes[:amount])
+      send_asset, send_amount = get_asset_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{
+        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+      }
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -199,11 +203,17 @@ def self.change_trust(attributes={})
     end
 
     def self.manage_sell_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      offer_id   = attributes[:offer_id] || 0
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      offer_id = attributes[:offer_id] || 0
+      price = interpret_price(attributes[:price])
 
       op = ManageSellOfferOp.new({
         buying:     buying,
@@ -219,11 +229,17 @@ def self.manage_sell_offer(attributes={})
     end
 
     def self.manage_buy_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      offer_id   = attributes[:offer_id] || 0
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      offer_id = attributes[:offer_id] || 0
+      price = interpret_price(attributes[:price])
 
       op = ManageBuyOfferOp.new({
         buying:     buying,
@@ -239,10 +255,16 @@ def self.manage_buy_offer(attributes={})
     end
 
     def self.create_passive_sell_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      price = interpret_price(attributes[:price])
 
       op = CreatePassiveSellOfferOp.new({
         buying:     buying,
@@ -309,9 +331,12 @@ def self.set_options(attributes={})
     def self.allow_trust(attributes={})
       op = AllowTrustOp.new()
 
-      trustor   = attributes[:trustor]
+      trustor = attributes[:trustor]
       authorize = attributes[:authorize]
-      asset     = Asset.send(*attributes[:asset])
+      asset = attributes[:asset]
+      if asset.is_a?(Array)
+        asset = Asset.send(*asset)
+      end
 
       raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
       raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
@@ -407,9 +432,13 @@ def self.bump_sequence(attributes={})
     end
 
     private
-    def self.extract_amount(a)
-      amount   = interpret_amount(a.last)
-      asset    = Stellar::Asset.send(*a[0...-1])
+    def self.get_asset_amount(values)
+      amount = interpret_amount(values.last)
+      if values[0].is_a?(Stellar::Asset)
+        asset = values.first
+      else
+        asset = Stellar::Asset.send(*values[0...-1])
+      end
 
       return asset, amount
     end

spec/lib/stellar/operation_spec.rb

@@ -1,15 +1,12 @@
 require 'spec_helper'
 
 describe Stellar::Operation, ".payment" do
-
-
   it "correctly translates the provided amount to the native representation" do
     op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, 20])
     expect(op.body.value.amount).to eql(20_0000000)
     op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, "20"])
     expect(op.body.value.amount).to eql(20_0000000)
   end
-
 end
 
 def pk_to_address(pk)
@@ -22,13 +19,14 @@ def pk_to_address(pk)
   let(:send_asset){ Stellar::Asset.alphanum4("USD", send_asset_issuer) }
   let(:dest_asset_issuer){ Stellar::KeyPair.master }
   let(:dest_asset){ Stellar::Asset.alphanum4("EUR", dest_asset_issuer) }
-  let(:amount){ [:alphanum4, dest_asset.code, dest_asset_issuer, 9.2] }
-  let(:with){ [:alphanum4, send_asset.code, send_asset_issuer, 10] }
+  let(:amount){ [Stellar::Asset.alphanum4(dest_asset.code, dest_asset_issuer), 9.2] }
+  let(:with){ [Stellar::Asset.alphanum4(send_asset.code, send_asset_issuer), 10] }
 
   describe Stellar::Operation, ".path_payment" do
     it "works" do
       destination = Stellar::KeyPair.random
-      amount = [:alphanum4, "USD", Stellar::KeyPair.master, 10]    
+      # test both forms of arrays
+      amount = [Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master), 10]    
       with = [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2]
 
       op = Stellar::Operation.path_payment(
@@ -98,7 +96,7 @@ def pk_to_address(pk)
   let(:asset) { Stellar::Asset.alphanum4("USD", issuer) }
 
   it "creates a ChangeTrustOp" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer])
+    op = Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
     expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value.limit).to eq(9223372036854775807)
@@ -119,15 +117,15 @@ def pk_to_address(pk)
   end
 
   it "creates a ChangeTrustOp with limit" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: 1234.75)
+    op = Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer), limit: 1234.75)
     expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
     expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value.limit).to eq(12347500000)
   end
 
   it "throws ArgumentError for incorrect limit argument" do
     expect {
-      Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: true)
+      Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer), limit: true)
     }.to raise_error(ArgumentError)
   end
 end