crystal_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27cacb6013a18cec21a77b3fe9b85ef9af918f80
+  data.tar.gz: 2aacba745040e1048f1f584b92b45c0fe87af2ba
+SHA512:
+  metadata.gz: 419ba56c0705c86cdf9fd9dd93a450f143deb3615c753cdc61f371f8b3ffd143e8dd3ef27bc5efd0f9e82bba03c359bbac87b248c5e9da9d689e05d29c51ebae
+  data.tar.gz: 0891392e5ff703c08f30d9c422f2882567cc39b61234235e2faa53028ce892593c7cf7442868f44127985567aad82108c5494013b9c83b6f6e319245a7435b49

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

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 crystal_api.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/crystal_api/attributes\.rb$}) { |m| "spec" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('spec/support/*.rb')    { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Donald Plummer
+
+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,50 @@
+# CrystalApi
+
+A library for using the CrystalCommerce API in Ruby. See
+http://apidocs.crystalcommerce.com for API documentation.
+
+## TODO
+
+* Receiving Webhook payload verification
+* Sending Webhook payload signing
+* Switch to http client that the user of the gem can override the
+  backend, so that async http calls can be made (faraday?)
+* Remove git ls-files usage from gemspec
+* Add usage documentation to apidocs site
+* Define behavior for http responses (404, 403, 500, etc)
+* Allow user of gem to specify json parsing library (MultiJSON)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'crystal_api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install crystal_api
+
+## Usage
+
+    store_endpoint = CrystalApi::StoreEndpoint.new(
+      base_url: "https://apitest-api.crystalcommerce.com/v1",
+      token: "your-oauth2-token"
+    )
+
+    store_prefs = store_endpoint.get("/prefs/store")
+
+## Contributing
+
+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
+
+## License
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/crystal_api.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crystal_api/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "crystal_api"
+  gem.version       = CrystalApi::VERSION
+  gem.authors       = ["Donald Plummer"]
+  gem.email         = ["donald@crystalcommerce.com"]
+  gem.description   = %q{A library for using the CrystalCommerce API.}
+  gem.summary       = %q{A library for using the CrystalCommerce API.}
+  gem.homepage      = "http://apidocs.crystalcommerce.com"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "money", "~> 5"
+  gem.add_dependency "values", "~> 1.2.1"
+  gem.add_dependency "activesupport"
+  gem.add_dependency "httparty"
+  gem.add_dependency "multi_json"
+
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
+  gem.add_development_dependency 'guard', '~> 1.2.3'
+  gem.add_development_dependency 'guard-rspec', '~> 1.2.1'
+  gem.add_development_dependency 'vcr', '~> 2.2.4'
+  gem.add_development_dependency 'webmock', '~> 1.8.0'
+  gem.add_development_dependency 'libnotify'
+  gem.add_development_dependency 'rb-inotify', '~> 0.8.8'
+  gem.add_development_dependency 'pry'
+end

data/lib/crystal_api.rb

@@ -0,0 +1,51 @@
+$: << (File.join(File.dirname(__FILE__)))
+
+require "crystal_api/version"
+require 'money'
+require 'active_support'
+require 'multi_json'
+
+module CrystalApi
+  CannotParseJson = Class.new(StandardError)
+
+  def self.from_json(object)
+    find_klass(object.keys.first).from_json(object)
+  end
+
+  def self.find_klass(word)
+    camel_cased_word = ActiveSupport::Inflector.camelize(word)
+
+    if CrystalApi.const_defined?("#{camel_cased_word}")
+      CrystalApi.const_get(camel_cased_word)
+    else
+      raise CrystalApi::CannotParseJson.new("No objects to parse #{word}!")
+    end
+  end
+end
+
+require 'crystal_api/money'
+require 'crystal_api/attributes'
+require 'crystal_api/variant'
+require 'crystal_api/webhook_envelope'
+require 'crystal_api/store'
+require 'crystal_api/received_webhook_parser'
+require 'crystal_api/variant_descriptor'
+require 'crystal_api/product'
+require 'crystal_api/photo'
+require 'crystal_api/url'
+require 'crystal_api/product_descriptor'
+require 'crystal_api/category'
+require 'crystal_api/market_prices'
+require 'crystal_api/descriptor'
+require 'crystal_api/store_prefs'
+require 'crystal_api/webhook'
+require 'crystal_api/paginated_collection'
+require 'crystal_api/report'
+
+require 'crystal_api/error_response'
+require 'crystal_api/store_endpoint'
+require 'crystal_api/webhook_registration'
+
+require 'crystal_api/hmac_request_signing'
+require 'crystal_api/message_verifier'
+require 'crystal_api/webhook_verifier'

data/lib/crystal_api/attributes.rb

@@ -0,0 +1,210 @@
+require 'set'
+require 'bigdecimal'
+
+module CrystalApi
+  module Attributes
+    class NoRootElementDefined < StandardError
+    end
+
+    module ClassMethods
+      attr_reader :attributes
+
+      [:integer, :decimal, :string, :object, :datetime, :date, :url].each do |type|
+        define_method("#{type}_attribute") do |attribute_name|
+          attr_reader attribute_name
+          @attributes[attribute_name.to_s] = type
+        end
+      end
+
+      def boolean_attribute(attribute_name)
+        attr_reader attribute_name
+        @attributes[attribute_name.to_s] = :boolean
+
+        if matches = attribute_name.to_s.match(/^is_(.*)$/)
+          define_method("#{matches[1]}?") do
+            send(attribute_name)
+          end
+        else
+          alias_method "#{attribute_name}?", attribute_name
+        end
+      end
+
+      def embedded_attribute(attribute_name, type = :object)
+        attr_reader attribute_name
+        @attributes[attribute_name.to_s] = [:embedded, type]
+      end
+
+      def array_attribute(attribute_name, type = :object)
+        attr_reader attribute_name
+        @attributes[attribute_name.to_s] = [:array, type]
+      end
+
+      def hash_attribute(attribute_name, type)
+        attr_reader attribute_name
+        @attributes[attribute_name.to_s] = [:hash, type]
+      end
+
+      def attribute(attribute_name)
+        attr_reader attribute_name
+        @attributes[attribute_name.to_s] = :unknown
+      end
+
+      def root_element(elem)
+        @root_element = elem.to_s
+      end
+
+      def get_root_element
+        klass = self
+        @root_element || raise(NoRootElementDefined.new("No root element was defined for #{klass.name}"))
+      end
+
+      def from_json(json_hash)
+        json_attributes = json_hash.fetch(get_root_element, json_hash)
+        embedded = json_attributes.delete("_embedded") || {}
+        attrs = attributes.inject({}) do |acc, (attr, type)|
+          if Array(type).first == :embedded
+            val = embedded[attr]
+          else
+            val = json_attributes[attr]
+          end
+          acc[attr] = val unless val.nil?
+          acc
+        end
+        new(attrs)
+      end
+    end
+
+    def initialize(args = {})
+      unexpected_keys = []
+
+      args.each do |arg, value|
+        if self.class.attributes.has_key?(arg.to_s)
+          instance_variable_set("@#{arg}", parse_arg(arg, value))
+        else
+          unexpected_keys << arg
+        end
+      end
+
+      if !unexpected_keys.empty?
+        raise ArgumentError.new("Unexpected hash keys: #{unexpected_keys}")
+      end
+
+      self.freeze
+    end
+
+    def self.included(receiver)
+      receiver.extend(ClassMethods)
+      receiver.class_eval do
+        @attributes = {}
+      end
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def eql?(other)
+      return false if other.class != self.class
+      self.class.attributes.keys.all? do |field|
+        self.send(field) == other.send(field)
+      end
+    end
+
+    def hash
+      result = 0
+      self.class.attributes.keys.each do |field|
+        result += self.send(field).hash
+      end
+      return result + self.class.hash
+    end
+
+    def as_json(options = {})
+      {
+        root_key => self.class.attributes.inject({}) { |acc, (key, _)|
+          unless options.fetch(:except, []).include?(key.to_sym)
+            value = send(key)
+            acc[key.to_s] = value.respond_to?(:as_json) ? value.as_json : value
+          end
+          acc
+        }
+      }
+    end
+
+    private
+
+    def root_key
+      self.class.get_root_element.to_s
+    end
+
+    def parse_arg(arg, value)
+      type, type2 = self.class.attributes[arg.to_s]
+      if type
+        if type2 && value
+          send("parse_#{type}", value, type2)
+        else
+          send("parse_#{type}", value)
+        end
+      end
+    end
+
+    def parse_integer(value)
+      value.to_i
+    end
+
+    def parse_decimal(value)
+      BigDecimal.new(value.to_s) unless value.nil?
+    end
+
+    def parse_boolean(value)
+      value == 'true' || value == '1' || value == true
+    end
+
+    def parse_string(value)
+      value.to_s
+    end
+
+    def parse_datetime(value)
+      DateTime.parse(value) if value
+    end
+
+    def parse_date(value)
+      Date.parse(value) if value
+    end
+
+    def parse_url(value)
+      Url.new(value)
+    end
+
+    def parse_array(value, type = :object)
+      value.map do |val|
+        send("parse_#{type}", val)
+      end
+    end
+
+    def parse_hash(value, type = :object)
+      value.inject({}) do |acc, (key, val)|
+        acc[key] = send("parse_#{type}", val)
+        acc
+      end
+    end
+
+    def parse_object(value)
+      return value unless value.is_a?(Hash)
+
+      klass = CrystalApi.find_klass(value.keys.first)
+      klass.from_json(value) if klass
+    end
+
+    def parse_embedded(value, type)
+      send("parse_#{type}", value)
+    end
+
+    def parse_unknown(value)
+      if value.is_a?(Hash)
+        parse_object(value)
+      elsif value.is_a?(Array)
+        parse_array(value)
+      end
+    end
+  end
+end

data/lib/crystal_api/category.rb

@@ -0,0 +1,28 @@
+module CrystalApi
+  class Category
+    include Attributes
+
+    root_element :category
+
+    integer_attribute :id
+    integer_attribute :catalog_id
+
+    string_attribute :name
+    string_attribute :seoname
+
+    boolean_attribute :is_root
+    boolean_attribute :is_leaf
+    boolean_attribute :is_visible_for_selling
+    boolean_attribute :is_visible_for_buying
+
+    string_attribute :description
+    string_attribute :browse_layout
+
+    hash_attribute :catalog_links, :url
+    hash_attribute :buylist_links, :url
+
+    array_attribute :descriptors
+
+    embedded_attribute :ancestors, :array
+  end
+end