ecwid_api 0.0.2 → 0.1.0

data/lib/ecwid_api/paged_ecwid_response.rb

@@ -0,0 +1,55 @@
+require_relative "paged_enumerator"
+
+# Public: Presents a paged Ecwid response as an Enumerator with a
+# PagedEnumerator
+#
+# Example
+#
+#   response = PagedEcwidResponse.new(client, "products", priceFrom: 10) do |product_hash|
+#     Product.new(product_hash, click: client)
+#   end
+#
+#   response.each do |product|
+#     # do stuff the the product
+#   end
+#
+module EcwidApi
+  class PagedEcwidResponse
+    include Enumerable
+    extend  Forwardable
+
+    def_delegator :@paged_enumerator, :each
+
+    # Public: Initialize a new PagedEcwidResponse
+    #
+    # client - an EcwidApi::Client
+    # path   - a String that is the path to retrieve from the client
+    # params - a Hash of parameters to pass along with the request
+    # &block - a Block that processes each item returned in the Response
+    #
+    def initialize(client, path, params = {}, &block)
+      params[:limit] = 100
+      params.delete(:offset)
+
+      block ||= Proc.new { |item| item }
+
+      response = client.get(path, params)
+
+      @paged_enumerator = PagedEnumerator.new(response) do |response, yielder|
+        response.body["items"].each do |item|
+          yielder << block.call(item)
+        end
+
+        count, offset, total = %w(count offset total).map do |i|
+          response.body[i].to_i
+        end
+
+        if count == 0 || count + offset >= total
+          false
+        else
+          client.get(path, params.merge(offset: offset + count))
+        end
+      end
+    end
+  end
+end

data/lib/ecwid_api/paged_enumerator.rb

@@ -0,0 +1,66 @@
+module EcwidApi
+  # Public: Abstracts pagination into an Enumerator so all of the objects for
+  # a given response can be retreived without having to know that they were
+  # split into pages from the server
+  #
+  # Examples
+  #
+  #   client.get("orders", limit: 10)
+  #
+  #   paged = PagedEnumerator.new(orders) do |response, yielder|
+  #     response.body["orders"].each do |obj|
+  #       yielder << obj
+  #     end
+  #
+  #     next_url = response.body["nextUrl"]
+  #     next_url ? client.get(next_url) : false
+  #   end
+  #
+  #   paged.each do |item|
+  #     puts item.inspect
+  #   end
+  #
+  class PagedEnumerator
+    include Enumerable
+
+    # Private: A response that we are evaluating
+    attr_reader :response
+    private     :response
+
+    # Private: Gets the next response
+    attr_reader :next_block
+    private     :next_block
+
+    # Public: Initializes a new PagedEnumerator
+    #
+    # response   - the response that contains a collection of objects
+    # next_block - The block will receive the response and a yielder Proc.
+    #              The block should use `yielder << item` to yield all of
+    #              the items in the collection.
+    #
+    #              Then the block should return the next response. If no
+    #              response is given (eg: the last page), the block should
+    #              return a falsey value.
+    #
+    def initialize(response, &next_block)
+      @response, @next_block = response, next_block
+    end
+
+    # Public: Iterates over each "page" yielding each "item" in every collection
+    def each(&block)
+      unless @next_enumerator
+        @yielder ||= []
+        @next_response ||= next_block.call(response, @yielder)
+
+        if @next_response
+          @next_enumerator ||= PagedEnumerator.new(@next_response, &@next_block)
+        else
+          @next_enumerator = []
+        end
+      end
+
+      @yielder.each(&block)
+      @next_enumerator.each(&block)
+    end
+  end
+end

data/lib/ecwid_api/person.rb

@@ -0,0 +1,7 @@
+module EcwidApi
+  class Person < Entity
+    ecwid_reader :name, :companyName, :street, :city, :countryCode,
+                 :countryName, :postalCode, :stateOrProvinceCode,
+                 :stateOrProvinceName, :phone
+  end
+end

data/lib/ecwid_api/product.rb

@@ -0,0 +1,77 @@
+require "open-uri"
+
+module EcwidApi
+	class Product < Entity
+    self.url_root = "products"
+
+    ecwid_reader :id, :sku, :quantity, :unlimited, :inStock, :name, :price,
+                 :priceInProductList, :wholesalePrices, :compareToPrice,
+                 :weight, :url, :created, :updated, :productClassId,
+                 :enabled, :options, :warningLimit, :fixedShippingRateOnly,
+                 :fixedShippingRate, :defaultCombinationId, :thumbnailUrl,
+                 :imageUrl, :smallThumbnailUrl, :originalImageUrl, :description,
+                 :galleryImages, :categoryIds, :defaultCategoryId, :favorites,
+                 :attributes, :files, :relatedProducts, :combinations
+
+    ecwid_writer :sku, :name, :quantity, :price, :wholesalePrices,
+                 :compareToPrice, :weight, :productClassId, :enabled, :options,
+                 :warningLimit, :fixedShippingRateOnly, :fixedShippingRate,
+                 :description, :categoryIds, :defaultCategoryId, :attributes,
+                 :relatedProducts
+
+    # Public: Uploads a primary image for a Product
+    #
+    # filename - a String that is either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def upload_image!(filename)
+      client.post("#{url}/image") do |req|
+        req.body = open(filename).read
+      end.tap do |response|
+        raise_on_failure(response)
+      end
+    end
+
+    # Public: Uploads gallery images for a Product
+    #
+    # *filenames - Strings that are either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns an Array of Faraday::Response object
+    def upload_gallery_images!(*filenames)
+      filenames.map do |filename|
+        client.post("#{url}/gallery") do |req|
+          req.body = open(filename).read
+        end.tap do |response|
+          raise_on_failure(response)
+        end
+      end
+    end
+
+    # Public: Deletes all of the gallery images for a Product
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def delete_gallery_images!
+      client.delete("#{url}/gallery").tap do |response|
+        raise_on_failure(response)
+      end
+    end
+
+    def combinations
+      @combinations ||= Api::ProductCombinations.new(self, client)
+    end
+
+    def created
+      @created ||= Time.parse(super)
+    end
+
+    def updated
+      @updated ||= Time.parse(super)
+    end
+	end
+end

data/lib/ecwid_api/product_combination.rb

@@ -0,0 +1,34 @@
+module EcwidApi
+  class ProductCombination < Entity
+    attr_reader :product
+
+    self.url_root = -> { "products/#{product.id}/combinations" }
+
+    ecwid_reader :id, :combinationNumber, :options, :sku, :smallThumbnailUrl,
+                 :thumbnailUrl, :imageUrl, :originalImageUrl, :quantity,
+                 :unlimited, :price, :wholesalePrices, :weight, :warningLimit
+
+    ecwid_writer :options, :sku, :quantity, :unlimited, :price,
+                 :wholesalePrices, :weight, :warningLimit, :inventoryDelta
+
+    def initialize(data, opts={})
+      super(data, opts)
+      @product = opts[:product]
+    end
+
+    # Public: Uploads a primary image for a ProductCombination
+    #
+    # filename - a String that is either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def upload_image!(filename)
+      client.post("#{url}/image") do |req|
+        req.body = open(filename).read
+      end.tap do |response|
+        raise_on_failure(response)
+      end
+    end
+  end
+end

data/lib/ecwid_api/version.rb

@@ -1,3 +1,3 @@
 module EcwidApi
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/ecwid_api.rb

@@ -1,39 +1,25 @@
-require "ecwid_api/version"
-require "ext/string"
-
-# Public: This is the main namespace for the EcwidApi. It can be used to store
-# the default client.
-#
-module EcwidApi
-  autoload :Client, "ecwid_api/client"
-  autoload :Error, "ecwid_api/error"
-  autoload :Entity, "ecwid_api/entity"
-
-  autoload :CategoryApi, "ecwid_api/category_api"
-  autoload :Category, "ecwid_api/category"
-
-  class << self
-    # Public: Gets and configures a default client
-    #
-    # To configure the default client, just pass a block.
-    #
-    # Examples
-    #
-    #   EcwidApi.default_client do |config|
-    #     config.store_id = '12345'
-    #     config.order_secret_key = 'ORDER_SECRET_KEY'
-    #     config.product_secret_key = 'PRODUCT_SECRET_KEY'
-    #   end
-    #
-    #   client = EcwidApi.default_client.store_id
-    #   # => "12345"
-    #
-    # Returns an EcwidApi::Client, or null if one hasn't been configured
-    def default_client(&block)
-      if block_given?
-        @default_client = Client.new(&block)
-      end
-      @default_client
-    end
-  end
-end
+require "ecwid_api/version"
+require "ext/string"
+require 'faraday'
+require 'faraday_middleware'
+
+require_relative "ecwid_api/error"
+
+# Public: This is the main namespace for the EcwidApi. It can be used to store
+# the default client.
+#
+module EcwidApi
+  autoload :OAuth, "ecwid_api/o_auth"
+  autoload :Client, "ecwid_api/client"
+  autoload :ResponseError, "ecwid_api/error"
+  autoload :Entity, "ecwid_api/entity"
+  autoload :Api, "ecwid_api/api"
+
+  autoload :Category, "ecwid_api/category"
+  autoload :Order, "ecwid_api/order"
+  autoload :OrderItem, "ecwid_api/order_item"
+  autoload :Person, "ecwid_api/person"
+  autoload :ProductCombination, "ecwid_api/product_combination"
+
+  autoload :Product,    "ecwid_api/product"
+end

data/lib/ext/string.rb

@@ -1,5 +1,13 @@
-class String
-  def camel_case
-    split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
-  end
+class String
+  def camel_case
+    split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+  end unless method_defined?(:camel_case)
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end unless method_defined?(:underscore)
 end

data/spec/api/categories_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe EcwidApi::Api::Categories, faraday: true do
+  subject { client.categories }
+
+  describe "#all" do
+    it "gets all of the categories from the client" do
+      expect(client).to receive(:get).with("categories", hash_including({})).and_call_original
+      subject.all
+    end
+
+    it "gets sub categories" do
+      expect(client).to receive(:get).with("categories", hash_including(parent: 5)).and_call_original
+      subject.all(parent: 5)
+    end
+  end
+
+  describe "#root" do
+    it "gets the root level categories" do
+      expect(subject).to receive(:all).with(hash_including(parent: 0)).and_call_original
+      subject.root
+    end
+  end
+
+  describe "#find" do
+    it "finds a single category" do
+      expect(client).to receive(:get).with("categories/#{5}").and_call_original
+      subject.find(5)
+    end
+  end
+end

data/spec/api/orders_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe EcwidApi::Api::Orders, faraday: true do
+  subject { client.orders }
+
+  describe "#all" do
+    it "passes the parameters to the client" do
+      expect(client).to receive(:get).with("orders", hash_including(from_date: '1982-05-17'))
+      subject.all(from_date: '1982-05-17')
+    end
+
+    it "gets the proper response (see fixtures)" do
+      subject.all.count.should == 2
+    end
+
+    it "gets EcwidApi::Order types" do
+      subject.all.all? { |order| order.is_a?(EcwidApi::Order) }.should be_true
+    end
+  end
+
+  describe "#find" do
+    it "is an `EcwidApi::Order`" do
+      subject.find(35).is_a?(EcwidApi::Order).should be_true
+    end
+
+    it "is nil when not found" do
+      subject.find(404).should be_nil
+    end
+  end
+end

data/spec/api/products_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe EcwidApi::Api::Products, faraday: true do
+  subject { client.products }
+
+  describe "#all" do
+    it "passes any other paramters through" do
+      expect(client).to receive(:get).with("products", hash_including(from_date: '1982-05-17'))
+      subject.all(from_date: '1982-05-17')
+    end
+
+    it "gets the proper response count (see fixture)" do
+      subject.all.count.should == 5
+    end
+
+    it "gets the proper product (see fixture)" do
+      subject.all.first.sku.should == "NC53090"
+    end
+  end
+end

data/spec/category_spec.rb

@@ -1,39 +1,34 @@
-require 'spec_helper'
-
-describe EcwidApi::Category, faraday: true do
-  let(:client) { EcwidApi::Client.new { |config| config.store_id = '12345' } }
-  subject { EcwidApi::Category.new({"id" => 123, "parentId" => 456}, client: client) }
-
-  before(:each) do
-    faraday_client(client)
-  end
-
-  describe "#sub_categories" do
-    it "sends the request to the CategoryApi" do
-      expect(client.categories).to receive(:all).with(123)
-      subject.sub_categories
-    end
-
-    it "is memoized" do
-      subject.sub_categories
-      expect(client.categories).to_not receive(:all)
-      subject.sub_categories
-    end
-  end
-
-  describe "#parent" do
-    it "sends the request for the parent to the CategoryApi" do
-      expect(client.categories).to receive(:find).with(456)
-      subject.parent
-    end
-
-    context "without a parent" do
-      subject { EcwidApi::Category.new({"id" => 123}) }
-
-      it "returns nil" do
-        expect(client.categories).to_not receive(:find)
-        subject.parent.should be_nil
-      end
-    end
-  end
+require 'spec_helper'
+
+describe EcwidApi::Category, faraday: true do
+  subject { EcwidApi::Category.new({"id" => 123, "parentId" => 456}, client: client) }
+
+  describe "#sub_categories" do
+    it "sends the request to the CategoryApi" do
+      expect(client.categories).to receive(:all).with(parent: 123)
+      subject.sub_categories
+    end
+
+    it "is memoized" do
+      subject.sub_categories
+      expect(client.categories).to_not receive(:all)
+      subject.sub_categories
+    end
+  end
+
+  describe "#parent" do
+    it "sends the request for the parent to the CategoryApi" do
+      expect(client.categories).to receive(:find).with(456)
+      subject.parent
+    end
+
+    context "without a parent" do
+      subject { EcwidApi::Category.new({"id" => 123}) }
+
+      it "returns nil" do
+        expect(client.categories).to_not receive(:find)
+        subject.parent.should be_nil
+      end
+    end
+  end
 end

data/spec/client_spec.rb

@@ -1,49 +1,21 @@
-require "spec_helper"
-
-describe EcwidApi::Client do
-  subject do
-    EcwidApi::Client.new do |config|
-      config.store_id = store_id
-    end
-  end
-  let(:store_id) { 12345 }
-
-  context "without a store_id" do
-    it "raises an error" do
-      expect { EcwidApi::Client.new }.to raise_error(EcwidApi::Error, /store_id/)
-    end
-  end
-
-  describe "#url" do
-    its(:url) { "http://app.ecwid.com/api/v1" }
-
-    it "can be overridden" do
-      client = EcwidApi::Client.new do |config|
-        config.store_id = store_id
-        config.url = "http://ladida.com"
-      end
-
-      client.url.should == "http://ladida.com"
-    end
-  end
-
-  describe "#store_url" do
-    its(:store_url) { "http://app.ecwid.com/api/v1/12345" }
-  end
-
-  describe "#get", faraday: true do
-    before(:each) do
-      faraday_client(subject)
-    end
-
-    it "delegates to the Faraday connection" do
-      expect(subject.send(:connection)).to receive(:get).with("categories", parent: 1)
-
-      subject.get "categories", parent: 1
-    end
-
-    it "returns a Faraday::Response" do
-      subject.get("categories", parent: 1).is_a?(Faraday::Response).should be_true
-    end
-  end
+require "spec_helper"
+
+describe EcwidApi::Client do
+  subject { client }
+
+  describe "#store_url" do
+    its(:store_url) { "http://app.ecwid.com/api/v3/12345" }
+  end
+
+  describe "#get", faraday: true do
+    it "delegates to the Faraday connection" do
+      expect(subject.send(:connection)).to receive(:get).with("categories", parent: 1)
+
+      subject.get "categories", parent: 1
+    end
+
+    it "returns a Faraday::Response" do
+      subject.get("categories", parent: 1).is_a?(Faraday::Response).should be_true
+    end
+  end
 end

data/spec/entity_spec.rb

@@ -1,9 +1,47 @@
 require 'spec_helper'
 
+class EntitySubject < EcwidApi::Entity
+  self.url_root = "stuff"
+
+  ecwid_reader :id, :parentId, :type, :modify, :override
+  ecwid_writer :writeOnly
+  ecwid_accessor :theStatus
+
+  def override
+    super.upcase
+  end
+end
+
+class EntityUrlSubject < EcwidApi::Entity
+  ecwid_reader :id, :parentId
+
+  self.url_root = -> { "parent/#{parent_id}/and" }
+end
+
 describe EcwidApi::Entity do
-  let(:data) { {"id" => 123, "parentId" => 456} }
+  let(:data) do
+    {
+      "id" => 123,
+      "parentId" => 456,
+      "type" => "AWESOME",
+      "theStatus" => "YOUNG",
+      "hidden" => "tee hee",
+      "writeOnly" => "write me!",
+      "override" => "upcase me"
+    }
+  end
+
+  subject { EntitySubject.new(data) }
+
+  describe "::url_root" do
+    its(:url) { should == "stuff/123" }
+
+    context "with a proc" do
+      subject { EntityUrlSubject.new(data) }
+      its(:url) { should == "parent/456/and/123" }
+    end
+  end
 
-  subject { EcwidApi::Entity.new(data) }
 
   describe "#[]" do
     it "gets data with a symbol key" do
@@ -13,11 +51,58 @@ describe EcwidApi::Entity do
     it "gets data with a string key" do
       subject["parentId"].should == 456
     end
+
+    it "get nil for unknown data" do
+      subject["whatever"].should be_nil
+    end
+
+    it "gets attributes not revealed by ecwid_reader or ecwid_accessor" do
+      subject["hidden"].should == "tee hee"
+    end
+  end
+
+  describe "overrides" do
+    its(:override) { should == "UPCASE ME" }
   end
 
-  describe "#method_missing" do
-    it "gets data with snake_cased messages" do
-      subject.parent_id.should == 456
+  describe "accessors" do
+
+    describe "::ecwid_reader" do
+      it "makes data accessible with a snake cased method" do
+        subject.parent_id.should == 456
+      end
+
+      it "doesn't have a writer" do
+        expect { subject.parent_id = 4 }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "::ecwid_writer" do
+      it "creates a writer method" do
+        subject.write_only = "yee haw!"
+        subject["writeOnly"].should == "yee haw!"
+      end
+
+      it "doesn't have a reader" do
+        expect { subject.write_only }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "::ecwid_accessor" do
+      it "creates a reader and a writer" do
+        subject.the_status = "MATURE"
+        subject.the_status.should == "MATURE"
+      end
+    end
+
+    describe "without an accessor" do
+      it "is accessible with []" do
+        subject[:hidden].should == "tee hee"
+      end
+
+      it "doesn't have an access method" do
+        expect { subject.hidden }.to raise_error(NoMethodError)
+      end
     end
   end
 end