mad_cart 0.0.1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+vendor
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.ruby-gemset
+.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mad_cart.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 MadMimi
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,117 @@
+# MadCart
+
+Provides a unified API to various CRMs and online stores.
+Simple configuration allows you to specify the properties you're interested in and what they're called.
+A flexible DSL allows easy CRM and store integration.
+
+Currently supports the following stores:
+**-Etsy**
+**-Bigcommerce**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mad_cart'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mad_cart
+
+## Usage
+
+#### Credentials
+
+Store/CRM credentials can be configured:
+
+```ruby
+MadCart.configure do |config|
+  config.add_store :etsy, api_key: 'my-api-key', store_url: 'http://path.to/store'
+end
+
+store = MadCart::Store::Etsy.new
+```
+...or passed to the store initializer:
+
+```ruby
+store = MadCart::Store::Etsy.new(api_key: 'my-api-key', store_url: 'http://path.to/store')
+```
+
+### Products
+
+```ruby
+store = MadCart::Store::Etsy.new
+
+store.products
+#=> an array of MadCart::Model::Product objects
+```
+
+### Customers
+```ruby
+store = MadCart::Store::BigCommerce.new
+
+store.customers
+# => returns an array of MadCart::Model::Customer objects
+```
+
+### Attributes
+
+Each model object has a property called attributes, which returns a hash. By default the following properties are returned:
+
+**Customers:** *first_name*, *last_name*, and *email*
+**Products:** *name*, *description*, and *image_url*
+
+#### Additional Attributes
+
+Any additional attributes returned by the CRM or store API will be stored in the *additional_attributes* property of the object.
+MadCart allows you to include any of these additional attributes in the #attributes property of the model objects:
+
+```ruby
+store = MadCart::Store::Etsy.new
+
+store.products.first.attributes
+#=> {name: 'product name', description: 'product description', image_url 'http://path.to/image'}
+
+MadCart.configure do |config|
+  config.include_attributes products: [:external_id, :url]
+end
+
+store.products.first.attributes
+#=> {name: 'product name', description: 'product description', image_url 'http://path.to/image', external_id: 42, url: 'http://path.to/store/products/42'}
+```
+
+#### Attribute Names
+
+MadCart allows you to change the names of these attributes to match your existing field names:
+
+```ruby
+MadCart.configure do |config|
+  config.attribute_map :products, {"name" => "title"}
+end
+
+store = MadCart::Store::Etsy.new
+
+store.products.first.attributes
+#=> {title: 'product name', description: 'product description', image_url 'http://path.to/image'}
+```
+
+This, in combination with declaring additional attributes, allows for very thin integration points without sacrificing customizability:
+
+```ruby
+store = MadCart::Store::Etsy.new
+store.products.each{|p| MyProduct.create!(p.attributes) }
+```
+
+## Contributing
+
+See the [Contributor's Guide](https://github.com/madmimi/mad_cart/wiki/Contributor's-Guide) for info on the store integration API.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'yaml'
+load 'vcr/tasks/vcr.rake'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/lib/mad_cart/attribute_mapper.rb

@@ -0,0 +1,35 @@
+module MadCart
+  module AttributeMapper
+
+    # def attributes
+    #       Hash[initial_attributes.map {|k, v| [(mapping_hash[k] || mapping_hash[k.to_sym] || k).to_s, v] }]
+    #     end
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    def attributes
+      Hash[self.class.exposed_attributes.map{|a| [a.to_s, self.send(a)]}]
+    end
+    
+    module ClassMethods
+      def map_attribute_name(name)
+        mapping_hash[name.to_sym] || mapping_hash[name.to_s] || name
+      end
+      
+      def mapping_hash
+        MadCart.config.attribute_maps[self.to_s.demodulize.underscore.pluralize] || {}
+      end
+      
+      def mapped_attributes
+        mapping_hash.values
+      end
+      
+      def unmapped_attributes
+        mapping_hash.keys
+      end
+    end
+
+  end
+end

data/lib/mad_cart/configuration.rb

@@ -0,0 +1,59 @@
+require 'ostruct'
+
+module MadCart
+  class << self
+    def configure
+      raise(ArgumentError, "MadCart.configure requires a block argument.") unless block_given?
+      yield(MadCart::Configuration.instance)
+    end
+
+    def config
+      raise(ArgumentError, "MadCart.config does not support blocks. Use MadCart.configure to set config values.") if block_given?
+      return MadCart::Configuration.instance.data
+    end
+  end
+  
+  class Configuration
+    include Singleton
+
+    def add_store(store_name, args={})
+      setup_data
+
+      @data[:stores] << store_name
+      @data[store_name.to_s] = args
+    end
+
+    def attribute_map(data_model, attributes)
+      setup_data
+
+      @data[:attribute_maps][data_model.to_s] = attributes
+    end
+
+    def include_attributes(args={})
+      setup_data
+
+      @data[:included_attributes].merge!(args)
+    end
+
+    def data
+      setup_data
+      Data.new(@data)
+    end
+
+    private
+    def setup_data
+      @data ||= {:stores => []}
+      @data[:attribute_maps] ||= {}
+      @data[:included_attributes] ||= {}
+    end
+
+    class Data < OpenStruct
+      class ConfigurationError < NoMethodError; end
+
+      def method_missing(meth, *args)
+        return nil
+      end
+
+    end
+  end
+end

data/lib/mad_cart/inheritable_attributes.rb

@@ -0,0 +1,27 @@
+module MadCart
+  module InheritableAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inheritable_attributes(*args)
+        @madcart_inheritable_attributes ||= [:inheritable_attributes]
+        @madcart_inheritable_attributes += args
+        args.each do |arg|
+          class_eval %(
+            class << self; attr_accessor :#{arg} end
+          )
+        end
+        @madcart_inheritable_attributes
+      end
+
+      def inherited(subclass)
+        @madcart_inheritable_attributes.each do |inheritable_attribute|
+          instance_var = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+        end
+      end
+    end
+  end
+end

data/lib/mad_cart/model/base.rb

@@ -0,0 +1,68 @@
+module MadCart
+  module Model
+    module Base
+      def initialize(args={})
+        self.additional_attributes = {}
+        check_required_attributes(args)
+        args.each { |k,v| set_attribute(k, v) }
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          include AttributeMapper
+          include InheritableAttributes
+          attr_accessor :additional_attributes
+          inheritable_attributes :required_attrs
+          attr_accessor *exposed_attributes
+        end
+      end
+
+      def define_attribute_accessors
+        klass.class_eval do
+          attr_accessor(*exposed_attributes)
+        end
+      end
+
+      def check_required_attributes(args)
+        keys = args.keys.map{|a| a.to_s }
+        klass.required_attrs.each do |attr|
+          raise(ArgumentError, "missing argument: #{attr}") if !keys.include?(attr)
+        end
+      end
+      private :check_required_attributes
+
+      def set_attribute(key, value)
+        attr_name = klass.map_attribute_name(key)
+        
+        if klass.exposed_attributes.include? attr_name.to_s
+          define_attribute_accessors unless self.respond_to?(attr_name)
+          self.send("#{attr_name}=", value) unless value.nil?
+        else
+          self.additional_attributes[attr_name.to_s] = value unless value.nil?
+        end
+      end
+      private :set_attribute
+
+      def klass
+        self.class
+      end
+      private :klass
+
+      module ClassMethods
+        def required_attributes(*args)
+          @required_attrs = args.map{|a| a.to_s }
+          attr_accessor *args
+        end
+
+        def exposed_attributes
+          ((self.required_attrs || []) + included_attributes + mapped_attributes).uniq.map{|a| a.to_s } - unmapped_attributes.map{|a| a.to_s }
+        end
+
+        def included_attributes
+          MadCart.config.included_attributes[self.to_s.demodulize.underscore.pluralize.to_sym] || []
+        end
+      end
+    end
+  end
+end

data/lib/mad_cart/model/customer.rb

@@ -0,0 +1,9 @@
+module MadCart
+  module Model
+    class Customer
+      include MadCart::Model::Base
+
+      required_attributes :first_name, :last_name, :email
+    end
+  end
+end

data/lib/mad_cart/model/product.rb

@@ -0,0 +1,9 @@
+module MadCart
+  module Model
+    class Product
+      include MadCart::Model::Base
+
+       required_attributes :name, :description, :image_url
+    end
+  end
+end

data/lib/mad_cart/store/base.rb

@@ -0,0 +1,151 @@
+module MadCart
+  module Store
+    class SetupError < StandardError
+      def self.message
+        "It appears MyStore has overrided the default "\
+        "MadCart::Base initialize method. That's fine, but please store "\
+        "any required connection arguments as @init_args for the "\
+        "#connection method to use later. Remember to call #after_initialize "\
+        "in your initialize method should you require it."
+      end
+    end
+    class InvalidStore < StandardError; end
+
+    module Base
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          include InheritableAttributes
+          inheritable_attributes :connection_delegate, :required_connection_args,
+            :fetch_delegates, :format_delegates, :after_init_delegate
+        end
+      end
+
+      def initialize(*args)
+        set_init_args(*args)
+        after_initialize(*args)
+      end
+
+      def connection
+        validate_connection_args!
+        return init_connection
+      end
+
+      def init_connection
+        @connection ||= execute_delegate(klass.connection_delegate, @init_args)
+      end
+
+      def klass
+        self.class
+      end
+      private :klass
+
+      def execute_delegate(delegate, *args)
+        return self.send(delegate, *args) if delegate.is_a?(Symbol)
+        return delegate.call(*args) if delegate.is_a?(Proc)
+
+        raise ArgumentError, "Invalid delegate" # if not returned by now
+      end
+      private :execute_delegate
+
+      def after_initialize(*args)
+        return nil unless klass.after_init_delegate
+        execute_delegate(klass.after_init_delegate, *args)
+      end
+      private :after_initialize
+
+      def validate_connection_args!
+        return true if klass.required_connection_args.empty?
+
+        raise(SetupError, SetupError.message) if @init_args.nil?
+        raise(ArgumentError,"Missing connection arguments: "\
+              "#{missing_args.join(', ')}") if missing_args.present?
+      end
+      private :validate_connection_args!
+
+      def missing_args
+        klass.required_connection_args - @init_args.keys
+      end
+      private :missing_args
+
+      def set_init_args(*args)
+        @init_args ||= configured_connection_args.merge(args.last || {})
+      end
+      private :set_init_args
+
+      def configured_connection_args
+        MadCart.config.send(klass.to_s.demodulize.underscore) || {}
+      end
+      private :configured_connection_args
+
+      def ensure_model_format(model, results)
+        if results.first.is_a?(MadCart::Model::Base)
+          results
+        else
+          map_to_madcart_model(model, results)
+        end
+      end
+      private :ensure_model_format
+
+      def map_to_madcart_model(model, results)
+        results.map do |args|
+          "MadCart::Model::#{model.to_s.classify}".constantize.new(args)
+        end
+      end
+      private :map_to_madcart_model
+
+      module ClassMethods
+        def create_connection_with(*args)
+          @connection_delegate = parse_delegate(args.first, :create_connection_with)
+          opts = args[1] || {}
+          @required_connection_args = opts[:requires] || []
+        end
+
+        def fetch(model, options={})
+          @fetch_delegates ||= {}
+          @format_delegates ||= {}
+          @fetch_delegates[model] = parse_delegate(options, :fetch)
+
+          define_method_for(model)
+        end
+
+        def format(model, options={})
+          if @fetch_delegates[model].nil?
+            raise ArgumentError, "Cannot define 'format' for a model that has not defined 'fetch'"
+          end
+
+          @format_delegates[model] = parse_delegate(options, :format)
+        end
+
+        def after_initialize(*args)
+          @after_init_delegate = parse_delegate(args.first, :after_initialize)
+        end
+
+        def parse_delegate(arg, method)
+          return arg if (arg.is_a?(Symbol) || arg.is_a?(Proc))
+          return arg[:with] if arg.is_a?(Hash) && arg[:with]
+
+          raise ArgumentError, "Invalid delegate for #{method}: "\
+            "#{arg.first.class}. Use Proc or Symbol. "
+        end
+        private :parse_delegate
+
+        def define_method_for(model)
+          define_method model do |*args|
+            fetch_result = execute_delegate(self.class.fetch_delegates[model], *args)
+            formatted_result = if self.class.format_delegates[model]
+                                 formatter = self.class.format_delegates[model]
+                                 fetch_result.map{|r| execute_delegate(formatter, r)}
+                               else
+                                 fetch_result
+                               end
+
+            return ensure_model_format(model, formatted_result)
+          end
+        end
+        private :define_method_for
+
+      end
+    end
+  end
+end

data/lib/mad_cart/store/big_commerce.rb

@@ -0,0 +1,118 @@
+module MadCart
+  module Store
+    class BigCommerce
+      class InvalidStore < StandardError; end;
+      class ServerError < StandardError; end;
+      class InvalidCredentials < StandardError; end;
+      
+      include MadCart::Store::Base
+
+      create_connection_with :create_connection, :requires => [:api_key, :store_url, :username]
+      fetch :customers, :with => :get_customer_hashes
+      fetch :products, :with => :get_products
+      
+      def valid?
+        check_for_errors do
+          connection.get('time.json')
+        end
+        return true
+        
+      rescue InvalidCredentials => e
+        return false
+      end
+
+      def products_count
+        (parse_response { connection.get('products/count.json') })["count"]
+      end
+
+      private
+
+      def make_customer_request(params={:min_id => 1})
+        parse_response { connection.get('customers.json', params) }
+      end
+      
+      def get_products(options={})
+        product_hashes = connection.get('products.json', options).try(:body)
+        return [] unless product_hashes
+        
+        threads, images = [], []
+        product_hashes.each do |product|
+          threads << Thread.new do
+            if product["images"]
+              url = "#{product["images"]["resource"][1..-1]}.json"
+              images << parse_response { connection.get(url) }
+            end
+          end
+        end
+        threads.each { |t| t.join }                
+
+        product_hashes.map do |p|
+
+          product_images = images.find { |i| i.first['product_id'] == p['id'] }
+          thumbnail = product_images.find { |i| i["is_thumbnail"] }
+          image     = product_images.sort_by{|i| i["sort_order"] }.find { |i| i["is_thumbnail"] }
+
+          p.merge({ 
+            :image_square_url => connection.build_url("/product_images/#{thumbnail['image_file']}").to_s,
+            :image_url        => connection.build_url("/product_images/#{image['image_file']}").to_s,
+          })
+        end
+      end
+
+      def get_customer_hashes
+        result = []
+        loop(:make_customer_request) {|c| result << c }
+        return result
+      end
+
+      def loop(source, &block)
+
+        items = send(source, :min_id => 1)
+
+        while true
+          items.each &block
+          break if items.count < 200
+          items = send(source, :min_id => items.max_id + 1 )
+        end
+
+      end
+
+      def parse_response(&block)
+        response = check_for_errors &block
+        return [] if empty_body?(response)
+        return response.body
+      end
+
+      def check_for_errors(&block)
+        response = yield
+
+        case response.status
+        when 401
+          raise InvalidCredentials
+        when 500
+          raise ServerError
+        end
+
+        response
+      rescue Faraday::Error::ConnectionFailed => e
+        raise InvalidStore
+      end
+
+      def api_url_for(store_domain)
+       "https://#{store_domain}/api/v2/"
+      end
+
+      def empty_body?(response)
+        true if response.status == 204 || response.body.nil?
+      end
+
+      def create_connection(args={})
+        @connection = Faraday.new(:url => api_url_for(args[:store_url]))
+        @connection.basic_auth(args[:username], args[:api_key])
+        @connection.response :json
+        @connection.adapter Faraday.default_adapter
+        @connection
+      end
+    end
+  end
+end