dcparker-shopify 0.1.9 → 0.2.0

data/CHANGELOG

@@ -1,2 +1,5 @@
-v0.1.0 First release, a rewrite of Shopify's own Rails plugin, turned into a gem with similar workings.
+v0.2.0 Second release, using HTTParty, capable of multiple shop connections in one app, and thread-safe.
+
 v0.1.9 2.0 Beta, another rewrite using the light HTTParty instead of ActiveResource.
+
+v0.1.0 First release, a rewrite of Shopify's own Rails plugin, turned into a gem with similar workings.

data/Manifest

@@ -1,7 +1,19 @@
 CHANGELOG
+lib/shopify/extlib/assertions.rb
+lib/shopify/extlib/class.rb
+lib/shopify/extlib/hash.rb
+lib/shopify/extlib/hook.rb
+lib/shopify/extlib/inflection.rb
+lib/shopify/extlib/logger.rb
+lib/shopify/extlib/object.rb
+lib/shopify/extlib/pathname.rb
+lib/shopify/extlib/rubygems.rb
+lib/shopify/extlib/string.rb
+lib/shopify/extlib/time.rb
+lib/shopify/extlib.rb
 lib/shopify/support.rb
 lib/shopify.rb
 LICENSE
 Manifest
-README
+README.textile
 shopify.gemspec

data/README.textile

@@ -0,0 +1,19 @@
+h1. Shopify Rubygem
+
+* Read any kind of data from Shopify, but no support built-in yet to save data back to Shopify.
+* Connect to multiple shops in the same app.
+* Thread-safe.
+
+Example Usage:
+
+<pre>
+  shop = Shopify.new('store_name', 'api-key', 'api-secret', 'auth-token')
+  order = shop.orders(:limit => 1)[0] # => gets first order
+  order.line_items                    # => the line items within that order
+  order.fulfillments                  # => gets all fulfillments related to this order
+  blogs = shop.blogs                  # => gets all blogs for this shop
+  articles = blogs[0].articles        # => gets all the articles in this blog
+  articles[0].comments                # => gets the comments for that article
+  shop.products                       # => get all products in this shop
+  ... and much more ... :)
+</pre>

data/lib/shopify.rb

@@ -2,24 +2,52 @@ include_path = File.expand_path(File.dirname(__FILE__))
 $:.unshift(include_path) unless $:.include?(include_path)
 require 'shopify/support'
 
-module Shopify
-  include HTTParty
+# Class: Shopify
+# Usage:
+#   shop = Shopify.new(host, [key, [secret, [token]]])
+#   shop.orders
+# TODO: Make the object remember the results of queries such as shop.orders when called without parameters,
+#       and reload only when you call shop.orders(true)
+class Shopify
+  attr_reader :host
+
+  def initialize(host, key=nil, secret=nil, token=nil)
+    @default_options = {}
+    extend HTTParty::ClassMethods
 
-  def self.setup(host, key=nil, secret=nil, token=nil)
     host.gsub!(/https?:\/\//, '') # remove http(s)://
     @host = host.include?('.') ? host : "#{host}.myshopify.com" # extend url to myshopify.com if no host is given
     @key    = key
     @secret = secret
     @token  = token
-    if [host, key, secret, token].all?
+    setup
+  end
+
+  def needs_authorization?
+    ![@host, @key, @secret, @token].all?
+  end
+
+  def authorize!(token)
+    @token = token
+    setup
+  end
+
+  def authorization_url(mode='w')
+    "http://#{@host}/admin/api/auth?api_key=#{@key}&mode=#{mode}"
+  end
+
+  def setup
+    unless needs_authorization?
       base_uri "http://#{@host}/admin"
       basic_auth @key, Digest::MD5.hexdigest("#{@secret.chomp}#{@token.chomp}")
       format :xml
-      return false
-    else
-      "http://#{@host}/admin/api/auth?api_key=#{@key}&mode=#{mode}"
     end
   end
+  private :setup
+
+  ##############################
+  ##  Shopify Object Classes  ##
+  ##############################
 
   # /admin/blogs.xml
   class Blog < ShopifyModel
@@ -33,7 +61,7 @@ module Shopify
 
   # /admin/blogs/[blog_id]/articles.xml
   class Article < ShopifyModel
-    child_of Blog
+    children_of Blog
     attr_accessor :author, :blog_id, :body, :body_html, :created_at, :id, :published_at, :title, :updated_at
     def comments(query_params={})
       Shopify.comments(query_params.merge(:article_id => id, :blog_id => blog_id))
@@ -85,9 +113,14 @@ module Shopify
     end
   end
 
+  class LineItem < ShopifyModel
+    children_of Order
+    attr_accessor :fulfillment_service, :grams, :id, :price, :quantity, :sku, :title, :variant_id, :vendor, :name, :product_title
+  end
+
   # /admin/orders/[order_id]/fulfillments.xml
   class Fulfillment < ShopifyModel
-    child_of Order
+    children_of Order
     attr_accessor :id, :order_id, :status, :tracking_number, :line_items, :receipt
   end
 
@@ -113,19 +146,19 @@ module Shopify
 
   # /admin/products/[product_id]/images.xml
   class Image < ShopifyModel
-    child_of Product
+    children_of Product
     attr_accessor :id, :position, :product_id, :src
   end
 
   # /admin/products/[product_id]/variants.xml
   class Variant < ShopifyModel
-    child_of Product
+    children_of Product
     attr_accessor :compare_at_price, :fulfillment_service, :grams, :id, :inventory_management, :inventory_policy, :inventory_quantity, :position, :price, :product_id, :sku, :title
   end
 
   # /admin/countries/[country_id]/provinces.xml
   class Province < ShopifyModel
-    child_of Country
+    children_of Country
     attr_accessor :code, :id, :name, :tax
   end
 
@@ -143,7 +176,7 @@ module Shopify
 
   # /admin/orders/[order_id]/transactions.xml
   class Transaction < ShopifyModel
-    child_of Order
+    children_of Order
     attr_accessor :amount, :authorization, :created_at, :kind, :order_id, :status, :receipt
   end
 end

data/lib/shopify/extlib.rb

@@ -0,0 +1,9 @@
+# :nodoc:all
+
+require 'quickbooks/extlib/class'
+require 'quickbooks/extlib/object'
+require 'quickbooks/extlib/string'
+require 'quickbooks/extlib/hash'
+require 'quickbooks/extlib/time'
+require 'quickbooks/extlib/assertions'
+require 'quickbooks/extlib/inflection'

data/lib/shopify/extlib/assertions.rb

@@ -0,0 +1,8 @@
+module Extlib # :nodoc:all
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

data/lib/shopify/extlib/class.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class # :nodoc:all
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/shopify/extlib/hash.rb

@@ -0,0 +1,327 @@
+class Hash # :nodoc:all
+  ##
+  # Convert to URL query param string
+  #
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+  #
+  # @return [String] This hash as a query string
+  #
+  # @api public
+  def to_params
+    params = self.map { |k,v| normalize_param(k,v) }.join
+    params.chop! # trailing &
+    params
+  end
+
+  ##
+  # Convert a key, value pair into a URL query param string
+  #
+  #   normalize_param(:name, "Bob")   #=> "name=Bob&"
+  #
+  # @param [Object] key The key for the param.
+  # @param [Object] value The value for the param.
+  #
+  # @return <String> This key value pair as a param
+  #
+  # @api public
+  def normalize_param(key, value)
+    param = ''
+    stack = []
+
+    if value.is_a?(Array)
+      param << value.map { |element| normalize_param("#{key}[]", element) }.join
+    elsif value.is_a?(Hash)
+      stack << [key,value]
+    else
+      param << "#{key}=#{value}&"
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          stack << ["#{parent}[#{key}]", value]
+        else
+          param << normalize_param("#{parent}[#{key}]", value)
+        end
+      end
+    end
+
+    param
+  end
+
+  ##
+  # Create a hash with *only* key/value pairs in receiver and +allowed+
+  #
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
+  #
+  # @param [Array[String, Symbol]] *allowed The hash keys to include.
+  #
+  # @return [Hash] A new hash with only the selected keys.
+  #
+  # @api public
+  def only(*allowed)
+    hash = {}
+    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
+  ##
+  # Create a hash with all key/value pairs in receiver *except* +rejected+
+  #
+  #    { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { :two => 2, :three => 3 }
+  #
+  # @param [Array[String, Symbol]] *rejected The hash keys to exclude.
+  #
+  # @return [Hash] A new hash without the selected keys.
+  #
+  # @api public
+  def except(*rejected)
+    hash = self.dup
+    rejected.each {|k| hash.delete(k) }
+    hash
+  end
+
+  # @return <String> The hash as attributes for an XML tag.
+  #
+  # @example
+  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+  #     #=> 'one="1" two="TWO"'
+  def to_xml_attributes
+    map do |k,v|
+      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+    end.join(' ')
+  end
+
+  alias_method :to_html_attributes, :to_xml_attributes
+
+  # @param html_class<#to_s>
+  #   The HTML class to add to the :class key. The html_class will be
+  #   concatenated to any existing classes.
+  #
+  # @example hash[:class] #=> nil
+  # @example hash.add_html_class!(:selected)
+  # @example hash[:class] #=> "selected"
+  # @example hash.add_html_class!("class1 class2")
+  # @example hash[:class] #=> "selected class1 class2"
+  def add_html_class!(html_class)
+    if self[:class]
+      self[:class] = "#{self[:class]} #{html_class}"
+    else
+      self[:class] = html_class.to_s
+    end
+  end
+
+  # Converts all keys into string values. This is used during reloading to
+  # prevent problems when classes are no longer declared.
+  #
+  # @return <Array> An array of they hash's keys
+  #
+  # @example
+  #   hash = { One => 1, Two => 2 }.proctect_keys!
+  #   hash # => { "One" => 1, "Two" => 2 }
+  def protect_keys!
+    keys.each {|key| self[key.to_s] = delete(key) }
+  end
+
+  # Attempts to convert all string keys into Class keys. We run this after
+  # reloading to convert protected hashes back into usable hashes.
+  #
+  # @example
+  #   # Provided that classes One and Two are declared in this scope:
+  #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
+  #   hash # => { One => 1, Two => 2 }
+  def unprotect_keys!
+    keys.each do |key|
+      (self[Object.full_const_get(key)] = delete(key)) rescue nil
+    end
+  end
+
+  # Destructively and non-recursively convert each key to an uppercase string,
+  # deleting nil values along the way.
+  #
+  # @return <Hash> The newly environmentized hash.
+  #
+  # @example
+  #   { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
+  #     #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }
+  def environmentize_keys!
+    keys.each do |key|
+      val = delete(key)
+      next if val.nil?
+      self[key.to_s.upcase] = val
+    end
+    self
+  end
+end
+
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the
+# underlying parser.
+class REXMLUtilityNode # :nodoc:all
+  attr_accessor :name, :attributes, :children, :type
+  cattr_accessor :typecasts, :available_typecasts
+
+  self.typecasts = {}
+  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
+  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
+  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
+  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
+  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
+  self.typecasts["string"]        = lambda{|v| v.to_s}
+  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
+
+  self.available_typecasts = self.typecasts.keys
+
+  def initialize(name, attributes = {})
+    @name         = name.tr("-", "_")
+    # leave the type alone if we don't know what it is
+    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+    @nil_element  = attributes.delete("nil") == "true"
+    @attributes   = undasherize_keys(attributes)
+    @children     = []
+    @text         = false
+  end
+
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+
+  def to_hash
+    if @type == "file"
+      f = StringIO.new((@children.first || '').unpack('m').first)
+      class << f
+        attr_accessor :original_filename, :content_type
+      end
+      f.original_filename = attributes['name'] || 'untitled'
+      f.content_type = attributes['content_type'] || 'application/octet-stream'
+      return {name => f}
+    end
+
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #change repeating groups into an array
+      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+      out = nil
+      if @type == "array"
+        out = []
+        groups.each do |k, v|
+          if v.size == 1
+            out << v.first.to_hash.entries.first.last
+          else
+            out << v.map{|e| e.to_hash[k]}
+          end
+        end
+        out = out.flatten
+
+      else # If Hash
+        out = {}
+        groups.each do |k,v|
+          if v.size == 1
+            out.merge!(v.first)
+          else
+            out.merge!( k => v.map{|e| e.to_hash[k]})
+          end
+        end
+        out.merge! attributes unless attributes.empty?
+        out = out.empty? ? nil : out
+      end
+
+      if @type && out.nil?
+        { name => typecast_value(out) }
+      else
+        { name => out }
+      end
+    end
+  end
+
+  # Typecasts a value based upon its type. For instance, if
+  # +node+ has #type == "integer",
+  # {{[node.typecast_value("12") #=> 12]}}
+  #
+  # @param value<String> The value that is being typecast.
+  #
+  # @details [:type options]
+  #   "integer"::
+  #     converts +value+ to an integer with #to_i
+  #   "boolean"::
+  #     checks whether +value+, after removing spaces, is the literal
+  #     "true"
+  #   "datetime"::
+  #     Parses +value+ using Time.parse, and returns a UTC Time
+  #   "date"::
+  #     Parses +value+ using Date.parse
+  #
+  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+  #   The result of typecasting +value+.
+  #
+  # @note
+  #   If +self+ does not have a "type" key, or if it's not one of the
+  #   options specified above, the raw +value+ will be returned.
+  def typecast_value(value)
+    return value unless @type
+    proc = self.class.typecasts[@type]
+    proc.nil? ? value : proc.call(value)
+  end
+
+  # Convert basic XML entities into their literal values.
+  #
+  # @param value<#gsub> An XML fragment.
+  #
+  # @return <#gsub> The XML fragment after converting entities.
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
+  end
+
+  # Take keys of the form foo-bar and convert them to foo_bar
+  def undasherize_keys(params)
+    params.keys.each do |key, value|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+
+  # Get the inner_html of the REXML node.
+  def inner_html
+    @children.join
+  end
+
+  # Converts the node into a readable HTML node.
+  #
+  # @return <String> The HTML node in text form.
+  def to_html
+    attributes.merge!(:type => @type ) if @type
+    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+  end
+
+  # @alias #to_html #to_s
+  def to_s
+    to_html
+  end
+end