walmart_open 0.0.3 → 0.0.4

data/README.md

@@ -109,25 +109,24 @@ taxonomies = client.taxonomy
 ### Making Commerce API Calls
 ```ruby
 # Placing an Order
-order = WalmartOpen::Order.new({billing_id: 1, first_name: "James",
-                               last_name: "Fong", partner_order_id: "38",
-                               partner_order_time: "16:15:47"})
+order = WalmartOpen::Order.new(billing_id: 1, partner_order_id: "38",
+                               partner_order_time: "16:15:47",
+                               first_name: "James", last_name: "Fong",
+                               street1: "200 Blossom Ln",
+                               street2: "100 Flynn Avenue",
+                               city: "Mountain View",
+                               state: "CA", zipcode: "94043", country: "USA")
 # required fields:
-# billing_id: long, first_name: string
+# billing_id: long, first_name: string, street1: string, city: string,
+  state: string, zipcode: string, country: string, phone: string
 # optional fields:
 # last_name: string
 # partner_order_time: string in format of HH:MM:SS, default to Time.now
 # partner_order_id: string, default to "Order-#{HASH_OF_RAND_AND_ORDER_TIME}"
 
-order.add_shipping_address({street1: "200 Blossom Ln", street2: "100 Flynn Avenue", city: "Mountain View", state: "CA", zipcode: "94043", country: "USA"})
-# required:
-# street1: string, city: string, state: string, zipcode: string, country: string
-# optional:
-# street2: string
-
-# add_item method 1, add_item(item_id, item_price, shipping_price = nil, quantity = 1)
-order.add_item(10371356, 5, 22.94)
-order.add_item(25174174, 214.99)
+# add_item method 1, add_item(item_id, quantity = 1, item_price = nil, shipping_price = nil )
+order.add_item(10371356)
+order.add_item(25174174)
 
 # add_item method 2, add_item(item, quantity = 1)
 order.add_item(client.lookup(10371356))

data/lib/walmart_open/order.rb

@@ -6,9 +6,8 @@ require "securerandom"
 module WalmartOpen
   class Order
 
-    attr_reader :shipping_address
-    attr_accessor :billing_id, :first_name, :last_name, :partner_order_time,
-                  :partner_order_id, :phone, :items
+    attr_reader :shipping_address, :items
+    attr_accessor :billing_record_id, :partner_order_time, :partner_order_id
 
     def initialize(params)
       params = params.each_with_object({}) do |pair, obj|
@@ -17,36 +16,35 @@ module WalmartOpen
 
       @shipping_address = nil
       @items = []
-      @billing_id = params[:billing_id]
-      @first_name = params[:first_name]
-      @last_name = params[:last_name]
-      @phone = params[:phone]
+      @billing_record_id = params[:billing_record_id]
       @partner_order_id = params[:partner_order_id] || "Order-#{Digest::SHA1.hexdigest("#{Time.now.to_i}:#{SecureRandom.hex(16)}")[0..19].upcase}"
       @partner_order_time = params[:partner_order_time] || Time.now
+      @shipping_address = add_shipping_address(params)
     end
 
-    def add_shipping_address(params)
-      @shipping_address = ShippingAddress.new(params)
-    end
-
-    def add_item(item_or_item_id, *args)
+    def add_item(item_or_item_id, quantity = 1, *args)
       if item_or_item_id.is_a?(Item)
         # add_item(item, quantity = 1)
-        @items << OrderItem.new(item_or_item_id.id, item_or_item_id.price, item_or_item_id.shipping_rate, args[0] || 1)
+        @items << OrderItem.new(item_or_item_id.id, quantity, item_or_item_id.price, item_or_item_id.shipping_rate)
       else
-        # add_item(item_id, item_price, shipping_price = 0, quantity = 1)
-        @items <<  OrderItem.new(item_or_item_id, args[0], args[1] || 0, args[2] || 1)
+        # add_item(item_id, quantity = 1, item_price = nil, shipping_price = nil)
+        @items <<  OrderItem.new(item_or_item_id, quantity, args[0], args[1])
       end
     end
 
     def valid?
-      base_values_valid? && !shipping_address.nil? && shipping_address.valid? && items_valid?
+      base_values_valid? && items_valid? &&
+        shipping_address && shipping_address.valid?
     end
 
     private
 
+    def add_shipping_address(params)
+      ShippingAddress.new(params)
+    end
+
     def base_values_valid?
-      billing_id && first_name && partner_order_time && partner_order_id
+      !!(billing_record_id && partner_order_time && partner_order_id)
     end
 
     def items_valid?

data/lib/walmart_open/order_item.rb

@@ -3,7 +3,7 @@ module WalmartOpen
 
     attr_accessor :item_id, :quantity, :item_price, :shipping_price
 
-    def initialize(item_id, item_price, shipping_price = 0, quantity = 1)
+    def initialize(item_id, quantity, item_price = nil, shipping_price = nil)
       @item_id = item_id
       @quantity = quantity
       @item_price = item_price
@@ -11,7 +11,7 @@ module WalmartOpen
     end
 
     def valid?
-      !!(item_id && quantity && item_price && shipping_price)
+      !!(item_id && quantity)
     end
   end
 end

data/lib/walmart_open/order_xml_builder.rb

@@ -32,21 +32,21 @@ module WalmartOpen
 
     def shipping_address(xml)
       xml.shippingAddress do |xml|
-        xml.firstName(order.first_name)
-        xml.lastName(order.last_name)
+        xml.firstName(order.shipping_address.first_name)
+        xml.lastName(order.shipping_address.last_name) if order.shipping_address.last_name
         xml.street1(order.shipping_address.street1)
         xml.street2(order.shipping_address.street2) if order.shipping_address.street2
         xml.city(order.shipping_address.city)
         xml.state(order.shipping_address.state)
         xml.zip(order.shipping_address.zipcode)
         xml.country(order.shipping_address.country)
-        xml.phone(order.phone) if order.phone
+        xml.phone(order.shipping_address.phone)
       end
     end
 
     def payment(xml)
       xml.payment do |xml|
-        xml.billingRecordId(order.billing_id)
+        xml.billingRecordId(order.billing_record_id)
       end
     end
 
@@ -54,8 +54,8 @@ module WalmartOpen
       xml.item do |xml|
         xml.itemId(order_item.item_id)
         xml.quantity(order_item.quantity)
-        xml.itemPrice(order_item.item_price)
-        xml.shippingPrice(order_item.shipping_price)
+        xml.itemPrice(order_item.item_price) if order_item.item_price
+        xml.shippingPrice(order_item.shipping_price) if order_item.shipping_price
       end
     end
   end

data/lib/walmart_open/shipping_address.rb

@@ -1,13 +1,22 @@
 module WalmartOpen
   class ShippingAddress
-    ATTRIBUTES = [
-        :street1,
-        :street2,
-        :city,
-        :state,
-        :zipcode,
-        :country
+    REQUIRED_ATTRIBUTES = [
+      :first_name,
+      :street1,
+      :city,
+      :state,
+      :zipcode,
+      :country,
+      :phone
     ]
+
+    OPTIONAL_ATTRIBUTES = [
+      :last_name,
+      :street2,
+    ]
+
+    ATTRIBUTES = REQUIRED_ATTRIBUTES + OPTIONAL_ATTRIBUTES
+
     attr_reader *ATTRIBUTES
 
     def initialize(params)
@@ -19,7 +28,9 @@ module WalmartOpen
     end
 
     def valid?
-      !!(street1 && city && state && zipcode && country)
+      REQUIRED_ATTRIBUTES.map do |attr|
+        public_send(attr).to_s.empty?
+      end.none?
     end
 
     private

data/lib/walmart_open/version.rb

@@ -1,3 +1,3 @@
 module WalmartOpen
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/walmart_open/order_item_spec.rb

@@ -6,13 +6,38 @@ describe WalmartOpen::OrderItem do
     it "sets value correctly" do
       item_id = 10371356
       item_price = 1.23
-      order_item = WalmartOpen::OrderItem.new(item_id, item_price)
+      item_shipping_price = 2.20
+      order_item = WalmartOpen::OrderItem.new(item_id, 1, item_price, item_shipping_price)
 
       expect(order_item.item_id).to eq(item_id)
-      expect(order_item.item_price).to eq(item_price)
-      expect(order_item.shipping_price).to eq(0)
       expect(order_item.quantity).to eq(1)
+      expect(order_item.item_price).to eq(item_price)
+      expect(order_item.shipping_price).to eq(item_shipping_price)
       expect(order_item).to be_valid
     end
+
+    context "#valid?" do
+      context "when required field are present" do
+        it "returns true" do
+          item_id = 10371356
+          order_item = WalmartOpen::OrderItem.new(item_id, 1)
+
+          expect(order_item.item_id).to eq(item_id)
+          expect(order_item.quantity).to eq(1)
+          expect(order_item).to be_valid
+        end
+      end
+
+      context "when required field are not present" do
+        it "returns false" do
+          item_id = nil
+          order_item = WalmartOpen::OrderItem.new(item_id, 1)
+
+          expect(order_item.item_id).to eq(item_id)
+          expect(order_item.quantity).to eq(1)
+          expect(order_item).not_to be_valid
+        end
+      end
+    end
   end
 end

data/spec/walmart_open/order_spec.rb

@@ -2,65 +2,68 @@ require "spec_helper"
 require "walmart_open/order"
 
 describe WalmartOpen::Order do
-  context "create order" do
-    let(:order_params) do
-      {
-        billing_id:         1,
-        first_name:         "James",
-        last_name:          "Fong",
-        partner_order_id:   "42",
-        phone:              "606-478-0850",
-        partner_order_time: Time.now
-      }
-    end
+  # mix symbol key and string key for testing purpose
+  let(:basic_order_params) do
+    {
+      billing_record_id:       1,
+      partner_order_id:       "42",
+      partner_order_time:     Time.now
+    }
+  end
 
-    let(:shipping_addr_params) do
-      {
-        street1:  "Listia Inc, 200 Blossom Ln",
-        street2:  "street2 test",
-        city:     "Mountain View",
-        state:    "CA",
-        zipcode:  "94043",
-        country:  "USA"
-      }
-    end
+  let(:shipping_addr_params) do
+    {
+      first_name:   "Testfirstname",
+      last_name:    "Fong",
+      street1:      "Listia Inc, 200 Blossom Ln",
+      street2:      "street2 test",
+      city:         "Mountain View",
+      state:        "CA",
+      zipcode:      "94043",
+      country:      "USA",
+      phone:        "606-478-0850"
+    }
+  end
+
+  let(:required_attrs) do
+    [:billing_record_id, :first_name, :street1, :city, :state, :zipcode, :country, :phone]
+  end
 
-    let(:order) { WalmartOpen::Order.new(order_params) }
+  let(:valid_order_params) { basic_order_params.merge(shipping_addr_params)}
+
+  context "create order" do
+    let(:order) { WalmartOpen::Order.new(valid_order_params) }
 
     context ".new" do
       it "sets value correctly" do
-        expect(order.shipping_address).to be_nil
+        expect(order.billing_record_id).to eql(valid_order_params[:billing_record_id])
+        expect(order.partner_order_time).to eq(valid_order_params[:partner_order_time])
+        expect(order.partner_order_id).to eq(valid_order_params[:partner_order_id])
+
+        expect(order.shipping_address).to be_valid
+        expect(order.shipping_address.first_name).to eql(valid_order_params[:first_name])
+        expect(order.shipping_address.last_name).to eql(valid_order_params[:last_name])
+        expect(order.shipping_address.phone).to eql(valid_order_params[:phone])
+
         expect(order.items).to be_empty
-        expect(order.billing_id).to eql(order_params[:billing_id])
-        expect(order.first_name).to eql(order_params[:first_name])
-        expect(order.last_name).to eql(order_params[:last_name])
-        expect(order.phone).to eql(order_params[:phone])
-        expect(order.partner_order_id).to eq(order_params[:partner_order_id])
-        expect(order.partner_order_time).to eq(order_params[:partner_order_time])
       end
 
       it "accepts string keys" do
-        stringified_order_params = order_params.each_with_object({}) do |pair, obj|
+        stringified_valid_attrs = valid_order_params.each_with_object({}) do |pair, obj|
           obj[pair.first.to_s] = pair.last
         end
-        WalmartOpen::Order.new(stringified_order_params)
+        order = WalmartOpen::Order.new(stringified_valid_attrs)
 
-        expect(order.shipping_address).to be_nil
-        expect(order.items).to be_empty
-        expect(order.billing_id).to eql(order_params[:billing_id])
-        expect(order.first_name).to eql(order_params[:first_name])
-        expect(order.last_name).to eql(order_params[:last_name])
-        expect(order.phone).to eql(order_params[:phone])
-        expect(order.partner_order_id).to eq(order_params[:partner_order_id])
-        expect(order.partner_order_time).to eq(order_params[:partner_order_time])
-      end
-    end
+        expect(order.billing_record_id).to eql(valid_order_params[:billing_record_id])
+        expect(order.partner_order_time).to eq(valid_order_params[:partner_order_time])
+        expect(order.partner_order_id).to eq(valid_order_params[:partner_order_id])
 
-    context "#add_shipping_address" do
-      it "sets value correctly" do
-        order.add_shipping_address(shipping_addr_params)
+        expect(order.shipping_address).to be_valid
+        expect(order.shipping_address.first_name).to eql(valid_order_params[:first_name])
+        expect(order.shipping_address.last_name).to eql(valid_order_params[:last_name])
+        expect(order.shipping_address.phone).to eql(valid_order_params[:phone])
 
-        expect(order.shipping_address).not_to be_nil
+        expect(order.items).to be_empty
       end
     end
 
@@ -72,68 +75,55 @@ describe WalmartOpen::Order do
       end
 
       it "adds item by id" do
-        order.add_item(1, 2.0)
+        order.add_item(1)
         expect(order.items).not_to be_empty
       end
     end
   end
 
   context "#valid?" do
-    let(:valid_attrs) do
-      {
-        first_name: "James",
-        billing_id: 1
-      }
-    end
-
-    let(:order) do
-      WalmartOpen::Order.new(valid_attrs).tap do |order|
-        order.add_shipping_address({})
-        order.add_item(10371356, 27.94)
-      end
-    end
-
-    context "when shipping address is valid" do
+    context "when required order params are present" do
       before do
-        allow(order.shipping_address).to receive(:valid?).and_return(true)
+        valid_order_params.delete(:last_name)
+        valid_order_params.delete("street2")
+        @order = WalmartOpen::Order.new(valid_order_params)
+        @order.add_item(1)
       end
 
-      context "when order attributes are valid" do
-        context "when items are valid" do
-          it "returns true" do
-            expect(order).to be_valid
-          end
-        end
-
-        context "when items are not valid" do
-          before do
-            order.add_item(12345)
-          end
-
-          it "returns false" do
-            expect(order).to_not be_valid
-          end
-        end
+      it "returns true" do
+        expect(@order).to be_valid
       end
+    end
 
-      context "when order attributes are not valid" do
+    context "when required order params are not present" do
+      shared_examples_for "missing required key" do |optional_key|
         before do
-          order.first_name = nil
+          valid_order_params.delete(optional_key) if optional_key
         end
 
         it "returns false" do
-          expect(order).to_not be_valid
+          order = WalmartOpen::Order.new(valid_order_params)
+          order.add_item(item_id) if item_id
+
+          expect(order).not_to be_valid
         end
       end
-    end
 
-    context "when shipping address is not valid" do
-      before do
-        allow(order.shipping_address).to receive(:valid?).and_return(false)
+      context "when order item present" do
+        let(:item_id) { 1 }
+        it_behaves_like "missing required key", :billing_record_id
+        it_behaves_like "missing required key", :first_name
+        it_behaves_like "missing required key", :street1
+        it_behaves_like "missing required key", :city
+        it_behaves_like "missing required key", :state
+        it_behaves_like "missing required key", :zipcode
+        it_behaves_like "missing required key", :country
+        it_behaves_like "missing required key", :phone
       end
 
-      it "returns false" do
-        expect(order).to_not be_valid
+      context "when order item not present" do
+        let(:item_id) {nil}
+        it_behaves_like "missing required key", nil
       end
     end
   end

data/spec/walmart_open/shipping_address_spec.rb

@@ -4,31 +4,24 @@ require "walmart_open/shipping_address"
 describe WalmartOpen::ShippingAddress do
   let(:valid_attrs) do
     {
-      street1: "Foo Bar, Maple St.",
-      street2: "Apt #100",
-      city: "Mountain View",
-      state: "CA",
-      zipcode: "94043",
-      country: "USA"
+      first_name:   "Testfirstname",
+      last_name:    "Testlastname",
+      street1:      "Foo Bar, Maple St.",
+      street2:      "Apt #100",
+      city:         "Mountain View",
+      state:        "CA",
+      zipcode:      "94043",
+      country:      "USA",
+      phone:        "1234567"
     }
   end
 
-  let(:required_attrs) do
-    [
-      :street1,
-      :city,
-      :state,
-      :zipcode,
-      :country
-    ]
-  end
+  let(:shipping_address) { WalmartOpen::ShippingAddress.new(valid_attrs) }
 
   context ".new" do
     it "sets attributes" do
-      shipping_address = WalmartOpen::ShippingAddress.new(valid_attrs)
-
-      WalmartOpen::ShippingAddress::ATTRIBUTES.each do |attr|
-        expect(shipping_address.public_send(attr)).to eq(valid_attrs[attr])
+      WalmartOpen::ShippingAddress::ATTRIBUTES.each do |key|
+        expect(shipping_address.public_send(key.to_sym)).to eq(valid_attrs[key])
       end
     end
 
@@ -45,26 +38,103 @@ describe WalmartOpen::ShippingAddress do
   end
 
   context "#valid?" do
-    context "when valid" do
+    shared_examples_for "missing optional key" do |optional_key|
+      before do
+        valid_attrs.delete(optional_key)
+      end
+
       it "returns true" do
         shipping_address = WalmartOpen::ShippingAddress.new(valid_attrs)
 
         expect(shipping_address).to be_valid
       end
+    end
 
-      it "returns true for no street2" do
-        valid_attrs.delete(:street2)
-        shipping_address = WalmartOpen::ShippingAddress.new(valid_attrs)
+    context "when valid" do
+      context "when all required field are present" do
+        it "returns true" do
+          shipping_address = WalmartOpen::ShippingAddress.new(valid_attrs)
 
-        expect(shipping_address).to be_valid
+          expect(shipping_address).to be_valid
+        end
+      end
+
+      context "missing optional key" do
+        context "when no last name" do
+          it "returns true" do
+            valid_attrs.delete(:last_name)
+            expect(shipping_address).to be_valid
+          end
+        end
+
+        context "when no street2" do
+          it "returns true" do
+            valid_attrs.delete(:street2)
+            expect(shipping_address).to be_valid
+          end
+        end
       end
     end
 
     context "when not valid" do
-      it "returns false for missing required attributes" do
-        required_attrs.each do |required_attr|
-          attrs = valid_attrs.reject { |k, _| k == required_attr }
-          expect(WalmartOpen::ShippingAddress.new(attrs)).to_not be_valid
+      shared_examples_for "missing required key" do |optional_key|
+        before do
+          valid_attrs.delete(optional_key) || valid_attrs.delete(optional_key.to_s)
+        end
+
+        it "returns false" do
+          shipping_address = WalmartOpen::ShippingAddress.new(valid_attrs)
+
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required first_name" do
+        it "returns false" do
+          valid_attrs.delete(:first_name)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required street1" do
+        it "returns false" do
+          valid_attrs.delete(:street1)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required city" do
+        it "returns false" do
+          valid_attrs.delete(:city)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required state" do
+        it "returns false" do
+          valid_attrs.delete(:state)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required zipcode" do
+        it "returns false" do
+          valid_attrs.delete(:zipcode)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required country" do
+        it "returns false" do
+          valid_attrs.delete(:country)
+          expect(shipping_address).not_to be_valid
+        end
+      end
+
+      context "missing required phone" do
+        it "returns false" do
+          valid_attrs.delete(:phone)
+          expect(shipping_address).not_to be_valid
         end
       end
     end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: walmart_open
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  prerelease: 
+  version: 0.0.4
 platform: ruby
 authors:
 - Ngan Pham
@@ -9,120 +10,136 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-13 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  type: :runtime
-  prerelease: false
   name: httparty
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.10'
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.10'
-- !ruby/object:Gem::Dependency
   type: :runtime
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: builder
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
-- !ruby/object:Gem::Dependency
-  type: :development
+  type: :runtime
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: bundler
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-- !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: rake
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: rspec
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 3.0.0.beta1
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 3.0.0.beta1
-- !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: debugger
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: timecop
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.7'
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.7'
-- !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
+- !ruby/object:Gem::Dependency
   name: webmock
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.16.0
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.16.0
+  type: :development
+  prerelease: false
 description: Ruby implementation for Walmart Open API.
 email:
 - ngan@listia.com
@@ -177,26 +194,27 @@ files:
 homepage: https://github.com/listia/walmart_open
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Ruby implementation for Walmart Open API
 test_files:
 - spec/spec_helper.rb

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTAwODg3ZDIxMDFmYjVmZGRmMjFmOGYwOTk3NzQ3ODc1ZjVlYjU2Zg==
-  data.tar.gz: !binary |-
-    NmY5MTY3NmJkOTgwNGJkMDg1MDI4MWRkYWQwZTU3MzE5ODgyMzMwOQ==
-SHA512:
-  metadata.gz: !binary |-
-    NGI5M2EwMzhlZjRiZWNiNjVjYmY2ZjYxYjQzMWE1YjRjODVjNzg1ZGNlYmRi
-    YTA1YWUyMzE2YTAzZDI4NTI3Njk5OWM3YzYxYzc4MTkzM2Q2MDhjNGM5ZWYz
-    OWE3YmI5ZGRhMjZiMDFjMDgyNThjODQzZGQzNGQ0N2M1ZjQ3MGM=
-  data.tar.gz: !binary |-
-    Yjg0M2JiNWIyNzhkZmRjN2I5YTU0MDRjMWUwZjU1Y2JhMjU5Njk3YzQ3M2U4
-    ZGZjNTRhMDMwMWExZDNmY2NmYjFhM2UwYjIyYjNiZmJjOGQwNTZkNjU0MzUz
-    YTAzNGI0ZTI1ZDk4MDBjZDcxYmI3NzQ5ODkyMmY3ZTJhOTU0NDQ=